{
private FixedTableModel model;
private RectF tableRect;
private RectF lastRect;
private int numElements;
private int lastElement;
protected FixedTableModelIterator(FixedTableModel model, RectF tableRect, int numElements) {
this.model = model;
this.tableRect = tableRect;
this.numElements = numElements;
lastRect = new RectF(
tableRect.left,
tableRect.top,
tableRect.left + model.getCellWidth(),
tableRect.top + model.getCellHeight());
}
@Override
public boolean hasNext() {
// was this the last element or is there no room in either axis for another cell?
return !(lastElement >= numElements || (isColumnFinished() && isRowFinished()));
}
private boolean isColumnFinished() {
return lastRect.bottom + model.getCellHeight() > tableRect.height();
}
private boolean isRowFinished() {
return lastRect.right + model.getCellWidth() > tableRect.width();
}
@Override
public RectF next() {
try {
if (lastElement == 0) {
return lastRect;
}
if (lastElement >= numElements) {
throw new IndexOutOfBoundsException();
}
switch (model.getOrder()) {
case ROW_MAJOR:
if (isColumnFinished()) {
moveOverAndUp();
} else {
moveDown();
}
break;
case COLUMN_MAJOR:
if (isRowFinished()) {
moveDownAndBack();
} else {
moveOver();
}
break;
default:
throw new UnsupportedOperationException();
}
return lastRect;
} finally {
lastElement++;
}
}
private void moveDownAndBack() {
//RectF rect = new RectF(lastRect);
lastRect.offsetTo(tableRect.left, lastRect.bottom);
//return rect;
}
private void moveOverAndUp() {
//RectF rect = new RectF(lastRect);
lastRect.offsetTo(lastRect.right, tableRect.top);
//return rect;
}
private void moveOver() {
//RectF rect = new RectF(lastRect);
lastRect.offsetTo(lastRect.right, lastRect.top);
//return rect;
}
private void moveDown() {
//RectF rect = new RectF(lastRect);
lastRect.offsetTo(lastRect.left, lastRect.bottom);
//return rect;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/Formatter.java 0000664 0000000 0000000 00000003717 12711435674 0030311 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import android.content.Context;
import com.androidplot.Plot;
import com.androidplot.util.Configurator;
/**
* Base class of all Formatters. Encapsulates visual elements of a series; line style, color etc.
* Implementors of this class should include both a default constructor and a one argument
* constructor in the following form:
*
*
* {@code
* // provided as a convenience to users; allows instantiation and
* // xml configuration in a single line.
* public MyFormatter(Context ctx, int xmlCfgId) {
* // prevent configuration of classes derived from this one:
* if (getClass().equals(MyFormatter.class)) {
* Configurator.configure(ctx, this, xmlCfgId);
* }
* }
*
*/
public abstract class Formatter {
public Formatter configure(Context ctx, int xmlCfgId) {
Configurator.configure(ctx, this, xmlCfgId);
return this;
}
/**
*
* @return The Class of SeriesRenderer that should be used.
*/
public abstract Class getRendererClass();
/**
*
* @return An instance of SeriesRenderer that took plot as an argument to its constructor.
*/
public abstract SeriesRenderer getRendererInstance(PlotType plot);
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/LayoutManager.java 0000664 0000000 0000000 00000021134 12711435674 0031107 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import android.graphics.*;
import android.view.MotionEvent;
import android.view.View;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.widget.Widget;
import com.androidplot.util.DisplayDimensions;
import com.androidplot.util.ZLinkedList;
public class LayoutManager extends ZLinkedList
implements View.OnTouchListener, Resizable {
private boolean drawAnchorsEnabled = false;
private Paint anchorPaint;
private boolean drawOutlinesEnabled = false;
private Paint outlinePaint;
private boolean drawOutlineShadowsEnabled = false;
private Paint outlineShadowPaint;
private boolean drawMarginsEnabled = false;
private Paint marginPaint;
private boolean drawPaddingEnabled = false;
private Paint paddingPaint;
private DisplayDimensions displayDims = new DisplayDimensions();
{
anchorPaint = new Paint();
anchorPaint.setStyle(Paint.Style.FILL);
anchorPaint.setColor(Color.GREEN);
outlinePaint = new Paint();
outlinePaint.setColor(Color.GREEN);
outlinePaint.setStyle(Paint.Style.STROKE);
outlinePaint.setAntiAlias(true);
outlinePaint.setStrokeWidth(2);
marginPaint = new Paint();
marginPaint.setColor(Color.YELLOW);
marginPaint.setStyle(Paint.Style.FILL);
marginPaint.setAlpha(200);
paddingPaint= new Paint();
paddingPaint.setColor(Color.BLUE);
paddingPaint.setStyle(Paint.Style.FILL);
paddingPaint.setAlpha(200);
}
/**
* Invoked immediately following XML configuration.
*/
public synchronized void onPostInit() {
for(Widget w : elements()) {
w.onPostInit();
}
}
public LayoutManager() {
}
public void setMarkupEnabled(boolean enabled) {
setDrawOutlinesEnabled(enabled);
setDrawAnchorsEnabled(enabled);
setDrawMarginsEnabled(enabled);
setDrawPaddingEnabled(enabled);
setDrawOutlineShadowsEnabled(enabled);
}
public void draw(Canvas canvas) throws PlotRenderException {
if(isDrawMarginsEnabled()) {
drawSpacing(canvas, displayDims.canvasRect, displayDims.marginatedRect, marginPaint);
}
if (isDrawPaddingEnabled()) {
drawSpacing(canvas, displayDims.marginatedRect, displayDims.paddedRect, paddingPaint);
}
for (Widget widget : elements()) {
//int canvasState = canvas.save(Canvas.ALL_SAVE_FLAG); // preserve clipping etc
try {
canvas.save(Canvas.ALL_SAVE_FLAG);
PositionMetrics metrics = widget.getPositionMetrics();
float elementWidth = widget.getWidthPix(displayDims.paddedRect.width());
float elementHeight = widget.getHeightPix(displayDims.paddedRect.height());
PointF coords = widget.getElementCoordinates(elementHeight,
elementWidth, displayDims.paddedRect, metrics);
DisplayDimensions dims = widget.getWidgetDimensions();
if (drawOutlineShadowsEnabled) {
canvas.drawRect(dims.canvasRect, outlineShadowPaint);
}
// not positive why this is, but the rect clipped by clipRect is 1 less than the one drawn by drawRect.
// so this is necessary to avoid clipping borders. I suspect that its a floating point
// jitter issue.
if (widget.isClippingEnabled()) {
canvas.clipRect(dims.canvasRect, Region.Op.INTERSECT);
}
widget.draw(canvas, dims.canvasRect);
if (drawMarginsEnabled) {
drawSpacing(canvas, dims.canvasRect, dims.marginatedRect, getMarginPaint());
}
if (drawPaddingEnabled) {
drawSpacing(canvas, dims.marginatedRect, dims.paddedRect, getPaddingPaint());
}
if (drawAnchorsEnabled) {
PointF anchorCoords =
Widget.getAnchorCoordinates(coords.x, coords.y, elementWidth,
elementHeight, metrics.getAnchor());
drawAnchor(canvas, anchorCoords);
}
if (drawOutlinesEnabled) {
canvas.drawRect(dims.canvasRect, outlinePaint);
}
} finally {
canvas.restore();
}
}
}
private void drawSpacing(Canvas canvas, RectF outer, RectF inner, Paint paint) {
try {
canvas.save(Canvas.ALL_SAVE_FLAG);
canvas.clipRect(inner, Region.Op.DIFFERENCE);
canvas.drawRect(outer, paint);
} finally {
canvas.restore();
}
}
protected void drawAnchor(Canvas canvas, PointF coords) {
float anchorSize = 4;
canvas.drawRect(coords.x-anchorSize, coords.y-anchorSize, coords.x+anchorSize, coords.y+anchorSize, anchorPaint);
}
public boolean isDrawOutlinesEnabled() {
return drawOutlinesEnabled;
}
public void setDrawOutlinesEnabled(boolean drawOutlinesEnabled) {
this.drawOutlinesEnabled = drawOutlinesEnabled;
}
public Paint getOutlinePaint() {
return outlinePaint;
}
public void setOutlinePaint(Paint outlinePaint) {
this.outlinePaint = outlinePaint;
}
public boolean isDrawAnchorsEnabled() {
return drawAnchorsEnabled;
}
public void setDrawAnchorsEnabled(boolean drawAnchorsEnabled) {
this.drawAnchorsEnabled = drawAnchorsEnabled;
}
public boolean isDrawMarginsEnabled() {
return drawMarginsEnabled;
}
public void setDrawMarginsEnabled(boolean drawMarginsEnabled) {
this.drawMarginsEnabled = drawMarginsEnabled;
}
public Paint getMarginPaint() {
return marginPaint;
}
public void setMarginPaint(Paint marginPaint) {
this.marginPaint = marginPaint;
}
public boolean isDrawPaddingEnabled() {
return drawPaddingEnabled;
}
public void setDrawPaddingEnabled(boolean drawPaddingEnabled) {
this.drawPaddingEnabled = drawPaddingEnabled;
}
public Paint getPaddingPaint() {
return paddingPaint;
}
public void setPaddingPaint(Paint paddingPaint) {
this.paddingPaint = paddingPaint;
}
public boolean isDrawOutlineShadowsEnabled() {
return drawOutlineShadowsEnabled;
}
public void setDrawOutlineShadowsEnabled(boolean drawOutlineShadowsEnabled) {
this.drawOutlineShadowsEnabled = drawOutlineShadowsEnabled;
if(drawOutlineShadowsEnabled && outlineShadowPaint == null) {
// use a default shadow effect in the case where none has been set:
outlineShadowPaint = new Paint();
outlineShadowPaint.setColor(Color.DKGRAY);
outlineShadowPaint.setStyle(Paint.Style.FILL);
outlineShadowPaint.setShadowLayer(3, 5, 5, Color.BLACK);
}
}
public Paint getOutlineShadowPaint() {
return outlineShadowPaint;
}
public void setOutlineShadowPaint(Paint outlineShadowPaint) {
this.outlineShadowPaint = outlineShadowPaint;
}
@Override
public boolean onTouch(View v, MotionEvent event) {
return false;
}
/**
* Recalculates layouts for all widgets using last set
* DisplayDimensions. Care should be excersized when choosing when
* to call this method as it is a relatively slow operation.
*/
public void refreshLayout() {
for (Widget widget : elements()) {
widget.layout(displayDims);
}
}
@Override
public void layout(final DisplayDimensions dims) {
this.displayDims = dims;
refreshLayout();
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/LayoutMetric.java 0000664 0000000 0000000 00000003721 12711435674 0030762 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
abstract class LayoutMetric {
private LayoutType layoutType;
//private LayoutType layoutType;
private float value;
//private float lastRow;
public LayoutMetric(float value, LayoutType layoutType) {
validatePair(value, layoutType);
set(value, layoutType);
//setLayoutType(layoutType);
//setValue(value);
//setLayoutType(layoutType);
}
/**
* Verifies that the values passed in are valid for the layout algorithm being used.
* @param value
* @param layoutType
*/
protected abstract void validatePair(float value, LayoutType layoutType);
public void set(float value, LayoutType layoutType) {
validatePair(value, layoutType);
this.value = value;
this.layoutType = layoutType;
}
public float getValue() {
return value;
}
public void setValue(float value) {
validatePair(value, layoutType);
this.value = value;
}
public abstract float getPixelValue(float size);
public LayoutType getLayoutType() {
return layoutType;
}
public void setLayoutType(LayoutType layoutType) {
validatePair(value, layoutType);
this.layoutType = layoutType;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/PositionMetric.java 0000664 0000000 0000000 00000005357 12711435674 0031320 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
public abstract class PositionMetric extends LayoutMetric {
protected enum Origin {
FROM_BEGINING,
FROM_CENTER,
FROM_END
}
protected enum LayoutMode {
ABSOLUTE,
RELATIVE
}
public PositionMetric(float value, LayoutType layoutType) {
super(value, layoutType);
}
/**
* Throws IllegalArgumentException if there is a problem.
* @param value
* @param layoutMode
* @throws IllegalArgumentException
*/
protected static void validateValue(float value, LayoutMode layoutMode) throws IllegalArgumentException {
switch(layoutMode) {
case ABSOLUTE:
break;
case RELATIVE:
if(value < -1 || value > 1) {
throw new IllegalArgumentException("Relative layout values must be within the range of -1 to 1.");
}
break;
default:
throw new IllegalArgumentException("Unknown LayoutMode: " + layoutMode);
}
}
protected float getAbsolutePosition(float size, Origin origin) {
switch(origin) {
case FROM_BEGINING:
return getValue();
case FROM_CENTER:
return (size/2f) + getValue();
case FROM_END:
return size - getValue();
default:
throw new IllegalArgumentException("Unsupported Origin: " + origin);
}
}
protected float getRelativePosition(float size, Origin origin) {
//throw new UnsupportedOperationException("Not yet implemented.");
switch(origin) {
case FROM_BEGINING:
return size * getValue();
case FROM_CENTER:
return (size/2f) + ((size/2f) * getValue());
case FROM_END:
return size + (size*getValue());
default:
throw new IllegalArgumentException("Unsupported Origin: " + origin);
}
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/PositionMetrics.java 0000664 0000000 0000000 00000004047 12711435674 0031476 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
public class PositionMetrics implements Comparable {
private XPositionMetric xPositionMetric;
private YPositionMetric yPositionMetric;
private AnchorPosition anchor;
private float layerDepth;
public PositionMetrics(float x, XLayoutStyle xLayoutStyle, float y, YLayoutStyle yLayoutStyle, AnchorPosition anchor) {
setXPositionMetric(new XPositionMetric(x, xLayoutStyle));
setYPositionMetric(new YPositionMetric(y, yLayoutStyle));
setAnchor(anchor);
}
public YPositionMetric getYPositionMetric() {
return yPositionMetric;
}
public void setYPositionMetric(YPositionMetric yPositionMetric) {
this.yPositionMetric = yPositionMetric;
}
public AnchorPosition getAnchor() {
return anchor;
}
public void setAnchor(AnchorPosition anchor) {
this.anchor = anchor;
}
@Override
public int compareTo(PositionMetrics o) {
if(this.layerDepth < o.layerDepth) {
return -1;
} else if(this.layerDepth == o.layerDepth) {
return 0;
} else {
return 1;
}
}
public XPositionMetric getXPositionMetric() {
return xPositionMetric;
}
public void setXPositionMetric(XPositionMetric xPositionMetric) {
this.xPositionMetric = xPositionMetric;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/RenderBundle.java 0000664 0000000 0000000 00000002747 12711435674 0030721 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import com.androidplot.Series;
import com.androidplot.xy.XYSeriesFormatter;
public abstract class RenderBundle {
//private XYDataset series;
private Series series;
private SeriesFormatterType formatter;
public RenderBundle(SeriesType series, SeriesFormatterType formatter) {
this.formatter = formatter;
this.series = series;
}
public Series getSeries() {
return series;
}
public void setSeries(Series series) {
this.series = series;
}
public SeriesFormatterType getFormatter() {
return formatter;
}
public void setFormatter(SeriesFormatterType formatter) {
this.formatter = formatter;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/RenderStack.java 0000664 0000000 0000000 00000006757 12711435674 0030562 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import com.androidplot.Plot;
import com.androidplot.Series;
import java.util.ArrayList;
import java.util.List;
/**
* A stack of series to be rendered. The stack order is immutable but individual elements may be
* manipulated via the public methods of {@link RenderStack.StackElement}.
*/
public class RenderStack {
private final Plot plot;
private final ArrayList> elements;
public ArrayList> getElements() {
return elements;
}
/**
* An element on the render stack.
*/
public class StackElement {
private SeriesAndFormatter seriesAndFormatter;
private boolean isEnabled = true;
public StackElement(SeriesAndFormatter seriesAndFormatter) {
set(seriesAndFormatter);
}
public SeriesAndFormatter get() {
return seriesAndFormatter;
}
public void set(SeriesAndFormatter seriesAndFormatter) {
this.seriesAndFormatter = seriesAndFormatter;
}
public boolean isEnabled() {
return isEnabled;
}
/**
* Enable or disable a stack element for rendering. Has no effect on StackElements that
* have already been rendered.
* @param isEnabled
*/
public void setEnabled(boolean isEnabled) {
this.isEnabled = isEnabled;
}
}
public RenderStack(Plot plot) {
this.plot = plot;
elements = new ArrayList<>(plot.getSeriesRegistry().size());
}
/**
* Syncs the stack structure with plot's current state. Should be called before
* rendering series data to an XYGraphWidget.
*/
public void sync() {
/**
* TODO: rendering performance *might* be improved by reusing StackElement instances but I'm skeptical...
*/
getElements().clear();
List> pairList = plot.getSeriesRegistry();
for(SeriesAndFormatter thisPair: pairList) {
getElements().add(new StackElement<>(thisPair));
}
}
/**
* Invokes {@link RenderStack.StackElement#setEnabled(boolean)} with a value
* of false on all stack elements associated with the specified renderer.
* @param rendererClass
*/
public void disable(Class rendererClass) {
for(RenderStack.StackElement element : getElements()) {
if(element.get().getFormatter().getRendererClass() == rendererClass) {
element.setEnabled(false);
}
}
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/Resizable.java 0000664 0000000 0000000 00000003034 12711435674 0030256 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import com.androidplot.util.DisplayDimensions;
/**
* Used by classes that depend on dimensional values to lay themselves out and draw.
* Consideration should be given to synchronizing with any draw routines that also
* exist within the class.
*/
public interface Resizable {
/**
* Called when a change to the class' dimensions is made. This method is responsible
* for cascading calls to update for any logical children of this class, for example
* the Plot class is responsible for updating the LayoutManager. Note that while dims
* is marked final in this interface, the compiler will not enforce it. Implementors of
* this method should take care not to make changes to dims as this will affect parent
* Resizables in likely undesired ways.
* @param dims
*/
public void layout(final DisplayDimensions dims);
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/SeriesAndFormatter.java 0000664 0000000 0000000 00000002521 12711435674 0032077 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import com.androidplot.Series;
/**
* Defines an association between a Series and a Formatter.
*/
public class SeriesAndFormatter {
private final SeriesType series;
private final FormatterType formatter;
public SeriesAndFormatter(SeriesType series, FormatterType formatter) {
this.series = series;
this.formatter = formatter;
}
public SeriesType getSeries() {
return series;
}
public FormatterType getFormatter() {
return formatter;
}
public boolean rendersWith(SeriesRenderer renderer) {
return getFormatter().getRendererClass() == renderer.getClass();
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/SeriesRenderer.java 0000664 0000000 0000000 00000010053 12711435674 0031256 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import android.graphics.Canvas;
import android.graphics.RectF;
import android.graphics.Region;
import com.androidplot.Series;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.Plot;
import java.util.ArrayList;
import java.util.List;
public abstract class SeriesRenderer
{
private PlotType plot;
public SeriesRenderer(PlotType plot) {
this.plot = plot;
}
public PlotType getPlot() {
return plot;
}
public void setPlot(PlotType plot) {
this.plot = plot;
}
public SeriesFormatterType getFormatter(SeriesType series) {
return (SeriesFormatterType) plot.getFormatter(series, getClass());
}
/**
*
* @param canvas
* @param plotArea
* @param sfPair The series / formatter pair to be rendered
* @throws PlotRenderException
*/
public void render(Canvas canvas, RectF plotArea, SeriesAndFormatter sfPair, RenderStack stack) throws PlotRenderException {
onRender(canvas, plotArea, sfPair.getSeries(), sfPair.getFormatter(), stack);
}
/**
*
* @param canvas
* @param plotArea
* @param series The series to be rendered
* @param formatter The getFormatter that should be used to render the series
* @param stack Ordered list of all series being renderered. May be manipulated by the Renderer
* to gain effect.
* @throws PlotRenderException
*/
protected abstract void onRender(Canvas canvas, RectF plotArea, SeriesType series,
SeriesFormatterType formatter, RenderStack stack) throws PlotRenderException;
/**
* Draw the legend icon in the rect passed in.
* @param canvas
* @param rect
*/
protected abstract void doDrawLegendIcon(Canvas canvas, RectF rect, SeriesFormatterType formatter);
public void drawSeriesLegendIcon(Canvas canvas, RectF rect, SeriesFormatterType formatter) {
try {
canvas.save(Canvas.ALL_SAVE_FLAG);
canvas.clipRect(rect, Region.Op.INTERSECT);
doDrawLegendIcon(canvas, rect, formatter);
} finally {
canvas.restore();
}
}
/**
*
* @return A List of all {@link SeriesAndFormatter} instances currently associated
* with this Renderer.
*/
public List> getSeriesAndFormatterList() {
List> results = new ArrayList<>();
ArrayList sfList = getPlot().getSeriesRegistry();
for(SeriesAndFormatter thisPair : sfList) {
if(thisPair.rendersWith(this)) {
results.add(thisPair);
}
}
return results;
}
/**
*
* @return
* @since 0.9.7
*/
public List getSeriesList() {
List results = new ArrayList<>();
ArrayList sfList = getPlot().getSeriesRegistry();
for(SeriesAndFormatter thisPair : sfList) {
if(thisPair.rendersWith(this)) {
results.add(thisPair.getSeries());
}
}
return results;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/Size.java 0000664 0000000 0000000 00000006106 12711435674 0027253 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import android.graphics.RectF;
import com.androidplot.util.PixelUtils;
/**
* Defines physical dimensions & scaling characteristics
*/
public class Size {
// convenience value; sets size to 100% width and height of the widget container.
public static Size FILL = new Size(0, SizeLayoutType.FILL, 0, SizeLayoutType.FILL);
private SizeMetric height;
private SizeMetric width;
/**
* Convenience constructor. Wraps {@link #Size(SizeMetric, SizeMetric)}.
* @param height Height value used algorithm to calculate the height of the associated widget(s).
* @param heightLayoutType Algorithm used to calculate the height of the associated widget(s).
* @param width Width value used algorithm to calculate the width of the associated widget(s).
* @param widthLayoutType Algorithm used to calculate the width of the associated widget(s).
*/
public Size(float height, SizeLayoutType heightLayoutType, float width, SizeLayoutType widthLayoutType) {
this.height = new SizeMetric(height, heightLayoutType);
this.width = new SizeMetric(width, widthLayoutType);
}
/**
* Creates a new SizeMetrics instance using the specified size layout algorithm and value.
* See {@link SizeMetric} for details on what can be passed in.
* @param height
* @param width
*/
public Size(SizeMetric height, SizeMetric width) {
this.height = height;
this.width = width;
}
public SizeMetric getHeight() {
return height;
}
public void setHeight(SizeMetric height) {
this.height = height;
}
public SizeMetric getWidth() {
return width;
}
/**
* Calculates a RectF with calculated width and height. The top-left corner is set to 0,0.
* @param canvasRect
* @return
*/
public RectF getRectF(RectF canvasRect) {
return new RectF(
0,
0,
width.getPixelValue(canvasRect.width()),
height.getPixelValue(canvasRect.height()));
}
/**
* Same as getRectF but with edges rounded to the nearest full pixel.
* @param canvasRect
* @return
*/
public RectF getRoundedRect(RectF canvasRect) {
return PixelUtils.nearestPixRect(0, 0, width.getPixelValue(canvasRect.width()),
height.getPixelValue(canvasRect.height()));
}
public void setWidth(SizeMetric width) {
this.width = width;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/SizeLayoutType.java 0000664 0000000 0000000 00000002646 12711435674 0031320 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
/**
* SizeLayoutType is an enumeration of algorithms available for calculating an arbitrary dimension of a widget.
* Each algorithm also takes a single value called "val" in this doc.
* ABSOLUTE - Val is treated as absolute. If val is 5 then the size of the widget along the associated axis is 5 pixels.
*
* RELATIVE - Val represents the percentage of the display that the widget should fill along the associated axis. For example,
* if the total size of the owning plot is 120 pixels and val is set to 50 then the size of the widget along the associated axis
* is 60; 50% of 120 = 60.
*
* FILL - Widget completely fills along the associated axis, minus the input size value
*/
public enum SizeLayoutType {
ABSOLUTE,
RELATIVE,
FILL
} androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/SizeMetric.java 0000664 0000000 0000000 00000004032 12711435674 0030413 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
/**
* Encapsulates a sizing algorithm and an associated value.
*
* The available algorithms list are stored in the {@link SizeLayoutType} enumeration.
*
*/
public class SizeMetric extends LayoutMetric {
public SizeMetric(float value, SizeLayoutType layoutType) {
super(value, layoutType);
}
protected void validatePair(float value, SizeLayoutType layoutType) {
switch(layoutType) {
case RELATIVE:
if(value < 0 || value > 1) {
throw new IllegalArgumentException("SizeMetric Relative and Hybrid layout values must be within the range of 0 to 1.");
}
case ABSOLUTE:
case FILL:
default:
break;
}
}
@Override
public float getPixelValue(float size) {
//switch(layoutType)
switch(getLayoutType()) {
case ABSOLUTE:
return getValue();
case RELATIVE:
return getValue() * size;
case FILL:
return size - getValue();
default:
throw new IllegalArgumentException("Unsupported LayoutType: " + this.getLayoutType());
}
}
@Override
public void setLayoutType(SizeLayoutType layoutType) {
super.setLayoutType(layoutType);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/TableModel.java 0000664 0000000 0000000 00000002501 12711435674 0030344 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import android.graphics.RectF;
import java.util.Iterator;
public abstract class TableModel {
private TableOrder order;
protected TableModel(TableOrder order) {
setOrder(order);
}
public abstract Iterator getIterator(RectF tableRect, int totalElements);
//public abstract RectF getCellRect(RectF tableRect, int numElements);
public TableOrder getOrder() {
return order;
}
public void setOrder(TableOrder order) {
this.order = order;
}
public enum Axis {
ROW,
COLUMN
}
public enum CellSizingMethod {
FIXED,
FILL
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/TableOrder.java 0000664 0000000 0000000 00000001370 12711435674 0030362 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
public enum TableOrder {
ROW_MAJOR, // standard c-style
COLUMN_MAJOR
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/TableSizingMethod.java 0000664 0000000 0000000 00000001742 12711435674 0031716 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
/**
* The sizing methods available to a table.
* AUTO: The table is divided evenly int tableSize/numElements sections.
* FIXED: Each element in the table has a predefined number of pixels
* regardless of what the table's dimensions actually are.
*/
public enum TableSizingMethod {
AUTO,
FIXED
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/TextOrientationType.java 0000664 0000000 0000000 00000001413 12711435674 0032337 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
public enum TextOrientationType {
HORIZONTAL,
VERTICAL_ASCENDING,
VERTICAL_DESCENDING
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/XLayoutStyle.java 0000664 0000000 0000000 00000001475 12711435674 0030773 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
public enum XLayoutStyle {
ABSOLUTE_FROM_LEFT,
ABSOLUTE_FROM_RIGHT,
ABSOLUTE_FROM_CENTER,
RELATIVE_TO_LEFT,
RELATIVE_TO_RIGHT,
RELATIVE_TO_CENTER
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/XPositionMetric.java 0000664 0000000 0000000 00000005320 12711435674 0031436 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import com.androidplot.ui.PositionMetric;
import com.androidplot.ui.XLayoutStyle;
public class XPositionMetric extends PositionMetric {
//private XLayoutStyle layoutType;
public XPositionMetric(float value, XLayoutStyle layoutStyle) {
super(value, layoutStyle);
validatePair(value, layoutStyle);
//this.layoutStyle = layoutStyle;
}
/**
* Throws IllegalArgumentException if there is a problem.
* @param value
*/
protected void validatePair(float value, XLayoutStyle layoutStyle) {
switch(layoutStyle) {
case ABSOLUTE_FROM_LEFT:
case ABSOLUTE_FROM_RIGHT:
case ABSOLUTE_FROM_CENTER:
validateValue(value, PositionMetric.LayoutMode.ABSOLUTE);
break;
case RELATIVE_TO_LEFT:
case RELATIVE_TO_RIGHT:
case RELATIVE_TO_CENTER:
validateValue(value, PositionMetric.LayoutMode.RELATIVE);
}
}
@Override
public float getPixelValue(float size) {
switch(getLayoutType()) {
case ABSOLUTE_FROM_LEFT:
return this.getAbsolutePosition(size, PositionMetric.Origin.FROM_BEGINING);
case ABSOLUTE_FROM_RIGHT:
return this.getAbsolutePosition(size, PositionMetric.Origin.FROM_END);
case ABSOLUTE_FROM_CENTER:
return this.getAbsolutePosition(size, PositionMetric.Origin.FROM_CENTER);
case RELATIVE_TO_LEFT:
return this.getRelativePosition(size, PositionMetric.Origin.FROM_BEGINING);
case RELATIVE_TO_RIGHT:
return this.getRelativePosition(size, PositionMetric.Origin.FROM_END);
case RELATIVE_TO_CENTER:
return this.getRelativePosition(size, PositionMetric.Origin.FROM_CENTER);
default:
throw new IllegalArgumentException("Unsupported LayoutType: " + this.getLayoutType());
}
}
@Override
public void setLayoutType(XLayoutStyle layoutType) {
super.setLayoutType(layoutType);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/YLayoutStyle.java 0000664 0000000 0000000 00000001474 12711435674 0030773 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
public enum YLayoutStyle {
ABSOLUTE_FROM_TOP,
ABSOLUTE_FROM_BOTTOM,
ABSOLUTE_FROM_CENTER,
RELATIVE_TO_TOP,
RELATIVE_TO_BOTTOM,
RELATIVE_TO_CENTER
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/YPositionMetric.java 0000664 0000000 0000000 00000006536 12711435674 0031451 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import com.androidplot.ui.PositionMetric;
import com.androidplot.ui.YLayoutStyle;
public class YPositionMetric extends PositionMetric {
/*
public enum YLayoutStyle {
ABSOLUTE_FROM_TOP,
ABSOLUTE_FROM_BOTTOM,
ABSOLUTE_FROM_CENTER,
RELATIVE_TO_TOP,
RELATIVE_TO_BOTTOM,
RELATIVE_TO_CENTER
}
*/
//private YLayoutStyle layoutType;
public YPositionMetric(float value, YLayoutStyle layoutStyle) {
super(value, layoutStyle);
//this.layoutStyle = layoutStyle;
}
/*
@Override
public void set(float value, YLayoutStyle layoutType) {
validatePair(value, layoutType);
super.set(value, layoutType);
}
@Override
public void setLayoutType(YLayoutStyle layoutType) {
validatePair(getValue(), layoutType);
super.setLayoutType(layoutType);
}
@Override
public void setValue(float value) {
validatePair(value, getLayoutType());
super.setValue(value);
}
*/
/**
* Throws IllegalArgumentException if there is a problem.
* @param value
*/
protected void validatePair(float value, YLayoutStyle layoutStyle) {
switch(layoutStyle) {
case ABSOLUTE_FROM_TOP:
case ABSOLUTE_FROM_BOTTOM:
case ABSOLUTE_FROM_CENTER:
validateValue(value, PositionMetric.LayoutMode.ABSOLUTE);
break;
case RELATIVE_TO_TOP:
case RELATIVE_TO_BOTTOM:
case RELATIVE_TO_CENTER:
validateValue(value, PositionMetric.LayoutMode.RELATIVE);
}
}
@Override
public float getPixelValue(float size) {
switch(getLayoutType()) {
case ABSOLUTE_FROM_TOP:
return this.getAbsolutePosition(size, PositionMetric.Origin.FROM_BEGINING);
case ABSOLUTE_FROM_BOTTOM:
return this.getAbsolutePosition(size, PositionMetric.Origin.FROM_END);
case ABSOLUTE_FROM_CENTER:
return this.getAbsolutePosition(size, PositionMetric.Origin.FROM_CENTER);
case RELATIVE_TO_TOP:
return this.getRelativePosition(size, PositionMetric.Origin.FROM_BEGINING);
case RELATIVE_TO_BOTTOM:
return this.getRelativePosition(size, PositionMetric.Origin.FROM_END);
case RELATIVE_TO_CENTER:
return this.getRelativePosition(size, PositionMetric.Origin.FROM_CENTER);
default:
throw new IllegalArgumentException("Unsupported LayoutType: " + this.getLayoutType());
}
}
@Override
public void setLayoutType(YLayoutStyle layoutType) {
super.setLayoutType(layoutType);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/widget/ 0000775 0000000 0000000 00000000000 12711435674 0026756 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/widget/EmptyWidget.java 0000664 0000000 0000000 00000002227 12711435674 0032066 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui.widget;
import android.graphics.Canvas;
import android.graphics.RectF;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.LayoutManager;
import com.androidplot.ui.Size;
public class EmptyWidget extends Widget {
public EmptyWidget(LayoutManager layoutManager, Size size) {
super(layoutManager, size);
}
@Override
protected void doOnDraw(Canvas canvas, RectF widgetRect) throws PlotRenderException {
// nothing to do
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/widget/TextLabelWidget.java 0000664 0000000 0000000 00000013140 12711435674 0032650 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui.widget;
import android.graphics.*;
import com.androidplot.ui.*;
import com.androidplot.util.FontUtils;
public class TextLabelWidget extends Widget {
private static final String TAG = TextLabelWidget.class.getName();
private String text;
private Paint labelPaint;
private TextOrientationType orientation;
private boolean autoPackEnabled = true;
{
labelPaint = new Paint();
labelPaint.setColor(Color.WHITE);
labelPaint.setAntiAlias(true);
labelPaint.setTextAlign(Paint.Align.CENTER);
setClippingEnabled(false);
}
public TextLabelWidget(LayoutManager layoutManager, Size size) {
this(layoutManager, size, TextOrientationType.HORIZONTAL);
}
public TextLabelWidget(LayoutManager layoutManager, String title, Size size, TextOrientationType orientation) {
this(layoutManager, size, orientation);
setText(title);
}
public TextLabelWidget(LayoutManager layoutManager, Size size, TextOrientationType orientation) {
super(layoutManager, new Size(0, SizeLayoutType.ABSOLUTE, 0, SizeLayoutType.ABSOLUTE));
setSize(size);
this.orientation = orientation;
}
@Override
protected void onMetricsChanged(Size olds, Size news) {
if(autoPackEnabled) {
pack();
}
}
@Override
public void onPostInit() {
if(autoPackEnabled) {
pack();
}
}
//protected abstract String getText();
/**
* Sets the dimensions of the widget to exactly contain the text contents
*/
public void pack() {
//Log.d(TAG, "Packing...");
Rect size = FontUtils.getStringDimensions(text, getLabelPaint());
if(size == null) {
//Log.w(TAG, "Attempt to pack empty text.");
return;
}
switch(orientation) {
case HORIZONTAL:
setSize(new Size(size.height(), SizeLayoutType.ABSOLUTE, size.width()+2, SizeLayoutType.ABSOLUTE));
break;
case VERTICAL_ASCENDING:
case VERTICAL_DESCENDING:
setSize(new Size(size.width(), SizeLayoutType.ABSOLUTE, size.height()+2, SizeLayoutType.ABSOLUTE));
break;
}
refreshLayout();
}
/**
* Do not call this method directly. It is indirectly invoked every time a plot is
* redrawn.
* @param canvas The Canvas to draw onto
* @param widgetRect the size and coordinates of this widget
*/
@Override
public void doOnDraw(Canvas canvas, RectF widgetRect) {
if(text == null || text.length() == 0) {
return;
}
//FontUtils.getStringDimensions(text, labelPaint);
float vOffset = labelPaint.getFontMetrics().descent;
PointF start = getAnchorCoordinates(widgetRect,
AnchorPosition.CENTER);
// BEGIN ROTATION CALCULATION
//int canvasState = canvas.save(Canvas.ALL_SAVE_FLAG);
try {
canvas.save(Canvas.ALL_SAVE_FLAG);
canvas.translate(start.x, start.y);
switch (orientation) {
case HORIZONTAL:
break;
case VERTICAL_ASCENDING:
canvas.rotate(-90);
break;
case VERTICAL_DESCENDING:
canvas.rotate(90);
break;
default:
throw new UnsupportedOperationException("Orientation " + orientation + " not yet implemented for TextLabelWidget.");
}
canvas.drawText(text, 0, vOffset, labelPaint);
} finally {
//canvas.restoreToCount(canvasState);
canvas.restore();
}
// END ROTATION CALCULATION
}
public Paint getLabelPaint() {
return labelPaint;
}
public void setLabelPaint(Paint labelPaint) {
this.labelPaint = labelPaint;
// when paint changes, packing params change too so check
// to see if we need to resize:
if(autoPackEnabled) {
pack();
}
}
public TextOrientationType getOrientation() {
return orientation;
}
public void setOrientation(TextOrientationType orientation) {
this.orientation = orientation;
if(autoPackEnabled) {
pack();
}
}
public boolean isAutoPackEnabled() {
return autoPackEnabled;
}
public void setAutoPackEnabled(boolean autoPackEnabled) {
this.autoPackEnabled = autoPackEnabled;
if(autoPackEnabled) {
pack();
}
}
public void setText(String text) {
//Log.d(TAG, "Setting textLabel to: " + text);
this.text = text;
if(autoPackEnabled) {
pack();
}
}
public String getText() {
return text;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/ui/widget/Widget.java 0000664 0000000 0000000 00000033124 12711435674 0031047 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui.widget;
import android.graphics.*;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.*;
import com.androidplot.util.DisplayDimensions;
import com.androidplot.ui.XLayoutStyle;
import com.androidplot.ui.YLayoutStyle;
import com.androidplot.util.PixelUtils;
/**
* A Widget is a graphical sub-element of a Plot that can be positioned relative
* to the bounds of the Plot.
*/
public abstract class Widget implements BoxModelable, Resizable {
private Paint borderPaint;
private Paint backgroundPaint;
private boolean clippingEnabled = false;
private BoxModel boxModel = new BoxModel();
private Size size;
private DisplayDimensions plotDimensions = new DisplayDimensions();
private DisplayDimensions widgetDimensions = new DisplayDimensions();
private boolean isVisible = true;
private PositionMetrics positionMetrics;
private LayoutManager layoutManager;
public Widget(LayoutManager layoutManager, SizeMetric heightMetric, SizeMetric widthMetric) {
this(layoutManager, new Size(heightMetric, widthMetric));
}
public Widget(LayoutManager layoutManager, Size size) {
this.layoutManager = layoutManager;
Size oldSize = this.size;
setSize(size);
onMetricsChanged(oldSize, size);
}
public DisplayDimensions getWidgetDimensions() {
return widgetDimensions;
}
public AnchorPosition getAnchor() {
return getPositionMetrics().getAnchor();
}
public void setAnchor(AnchorPosition anchor) {
getPositionMetrics().setAnchor(anchor);
}
/**
* Same as {@link #position(float, com.androidplot.ui.XLayoutStyle, float, com.androidplot.ui.YLayoutStyle, com.androidplot.ui.AnchorPosition)}
* but with the anchor parameter defaulted to the upper left corner.
* @param x
* @param xLayoutStyle
* @param y
* @param yLayoutStyle
*/
public void position(float x, XLayoutStyle xLayoutStyle, float y, YLayoutStyle yLayoutStyle) {
position(x, xLayoutStyle, y, yLayoutStyle, AnchorPosition.LEFT_TOP);
}
/**
* @param x X-Coordinate of the top left corner of element. When using RELATIVE, must be a value between 0 and 1.
* @param xLayoutStyle LayoutType to use when orienting this element's X-Coordinate.
* @param y Y_VALS_ONLY-Coordinate of the top-left corner of element. When using RELATIVE, must be a value between 0 and 1.
* @param yLayoutStyle LayoutType to use when orienting this element's Y_VALS_ONLY-Coordinate.
* @param anchor The point of reference used by this positioning call.
*/
public void position(float x, XLayoutStyle xLayoutStyle, float y,
YLayoutStyle yLayoutStyle, AnchorPosition anchor) {
setPositionMetrics(new PositionMetrics(x, xLayoutStyle, y, yLayoutStyle, anchor));
layoutManager.addToTop(this);
}
/**
* Can be overridden by subclasses to respond to resizing events.
*
* @param oldSize
* @param newSize
*/
protected void onMetricsChanged(Size oldSize, Size newSize) {
}
/**
* Can be overridden by subclasses to handle any final resizing etc. that
* can only be done after XML configuration etc. has completed.
*/
public void onPostInit() {
}
/**
* Determines whether or not point lies within this Widget.
*
* @param point
* @return
*/
public boolean containsPoint(PointF point) {
//return outlineRect != null && outlineRect.contains(point.x, point.y);
return widgetDimensions.canvasRect.contains(point.x, point.y);
}
public void setSize(Size size) {
this.size = size;
}
public Size getSize() {
return this.size;
}
public void setWidth(float width) {
size.getWidth().setValue(width);
}
public void setWidth(float width, SizeLayoutType layoutType) {
size.getWidth().set(width, layoutType);
}
public void setHeight(float height) {
size.getHeight().setValue(height);
}
public void setHeight(float height, SizeLayoutType layoutType) {
size.getHeight().set(height, layoutType);
}
public SizeMetric getWidthMetric() {
return size.getWidth();
}
public SizeMetric getHeightMetric() {
return size.getHeight();
}
public float getWidthPix(float size) {
return this.size.getWidth().getPixelValue(size);
}
public float getHeightPix(float size) {
return this.size.getHeight().getPixelValue(size);
}
public RectF getMarginatedRect(RectF widgetRect) {
return boxModel.getMarginatedRect(widgetRect);
}
public RectF getPaddedRect(RectF widgetMarginRect) {
return boxModel.getPaddedRect(widgetMarginRect);
}
@Override
public void setMarginRight(float marginRight) {
boxModel.setMarginRight(marginRight);
}
@Override
public void setMargins(float left, float top, float right, float bottom) {
boxModel.setMargins(left, top, right, bottom);
}
@Override
public void setPadding(float left, float top, float right, float bottom) {
boxModel.setPadding(left, top, right, bottom);
}
@Override
public float getMarginTop() {
return boxModel.getMarginTop();
}
@Override
public void setMarginTop(float marginTop) {
boxModel.setMarginTop(marginTop);
}
@Override
public float getMarginBottom() {
return boxModel.getMarginBottom();
}
@Override
public float getPaddingLeft() {
return boxModel.getPaddingLeft();
}
@Override
public void setPaddingLeft(float paddingLeft) {
boxModel.setPaddingLeft(paddingLeft);
}
@Override
public float getPaddingTop() {
return boxModel.getPaddingTop();
}
@Override
public void setPaddingTop(float paddingTop) {
boxModel.setPaddingTop(paddingTop);
}
@Override
public float getPaddingRight() {
return boxModel.getPaddingRight();
}
@Override
public void setPaddingRight(float paddingRight) {
boxModel.setPaddingRight(paddingRight);
}
@Override
public float getPaddingBottom() {
return boxModel.getPaddingBottom();
}
@Override
public void setPaddingBottom(float paddingBottom) {
boxModel.setPaddingBottom(paddingBottom);
}
@Override
@SuppressWarnings("SameParameterValue")
public void setMarginBottom(float marginBottom) {
boxModel.setMarginBottom(marginBottom);
}
@Override
public float getMarginLeft() {
return boxModel.getMarginLeft();
}
@Override
public void setMarginLeft(float marginLeft) {
boxModel.setMarginLeft(marginLeft);
}
@Override
public float getMarginRight() {
return boxModel.getMarginRight();
}
/**
* Causes the pixel dimensions used for rendering this Widget
* to be recalculated. Should be called any time a parameter that factors
* into this Widget's size or position is altered.
*/
public synchronized void refreshLayout() {
if(positionMetrics == null) {
// make sure positionMetrics have been set. this method can be
// automatically called during xml configuration of certain params
// before the widget is fully configured.
return;
}
float elementWidth = getWidthPix(plotDimensions.paddedRect.width());
float elementHeight = getHeightPix(plotDimensions.paddedRect.height());
PointF coords = getElementCoordinates(elementHeight,
elementWidth, plotDimensions.paddedRect, positionMetrics);
RectF widgetRect = new RectF(coords.x, coords.y,
coords.x + elementWidth, coords.y + elementHeight);
RectF marginatedWidgetRect = getMarginatedRect(widgetRect);
RectF paddedWidgetRect = getPaddedRect(marginatedWidgetRect);
widgetDimensions = new DisplayDimensions(widgetRect,
marginatedWidgetRect, paddedWidgetRect);
}
@Override
public synchronized void layout(final DisplayDimensions plotDimensions) {
this.plotDimensions = plotDimensions;
refreshLayout();
}
public PointF getElementCoordinates(float height, float width, RectF viewRect, PositionMetrics metrics) {
float x = metrics.getXPositionMetric().getPixelValue(viewRect.width()) + viewRect.left;
float y = metrics.getYPositionMetric().getPixelValue(viewRect.height()) + viewRect.top;
PointF point = new PointF(x, y);
return PixelUtils.sub(point, getAnchorOffset(width, height, metrics.getAnchor()));
}
public static PointF getAnchorOffset(float width, float height, AnchorPosition anchorPosition) {
PointF point = new PointF();
switch (anchorPosition) {
case LEFT_TOP:
break;
case LEFT_MIDDLE:
point.set(0, height / 2);
break;
case LEFT_BOTTOM:
point.set(0, height);
break;
case RIGHT_TOP:
point.set(width, 0);
break;
case RIGHT_BOTTOM:
point.set(width, height);
break;
case RIGHT_MIDDLE:
point.set(width, height / 2);
break;
case TOP_MIDDLE:
point.set(width / 2, 0);
break;
case BOTTOM_MIDDLE:
point.set(width / 2, height);
break;
case CENTER:
point.set(width / 2, height / 2);
break;
default:
throw new IllegalArgumentException("Unsupported anchor location: " + anchorPosition);
}
return point;
}
public static PointF getAnchorCoordinates(RectF widgetRect, AnchorPosition anchorPosition) {
return PixelUtils.add(new PointF(widgetRect.left, widgetRect.top),
getAnchorOffset(widgetRect.width(), widgetRect.height(), anchorPosition));
}
public static PointF getAnchorCoordinates(float x, float y, float width, float height, AnchorPosition anchorPosition) {
return getAnchorCoordinates(new RectF(x, y, x+width, y+height), anchorPosition);
}
public void draw(Canvas canvas, RectF widgetRect) throws PlotRenderException {
//outlineRect = widgetRect;
if (isVisible()) {
if (backgroundPaint != null) {
drawBackground(canvas, widgetDimensions.canvasRect);
}
/* RectF marginatedRect = new RectF(outlineRect.left + marginLeft,
outlineRect.top + marginTop,
outlineRect.right - marginRight,
outlineRect.bottom - marginBottom);*/
/*RectF marginatedRect = boxModel.getMarginatedRect(widgetRect);
RectF paddedRect = boxModel.getPaddedRect(marginatedRect);*/
doOnDraw(canvas, widgetDimensions.paddedRect);
if (borderPaint != null) {
drawBorder(canvas, widgetDimensions.paddedRect);
}
}
}
protected void drawBorder(Canvas canvas, RectF paddedRect) {
canvas.drawRect(paddedRect, borderPaint);
}
protected void drawBackground(Canvas canvas, RectF widgetRect) {
canvas.drawRect(widgetRect, backgroundPaint);
}
/**
* @param canvas The Canvas to draw onto
* @param widgetRect the size and coordinates of this widget
*/
protected abstract void doOnDraw(Canvas canvas, RectF widgetRect) throws PlotRenderException;
public Paint getBorderPaint() {
return borderPaint;
}
public void setBorderPaint(Paint borderPaint) {
this.borderPaint = borderPaint;
}
public Paint getBackgroundPaint() {
return backgroundPaint;
}
public void setBackgroundPaint(Paint backgroundPaint) {
this.backgroundPaint = backgroundPaint;
}
public boolean isClippingEnabled() {
return clippingEnabled;
}
public void setClippingEnabled(boolean clippingEnabled) {
this.clippingEnabled = clippingEnabled;
}
public boolean isVisible() {
return isVisible;
}
public void setVisible(boolean visible) {
isVisible = visible;
}
public PositionMetrics getPositionMetrics() {
return positionMetrics;
}
public void setPositionMetrics(PositionMetrics positionMetrics) {
this.positionMetrics = positionMetrics;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/ 0000775 0000000 0000000 00000000000 12711435674 0026033 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/AttrUtils.java 0000664 0000000 0000000 00000021406 12711435674 0030634 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import android.content.res.TypedArray;
import android.graphics.Paint;
import android.util.TypedValue;
import com.androidplot.ui.*;
import com.androidplot.ui.widget.Widget;
import com.androidplot.xy.XYStepMode;
import com.androidplot.xy.XYStepModel;
/**
* Methods for applying styleable attributes.
*
*/
public class AttrUtils {
/**
* Configure a {@link Paint} instance used for drawing text from xml attrs.
* @param attrs
* @param paint
* @param colorAttr
* @param textSizeAttr
*/
public static void configureTextPaint(TypedArray attrs, Paint paint, int colorAttr, int textSizeAttr) {
if(attrs != null) {
setColor(attrs, paint, colorAttr);
setTextSize(attrs, paint, textSizeAttr);
}
}
/**
* Configure a {@link Paint} instance used for drawing lines from xml attrs.
* @param attrs
* @param paint
* @param colorAttr
* @param strokeWidthAttr
*/
public static void configureLinePaint(TypedArray attrs, Paint paint, int colorAttr, int strokeWidthAttr) {
if(attrs != null) {
setColor(attrs, paint, colorAttr);
paint.setStrokeWidth(attrs.getDimension(strokeWidthAttr, paint.getStrokeWidth()));
}
}
private static void setColor(TypedArray attrs, Paint paint, int attrId) {
paint.setColor(attrs.getColor(attrId, paint.getColor()));
}
private static void setTextSize(TypedArray attrs, Paint paint, int attrId) {
paint.setTextSize(attrs.getDimension(attrId, paint.getTextSize()));
}
/**
* Configure a {@link BoxModelable} instance from xml attrs.
* @param attrs
* @param model
* @param marginTop
* @param marginBottom
* @param marginLeft
* @param marginRight
* @param paddingTop
* @param paddingBottom
* @param paddingLeft
* @param paddingRight
*/
public static void configureBoxModelable(TypedArray attrs, BoxModelable model, int marginTop, int marginBottom,
int marginLeft, int marginRight, int paddingTop, int paddingBottom,
int paddingLeft, int paddingRight) {
if(attrs != null) {
model.setMargins(attrs.getDimension(marginLeft, model.getMarginLeft()),
attrs.getDimension(marginTop, model.getMarginTop()),
attrs.getDimension(marginRight, model.getMarginRight()),
attrs.getDimension(marginBottom, model.getMarginBottom()));
model.setPadding(attrs.getDimension(paddingLeft, model.getPaddingLeft()),
attrs.getDimension(paddingTop, model.getPaddingTop()),
attrs.getDimension(paddingRight, model.getPaddingRight()),
attrs.getDimension(paddingBottom, model.getPaddingBottom()));
}
}
/**
* Configure a {@link Size} instance from xml attrs.
* @param attrs
* @param model
* @param heightSizeLayoutTypeAttr
* @param heightAttr
* @param widthSizeLayoutTypeAttr
* @param widthAttr
*/
public static void configureSize(TypedArray attrs, Size model, int heightSizeLayoutTypeAttr, int heightAttr,
int widthSizeLayoutTypeAttr, int widthAttr) {
if(attrs != null) {
configureSizeMetric(attrs, model.getHeight(), heightSizeLayoutTypeAttr, heightAttr);
configureSizeMetric(attrs, model.getWidth(), widthSizeLayoutTypeAttr, widthAttr);
}
}
private static void configureSizeMetric(TypedArray attrs, SizeMetric model, int typeAttr, int valueAttr) {
final float value = getIntFloatDimenValue(attrs, valueAttr, model.getValue()).floatValue();
final SizeLayoutType sizeLayoutType =
getSizeLayoutType(attrs, typeAttr, model.getLayoutType());
model.set(value, sizeLayoutType);
}
private static SizeLayoutType getSizeLayoutType(TypedArray attrs, int attr, SizeLayoutType defaultValue) {
return SizeLayoutType.values()[attrs.getInt(attr, defaultValue.ordinal())];
}
public static void configureWidget(TypedArray attrs, Widget widget, int heightSizeLayoutTypeAttr, int heightAttr,
int widthSizeLayoutTypeAttr, int widthAttr, int xLayoutStyleAttr,
int xLayoutValueAttr, int yLayoutStyleAttr, int yLayoutValueAttr,
int anchorPositionAttr, int visibilityAttr) {
if(attrs != null) {
configureSize(attrs, widget.getSize(), heightSizeLayoutTypeAttr,
heightAttr, widthSizeLayoutTypeAttr, widthAttr);
configurePositionMetrics(attrs, widget.getPositionMetrics(), xLayoutStyleAttr, xLayoutValueAttr,
yLayoutStyleAttr, yLayoutValueAttr, anchorPositionAttr);
widget.setVisible(attrs.getBoolean(visibilityAttr, widget.isVisible()));
}
}
/**
* Configure a {@link Widget} from xml attrs.
* @param attrs
* @param metrics
* @param xLayoutStyleAttr
* @param xLayoutValueAttr
* @param yLayoutStyleAttr
* @param yLayoutValueAttr
* @param anchorPositionAttr
*/
public static void configurePositionMetrics(TypedArray attrs, PositionMetrics metrics, int xLayoutStyleAttr,
int xLayoutValueAttr, int yLayoutStyleAttr, int yLayoutValueAttr,
int anchorPositionAttr) {
if(attrs != null) {
metrics.getXPositionMetric().set(
getIntFloatDimenValue(attrs, xLayoutValueAttr, metrics.getXPositionMetric().getValue()).floatValue(),
getXLayoutStyle(attrs, xLayoutStyleAttr, metrics.getXPositionMetric().getLayoutType()));
metrics.getYPositionMetric().set(
getIntFloatDimenValue(attrs, yLayoutValueAttr, metrics.getYPositionMetric().getValue()).floatValue(),
getYLayoutStyle(attrs, yLayoutStyleAttr, metrics.getYPositionMetric().getLayoutType()));
metrics.setAnchor(getAnchorPosition(attrs, anchorPositionAttr, metrics.getAnchor()));
}
}
/**
* Convenience method to retrieve values from xml that can be entered as a int, float or dimen.
* @param attrs
* @param valueAttr
* @param defaultValue
* @return
*/
private static Number getIntFloatDimenValue(TypedArray attrs, int valueAttr, Number defaultValue) {
Number result = defaultValue;
if(attrs != null && attrs.hasValue(valueAttr)) {
final int valueType = attrs.peekValue(valueAttr).type;
if (valueType == TypedValue.TYPE_DIMENSION) {
result = attrs.getDimension(valueAttr, defaultValue.floatValue());
} else if(valueType == TypedValue.TYPE_INT_DEC) {
result = attrs.getInt(valueAttr, defaultValue.intValue());
} else if (valueType == TypedValue.TYPE_FLOAT) {
result = attrs.getFloat(valueAttr, defaultValue.floatValue());
} else {
throw new IllegalArgumentException("Invalid value type - must be float or dimension.");
}
}
return result;
}
private static XLayoutStyle getXLayoutStyle(TypedArray attrs, int attr, XLayoutStyle defaultValue) {
return XLayoutStyle.values()[attrs.getInt(attr, defaultValue.ordinal())];
}
private static YLayoutStyle getYLayoutStyle(TypedArray attrs, int attr, YLayoutStyle defaultValue) {
return YLayoutStyle.values()[attrs.getInt(attr, defaultValue.ordinal())];
}
private static AnchorPosition getAnchorPosition(TypedArray attrs, int attr, AnchorPosition defaultValue) {
return AnchorPosition.values()[attrs.getInt(attr, defaultValue.ordinal())];
}
public static void configureStep(TypedArray attrs, XYStepModel model, int stepModeAttr, int stepValueAttr) {
if(attrs != null) {
model.setMode(XYStepMode.values()[attrs.getInt(stepModeAttr, model.getMode().ordinal())]);
model.setValue(getIntFloatDimenValue(attrs, stepValueAttr, model.getValue()).doubleValue());
}
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/Configurator.java 0000664 0000000 0000000 00000032252 12711435674 0031344 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import android.content.Context;
import android.content.res.XmlResourceParser;
import android.graphics.Color;
import android.util.Log;
import android.util.TypedValue;
import org.xmlpull.v1.XmlPullParserException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.HashMap;
/**
* Utility class for "configuring" objects via XML config files. Supports the following field types:
* String
* Enum
* int
* float
* boolean
*
* Config files should be stored in /res/xml. Given the XML configuration /res/xml/myConfig.xml, one can apply the
* configuration to an Object instance as follows:
*
* MyObject obj = new MyObject();
* Configurator.configure(obj, R.xml.myConfig);
*
* WHAT IT DOES:
* Given a series of parameters stored in an XML file, Configurator iterates through each parameter, using the name
* as a map to the field within a given object. For example:
*
*
* {@code
*
* }
*
*
* Given a Car instance car and assuming the method setCondition(String) exists within the SparkPlug class,
* Configurator does the following:
*
*
* {@code
* car.getEngine().getSparkPlug().setCondition("poor");
* }
*
*
* Now let's pretend that setCondition takes an instance of the Condition enum as it's argument.
* Configurator then does the following:
*
* car.getEngine().getSparkPlug().setCondition(Condition.valueOf("poor");
*
* Now let's look at how ints are handled. Given the following xml:
*
*
*
* would result in:
* car.getEngine.setMiles(Integer.ParseInt("100000");
*
* That's pretty straight forward. But colors are expressed as ints too in Android
* but can be defined using hex values or even names of colors. When Configurator
* attempts to parse a parameter for a method that it knows takes an int as it's argument,
* Configurator will first attempt to parse the parameter as a color. Only after this
* attempt fails will Configurator resort to Integer.ParseInt. So:
*
*
*
* would result in:
* car.getHood().getPaint().setColor(Color.parseColor("Red");
*
* Next lets talk about float. Floats can appear in XML a few different ways in Android,
* especially when it comes to defining dimensions:
*
*
*
* Configurator will correctly parse each of these into their corresponding real pixel value expressed as a float.
*
* One last thing to keep in mind when using Configurator:
* Values for Strings and ints can be assigned to localized values, allowing
* a cleaner solution for those developing apps to run on multiple form factors
* or in multiple languages:
*
*
*/
@SuppressWarnings("WeakerAccess")
public abstract class Configurator {
private static final String TAG = Configurator.class.getName();
protected static final String CFG_ELEMENT_NAME = "config";
protected static int parseResId(Context ctx, String prefix, String value) {
String[] split = value.split("/");
// is this a localized resource?
if (split.length > 1 && split[0].equalsIgnoreCase(prefix)) {
String pack = split[0].replace("@", "");
String name = split[1];
return ctx.getResources().getIdentifier(name, pack, ctx.getPackageName());
} else {
throw new IllegalArgumentException();
}
}
protected static int parseIntAttr(Context ctx, String value) {
try {
return ctx.getResources().getColor(parseResId(ctx, "@color", value));
} catch (IllegalArgumentException e1) {
try {
return Color.parseColor(value);
} catch (IllegalArgumentException e2) {
// wasn't a color so try parsing as a plain old int:
return Integer.parseInt(value);
}
}
}
/**
* Treats value as a float parameter. First value is tested to see whether
* it contains a resource identifier. Failing that, it is tested to see whether
* a dimension suffix (dp, em, mm etc.) exists. Failing that, it is evaluated as
* a plain old float.
* @param ctx
* @param value
* @return
*/
protected static float parseFloatAttr(Context ctx, String value) {
try {
return ctx.getResources().getDimension(parseResId(ctx, "@dimen", value));
} catch (IllegalArgumentException e1) {
try {
return PixelUtils.stringToDimension(value);
} catch (Exception e2) {
return Float.parseFloat(value);
}
}
}
protected static String parseStringAttr(Context ctx, String value) {
try {
return ctx.getResources().getString(parseResId(ctx, "@string", value));
} catch (IllegalArgumentException e1) {
return value;
}
}
protected static Method getSetter(Class clazz, final String fieldId) throws NoSuchMethodException {
Method[] methods = clazz.getMethods();
String methodName = "set" + fieldId;
for (Method method : methods) {
if (method.getName().equalsIgnoreCase(methodName)) {
return method;
}
}
throw new NoSuchMethodException("No such public method (case insensitive): " +
methodName + " in " + clazz);
}
@SuppressWarnings("unchecked")
protected static Method getGetter(Class clazz, final String fieldId) throws NoSuchMethodException {
Log.d(TAG, "Attempting to find getter for " + fieldId + " in class " + clazz.getName());
String firstLetter = fieldId.substring(0, 1);
String methodName = "get" + firstLetter.toUpperCase() + fieldId.substring(1, fieldId.length());
return clazz.getMethod(methodName);
}
/**
* Returns the object containing the field specified by path.
* @param obj
* @param path Path through member hierarchy to the destination field.
* @return null if the object at path cannot be found.
* @throws java.lang.reflect.InvocationTargetException
*
* @throws IllegalAccessException
*/
protected static Object getObjectContaining(Object obj, String path) throws
InvocationTargetException, IllegalAccessException, NoSuchMethodException {
if(obj == null) {
throw new NullPointerException("Attempt to call getObjectContaining(Object obj, String path) " +
"on a null Object instance. Path was: " + path);
}
Log.d(TAG, "Looking up object containing: " + path);
int separatorIndex = path.indexOf(".");
// not there yet, descend deeper:
if (separatorIndex > 0) {
String lhs = path.substring(0, separatorIndex);
String rhs = path.substring(separatorIndex + 1, path.length());
// use getter to retrieve the instance
Method m = getGetter(obj.getClass(), lhs);
if(m == null) {
throw new NullPointerException("No getter found for field: " + lhs + " within " + obj.getClass());
}
Log.d(TAG, "Invoking " + m.getName() + " on instance of " + obj.getClass().getName());
Object o = m.invoke(obj);
// delve into o
return getObjectContaining(o, rhs);
//} catch (NoSuchMethodException e) {
// TODO: log a warning
// return null;
//}
} else {
// found it!
return obj;
}
}
@SuppressWarnings("unchecked")
private static Object[] inflateParams(Context ctx, Class[] params, String[] vals) throws NoSuchMethodException,
InvocationTargetException, IllegalAccessException {
Object[] out = new Object[params.length];
int i = 0;
for (Class param : params) {
if (Enum.class.isAssignableFrom(param)) {
out[i] = param.getMethod("valueOf", String.class).invoke(null, vals[i].toUpperCase());
} else if (param.equals(Float.TYPE)) {
out[i] = parseFloatAttr(ctx, vals[i]);
} else if (param.equals(Integer.TYPE)) {
out[i] = parseIntAttr(ctx, vals[i]);
} else if (param.equals(Boolean.TYPE)) {
out[i] = Boolean.valueOf(vals[i]);
} else if (param.equals(String.class)) {
out[i] = parseStringAttr(ctx, vals[i]);
} else {
throw new IllegalArgumentException(
"Error inflating XML: Setter requires param of unsupported type: " + param);
}
i++;
}
return out;
}
/**
*
* @param ctx
* @param obj
* @param xmlFileId ID of the XML config file within /res/xml
*/
public static void configure(Context ctx, Object obj, int xmlFileId) {
XmlResourceParser xrp = ctx.getResources().getXml(xmlFileId);
try {
HashMap params = new HashMap();
while (xrp.getEventType() != XmlResourceParser.END_DOCUMENT) {
xrp.next();
String name = xrp.getName();
if (xrp.getEventType() == XmlResourceParser.START_TAG) {
if (name.equalsIgnoreCase(CFG_ELEMENT_NAME))
for (int i = 0; i < xrp.getAttributeCount(); i++) {
params.put(xrp.getAttributeName(i), xrp.getAttributeValue(i));
}
break;
}
}
configure(ctx, obj, params);
} catch (XmlPullParserException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
xrp.close();
}
}
public static void configure(Context ctx, Object obj, HashMap params) {
for (String key : params.keySet()) {
try {
configure(ctx, obj, key, params.get(key));
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
Log.w(TAG, "Error inflating XML: Setter for field \"" + key + "\" does not exist. ");
e.printStackTrace();
}
}
}
/**
* Recursively descend into an object using key as the pathway and invoking the corresponding setter
* if one exists.
*
* @param key
* @param value
*/
protected static void configure(Context ctx, Object obj, String key, String value)
throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
Object o = getObjectContaining(obj, key);
if (o != null) {
int idx = key.lastIndexOf(".");
String fieldId = idx > 0 ? key.substring(idx + 1, key.length()) : key;
Method m = getSetter(o.getClass(), fieldId);
Class[] paramTypes = m.getParameterTypes();
// TODO: add support for generic type params
if (paramTypes.length >= 1) {
// split on "|"
// TODO: add support for String args containing a |
String[] paramStrs = value.split("\\|");
if (paramStrs.length == paramTypes.length) {
Object[] oa = inflateParams(ctx, paramTypes, paramStrs);
Log.d(TAG, "Invoking " + m.getName() + " with arg(s) " + argArrToString(oa));
m.invoke(o, oa);
} else {
throw new IllegalArgumentException("Error inflating XML: Unexpected number of argments passed to \""
+ m.getName() + "\". Expected: " + paramTypes.length + " Got: " + paramStrs.length);
}
} else {
// Obvious this is not a setter
throw new IllegalArgumentException("Error inflating XML: no setter method found for param \"" +
fieldId + "\".");
}
}
}
protected static String argArrToString(Object[] args) {
String out = "";
for(Object obj : args) {
out += (obj == null ? (out += "[null] ") :
("[" + obj.getClass() + ": " + obj + "] "));
}
return out;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/DisplayDimensions.java 0000664 0000000 0000000 00000002744 12711435674 0032343 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import android.graphics.RectF;
/**
* Convenience class for managing {@link com.androidplot.ui.BoxModel} data
*/
public class DisplayDimensions {
private static final int ONE = 1;
public final RectF canvasRect;
public final RectF marginatedRect;
public final RectF paddedRect;
// init to 1 to avoid potential divide by zero errors (yet to be observed in practice)
private static final RectF initRect;
static {
initRect = new RectF(ONE, ONE, ONE, ONE);
}
public DisplayDimensions() {
this(initRect, initRect, initRect);
}
public DisplayDimensions(RectF canvasRect, RectF marginatedRect, RectF paddedRect) {
this.canvasRect = canvasRect;
this.marginatedRect = marginatedRect;
this.paddedRect = paddedRect;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/FontUtils.java 0000664 0000000 0000000 00000004250 12711435674 0030626 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import android.graphics.Paint;
import android.graphics.Rect;
public class FontUtils {
private static final int ZERO = 0;
/**
* Determines the height of the tallest character that can be drawn by paint.
* @param paint
* @return
*/
public static float getFontHeight(Paint paint) {
Paint.FontMetrics metrics = paint.getFontMetrics();
return (-metrics.ascent) + metrics.descent;
//return (-metrics.top) + metrics.bottom;
}
/**
* Get the smallest rect that ecompasses the text to be drawn using paint.
* @param text
* @param paint
* @return
*/
public static Rect getPackedStringDimensions(String text, Paint paint) {
Rect size = new Rect();
paint.getTextBounds(text, ZERO, text.length(), size);
return size;
}
/**
* Like getPackedStringDimensions except adds extra space to accommodate all
* characters that can be drawn regardless of whether or not they exist in text.
* This ensures a more uniform appearance for things that have dynamic text.
* @param text
* @param paint
* @return
*/
public static Rect getStringDimensions(String text, Paint paint) {
Rect size = new Rect();
if(text == null || text.length() == ZERO) {
return null;
}
paint.getTextBounds(text, ZERO, text.length(), size);
size.bottom = size.top + (int) getFontHeight(paint);
return size;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/ListOrganizer.java 0000664 0000000 0000000 00000006624 12711435674 0031502 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import java.util.List;
/**
* Utility class providing additional element organization operations.
* @param
*/
public class ListOrganizer implements ZIndexable {
private static final int ZERO = 0;
private static final int ONE = 1;
private List list;
public ListOrganizer(List list) {
this.list = list;
}
public boolean moveToTop(ElementType element) {
if(list.remove(element)) {
list.add(list.size(), element);
return true;
} else {
return false;
}
}
public boolean moveAbove(ElementType objectToMove, ElementType reference) {
if(objectToMove == reference) {
throw new IllegalArgumentException("Illegal argument to moveAbove(A, B); A cannot be equal to B.");
}
list.remove(objectToMove);
int refIndex = list.indexOf(reference);
list.add(refIndex + ONE, objectToMove);
return true;
}
public boolean moveBeneath(ElementType objectToMove, ElementType reference) {
if (objectToMove == reference) {
throw new IllegalArgumentException("Illegal argument to moveBeaneath(A, B); A cannot be equal to B.");
}
list.remove(objectToMove);
int refIndex = list.indexOf(reference);
list.add(refIndex, objectToMove);
return true;
}
public boolean moveToBottom(ElementType key) {
list.remove(key);
list.add(ZERO, key);
return true;
}
public boolean moveUp(ElementType key) {
int widgetIndex = list.indexOf(key);
if(widgetIndex == - ONE) {
// key not found:
return false;
}
if(widgetIndex >= list.size() - ONE) {
// already at the top:
return true;
}
ElementType widgetAbove = list.get(widgetIndex + ONE);
return moveAbove(key, widgetAbove);
}
public boolean moveDown(ElementType key) {
int widgetIndex = list.indexOf(key);
if(widgetIndex == - ONE) {
// key not found:
return false;
}
if(widgetIndex <= ZERO) {
// already at the bottom:
return true;
}
ElementType widgetBeneath = list.get(widgetIndex - ONE);
return moveBeneath(key, widgetBeneath);
}
@Override
public List elements() {
return list;
}
public void addToBottom(ElementType element) {
list.add(ZERO, element);
}
public void addToTop(ElementType element) {
list.add(list.size(), element);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/Mapping.java 0000664 0000000 0000000 00000002045 12711435674 0030272 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
/**
* Essentially just a version of the Map interface used to associate
* a key of a given type with a value of a given type, does impose a 1:1
* relationship between keys and values and defines no method for insertion or deletion.
*/
public interface Mapping {
/**
* @param value
* @return The Key associated with the specified value.
*/
Key get(Value value);
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/PixelUtils.java 0000664 0000000 0000000 00000014662 12711435674 0031011 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import android.content.Context;
import android.graphics.PointF;
import android.graphics.RectF;
import android.util.DisplayMetrics;
import android.util.TypedValue;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PixelUtils {
private static DisplayMetrics metrics;
private static final float FLOAT_INT_AVG_NUDGE = 0.5f;
/**
* Recalculates scale value etc. Should be called when an application starts or
* whenever the screen is rotated.
*/
public static void init(Context ctx) {
metrics = ctx.getResources().getDisplayMetrics();
}
public static PointF add(PointF lhs, PointF rhs) {
return new PointF(lhs.x + rhs.x, lhs.y + rhs.y);
}
public static PointF sub(PointF lhs, PointF rhs) {
return new PointF(lhs.x - rhs.x, lhs.y - rhs.y);
}
/**
* Converts a sub-pixel accurate RectF to
* a single pixel accurate rect. This is helpful
* for clipping operations which dont do a good job with
* subpixel vals.
* @param in
* @return
*/
public static RectF sink(RectF in) {
return nearestPixRect(in.left, in.top, in.right, in.bottom);
}
public static RectF nearestPixRect(float left, float top, float right, float bottom) {
return new RectF(
(int) (left + FLOAT_INT_AVG_NUDGE),
(int) (top + FLOAT_INT_AVG_NUDGE),
(int) (right + FLOAT_INT_AVG_NUDGE),
(int) (bottom + FLOAT_INT_AVG_NUDGE));
}
/**
* Converts a dp value to pixels.
* @param dp
* @return Pixel value of dp.
*/
public static float dpToPix(float dp) {
checkMetrics();
return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, metrics);
}
/**
* Converts an sp value to pixels.
* @param sp
* @return Pixel value of sp.
*/
@SuppressWarnings("SameParameterValue")
public static float spToPix(float sp) {
checkMetrics();
return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp, metrics);
}
/**
*
* @param fraction A float value between 0 and 1.
* @return Number of pixels fraction represents on the current device's display.
*/
public static float fractionToPixH(float fraction) {
checkMetrics();
return metrics.heightPixels * fraction;
}
/**
*
* @param fraction A float value between 0 and 1.
* @return Number of pixels fraction represents on the current device's display.
*/
public static float fractionToPixW(float fraction) {
checkMetrics();
return metrics.widthPixels * fraction;
}
/**
*
* CODE BELOW IS ADAPTED IN PART FROM MINDRIOT'S SAMPLE CODE HERE:
* http://stackoverflow.com/questions/8343971/how-to-parse-a-dimension-string-and-convert-it-to-a-dimension-value
*/
// Initialize dimension string to constant lookup.
public static final Map dimensionConstantLookup = initDimensionConstantLookup();
private static Map initDimensionConstantLookup() {
Map m = new HashMap();
m.put("px", TypedValue.COMPLEX_UNIT_PX);
m.put("dip", TypedValue.COMPLEX_UNIT_DIP);
m.put("dp", TypedValue.COMPLEX_UNIT_DIP);
m.put("sp", TypedValue.COMPLEX_UNIT_SP);
m.put("pt", TypedValue.COMPLEX_UNIT_PT);
m.put("in", TypedValue.COMPLEX_UNIT_IN);
m.put("mm", TypedValue.COMPLEX_UNIT_MM);
return Collections.unmodifiableMap(m);
}
// Initialize pattern for dimension string.
protected static final String DIMENSION_REGEX = "^\\-?\\s*(\\d+(\\.\\d+)*)\\s*([a-zA-Z]+)\\s*$";
protected static final Pattern DIMENSION_PATTERN = Pattern.compile(DIMENSION_REGEX);
public static float stringToDimension(String dimension) {
// Mimics TypedValue.complexToDimension(int data, DisplayMetrics metrics).
InternalDimension internalDimension = stringToInternalDimension(dimension);
return TypedValue.applyDimension(internalDimension.unit, internalDimension.value, metrics);
}
private static InternalDimension stringToInternalDimension(String dimension) {
// Match target against pattern.
Matcher matcher = DIMENSION_PATTERN.matcher(dimension);
if (matcher.matches()) {
// Match found.
// Extract value.
float value = Float.valueOf(matcher.group(1));
// Extract dimension units.
String unit = matcher.group(3).toLowerCase();
// Get Android dimension constant.
Integer dimensionUnit = dimensionConstantLookup.get(unit);
if (dimensionUnit == null) {
// Invalid format.
throw new NumberFormatException();
} else {
// Return valid dimension.
return new InternalDimension(value, dimensionUnit);
}
} else {
// Invalid format.
throw new NumberFormatException();
}
}
private static class InternalDimension {
float value;
int unit;
public InternalDimension(float value, int unit) {
this.value = value;
this.unit = unit;
}
}
/**
* Safety check to hopefully help clarify what could otherwise be a confusing NPE.
*/
private static void checkMetrics() {
if(metrics == null) {
throw new RuntimeException("PixelUtils not initialized; call PixelUtils.init(Context) before using.");
}
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/PlotStatistics.java 0000664 0000000 0000000 00000007362 12711435674 0031677 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.RectF;
import com.androidplot.Plot;
import com.androidplot.PlotListener;
/**
* !!! THIS CLASS IS STILL UNDER DEVELOPMENT AND MAY CONTAIN BUGS !!!
* Gathers performance statistics from a Plot. Instances of PlotStatistics
* should never be added to more than one Plot, otherwise the statiscs will
* be invalid.
*/
public class PlotStatistics implements PlotListener {
long updateDelayMs;
long longestRenderMs = 0;
long shortestRenderMs = 0;
long lastStart = 0;
long lastLatency = 0;
long lastAnnotation;
long latencySamples = 0;
long latencySum = 0;
String annotationString = "";
private Paint paint;
{
paint = new Paint();
paint.setTextAlign(Paint.Align.CENTER);
paint.setColor(Color.WHITE);
paint.setTextSize(30);
resetCounters();
}
private boolean annotatePlotEnabled;
public PlotStatistics(long updateDelayMs, boolean annotatePlotEnabled) {
this.updateDelayMs = updateDelayMs;
this.annotatePlotEnabled = annotatePlotEnabled;
}
public void setAnnotatePlotEnabled(boolean enabled) {
this.annotatePlotEnabled = enabled;
}
private void resetCounters() {
longestRenderMs = 0;
shortestRenderMs = 999999999;
latencySamples = 0;
latencySum = 0;
}
private void annotatePlot(Plot source, Canvas canvas) {
long nowMs = System.currentTimeMillis();
// throttle the update frequency:
long msSinceUpdate = (nowMs - lastAnnotation);
if(msSinceUpdate >= updateDelayMs) {
float avgLatency = latencySamples > 0 ? latencySum/latencySamples : 0;
String overallFPS = String.format("%.2f", latencySamples > 0 ? (1000f/msSinceUpdate) * latencySamples : 0);
String potentialFPS = String.format("%.2f", latencySamples > 0 ? 1000f/avgLatency : 0);
annotationString = "FPS (potential): " + potentialFPS + " FPS (actual): " + overallFPS + " Latency (ms) Avg: " + lastLatency + " \nMin: " + shortestRenderMs +
" Max: " + longestRenderMs;
lastAnnotation = nowMs;
resetCounters();
}
RectF r = source.getDisplayDimensions().canvasRect;
if(annotatePlotEnabled) {
canvas.drawText(annotationString, r.centerX(), r.centerY(), paint);
}
}
@Override
public void onBeforeDraw(Plot source, Canvas canvas) {
lastStart = System.currentTimeMillis();
}
@Override
public void onAfterDraw(Plot source, Canvas canvas) {
lastLatency = System.currentTimeMillis() - lastStart;
if(lastLatency < shortestRenderMs) {
shortestRenderMs = lastLatency;
}
if(lastLatency > longestRenderMs) {
longestRenderMs = lastLatency;
}
latencySum += lastLatency;
latencySamples++;
annotatePlot(source, canvas);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/RectFUtils.java 0000664 0000000 0000000 00000002660 12711435674 0030726 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import android.graphics.RectF;
/**
* Convenience methods for dealing with {@link android.graphics.RectF}
*/
public abstract class RectFUtils {
/**
* Determine if two {@link RectF} instances are equal. Must be used in place
* of default equality operation due to a bug that exists in older versions of Android:
* http://stackoverflow.com/questions/13517852/rectf-equals-fails-on-android-versions-below-jelly-bean
* @param r1 May not be null
* @param r2 May not be null
* @return True if r1 and r2 are identical, false otherwise.
*/
public static boolean areIdentical(RectF r1, RectF r2) {
return r1.left == r2.left &&
r1.top == r2.top &&
r1.right == r2.right &&
r1.bottom == r2.bottom;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/Redrawer.java 0000664 0000000 0000000 00000007361 12711435674 0030460 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import android.util.Log;
import com.androidplot.Plot;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Utility class for invoking Plot.redraw() on a background thread
* at a set frequency.
*/
public class Redrawer implements Runnable {
private static final int ONE_SECOND_MS = 1000;
private static final String TAG = Redrawer.class.getName();
private List plots;
private long sleepTime;
private boolean keepRunning;
private boolean keepAlive;
/**
*
* @param plots List of Plot instances to be redrawn
* @param maxRefreshRate Desired frequency at which to redraw plots.
* @param startImmediately If true, invokes run() immediately after construction.
*/
public Redrawer(List plots, float maxRefreshRate, boolean startImmediately) {
this.plots = plots;
setMaxRefreshRate(maxRefreshRate);
new Thread(this).start();
if(startImmediately) {
run();
}
}
public Redrawer(Plot plot, float maxRefreshRate, boolean startImmediately) {
this(Arrays.asList(new Plot[]{plot}), maxRefreshRate, startImmediately);
}
/**
* Temporarily stop redrawing the plot.
*/
public synchronized void pause() {
keepRunning = false;
notify();
Log.d(TAG, "Redrawer paused.");
}
/**
* Start/resume redrawing the plot.
*/
public synchronized void start() {
keepRunning = true;
notify();
Log.d(TAG, "Redrawer started.");
}
/**
* Internally, this causes
* the refresh thread to exit. Should always be called
* before exiting the application.
*/
public synchronized void finish() {
keepRunning = false;
keepAlive = false;
notify();
}
@Override
public void run() {
keepAlive = true;
try {
while(keepAlive) {
if(keepRunning) {
// redraw plot(s) and sleep in an interruptible state for a
// max of sleepTime ms.
// TODO: record start and end timestamps and
// TODO: calculate sleepTime from that, in order to more accurately
// TODO: meet desired refresh rate.
for(Plot plot : plots) {
plot.redraw();
}
synchronized (this) {
wait(sleepTime);
}
} else {
// sleep until notified
synchronized (this) {
wait();
}
}
}
} catch(InterruptedException e) {
} finally {
Log.d(TAG, "Redrawer thread exited.");
}
}
/**
* Set the maximum refresh rate that Redrawer should use. Actual
* refresh rate could be slower.
* @param refreshRate Refresh rate in Hz.
*/
public void setMaxRefreshRate(float refreshRate) {
sleepTime = (long)(ONE_SECOND_MS / refreshRate);
Log.d(TAG, "Set Redrawer refresh rate to " +
refreshRate + "( " + sleepTime + " ms)");
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/SeriesUtils.java 0000664 0000000 0000000 00000010272 12711435674 0031153 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import com.androidplot.Bounds;
import com.androidplot.xy.XYBounds;
import com.androidplot.xy.XYConstraints;
import com.androidplot.xy.XYSeries;
import java.util.List;
/**
* Utilities for dealing with Series data.
*/
public class SeriesUtils {
public static XYBounds minMax(List seriesList) {
return minMax(null, seriesList);
}
public static XYBounds minMax(XYSeries... seriesList) {
return minMax(null, seriesList);
}
/**
* @param constraints may be null.
* @param seriesList
* @return
* @since 0.9.7
*/
public static XYBounds minMax(XYConstraints constraints, List seriesList) {
// TODO: this is inefficient...clean it up!
return minMax(constraints, seriesList.toArray(new XYSeries[seriesList.size()]));
}
/**
* @param constraints May be null.
* @param seriesArray
* @return
* @since 0.9.7
*/
public static XYBounds minMax(XYConstraints constraints, XYSeries... seriesArray) {
final XYBounds bounds = new XYBounds();
// make sure there is series data to iterate over:
if (seriesArray != null && seriesArray.length > 0) {
// iterate over each series
for (XYSeries series : seriesArray) {
if (series.size() > 0) {
for (int i = 0; i < series.size(); i++) {
final Number xi = series.getX(i);
final Number yi = series.getY(i);
// if constraints have been set, make sure this xy coordinate exists within them:
if (constraints == null || constraints.contains(xi, yi)) {
if (xi != null) {
if (bounds.getMinX() == null ||
xi.doubleValue() < bounds.getMinX().doubleValue()) {
bounds.setMinX(xi);
}
if (bounds.getMaxX() == null ||
xi.doubleValue() > bounds.getMaxX().doubleValue()) {
bounds.setMaxX(xi);
}
}
if (yi != null) {
if (bounds.getMinY() == null ||
yi.doubleValue() < bounds.getMinY().doubleValue()) {
bounds.setMinY(yi);
}
if (bounds.getMaxY() == null ||
yi.doubleValue() > bounds.getMaxY().doubleValue()) {
bounds.setMaxY(yi);
}
}
}
}
}
}
}
return bounds;
}
/**
* @param lists
* @return
* @since 0.9.7
*/
public static Bounds minMax(List... lists) {
Number min = null;
Number max = null;
for (List list : lists) {
for (Number i : list) {
if (i != null) {
double di = i.doubleValue();
if (min == null || di < min.doubleValue()) {
min = i;
}
if (max == null || di > max.doubleValue()) {
max = i;
}
}
}
}
return new Bounds(min, max);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/ValPixConverter.java 0000664 0000000 0000000 00000006745 12711435674 0032005 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import android.graphics.PointF;
import android.graphics.RectF;
/**
* Utility methods for converting pixel coordinates into real values and vice versa.
*/
public class ValPixConverter {
private static final int ZERO = 0;
public static float valToPix(double val, double min, double max, float lengthPix, boolean flip) {
if(lengthPix <= ZERO) {
throw new IllegalArgumentException("Length in pixels must be greater than 0.");
}
double range = range(min, max);
double scale = lengthPix / range;
double raw = val - min;
float pix = (float)(raw * scale);
if(flip) {
pix = (lengthPix - pix);
}
return pix;
}
public static double range(double min, double max) {
return (max-min);
}
public static double valPerPix(double min, double max, float lengthPix) {
double valRange = range(min, max);
return valRange/lengthPix;
}
/**
* Convert a value in pixels to the type passed into min/max
* @param pix
* @param min
* @param max
* @param lengthPix
* @param flip True if the axis should be reversed before calculated. This is the case
* with the y axis for screen coords.
* @return
*/
public static double pixToVal(float pix, double min, double max, float lengthPix, boolean flip) {
if(pix < ZERO) {
throw new IllegalArgumentException("pixel values cannot be negative.");
}
if(lengthPix <= ZERO) {
throw new IllegalArgumentException("Length in pixels must be greater than 0.");
}
float pMult = pix;
if(flip) {
pMult = lengthPix - pix;
}
double range = range(min, max);
return ((range / lengthPix) * pMult) + min;
}
/**
* Converts a real value into a pixel value.
* @param x Real d (domain) component of the point to convert.
* @param y Real y (range) component of the point to convert.
* @param plotArea
* @param minX Minimum visible real value on the d (domain) axis.
* @param maxX Maximum visible real value on the y (domain) axis.
* @param minY Minimum visible real value on the y (range) axis.
* @param maxY Maximum visible real value on the y (range axis.
* @return
*/
public static PointF valToPix(Number x, Number y, RectF plotArea, Number minX, Number maxX, Number minY, Number maxY) {
float pixX = ValPixConverter.valToPix(x.doubleValue(), minX.doubleValue(), maxX.doubleValue(), plotArea.width(), false) + (plotArea.left);
float pixY = ValPixConverter.valToPix(y.doubleValue(), minY.doubleValue(), maxY.doubleValue(), plotArea.height(), true) + plotArea.top;
return new PointF(pixX, pixY);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/ZHash.java 0000664 0000000 0000000 00000010607 12711435674 0027717 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import java.util.HashMap;
import java.util.List;
/**
* An implementation of {@link ZIndexable}. Provides fast element retrieval via hash key in addition to
* mutable ordering (z indexing) of elements.
*/
public class ZHash implements ZIndexable {
private HashMap hash;
private ZLinkedList zlist;
{
hash = new HashMap<>();
zlist = new ZLinkedList<>();
}
public int size() {
return zlist.size();
}
public ValueType get(KeyType key) {
return hash.get(key);
}
public List getKeysAsList() {
return zlist;
}
/**
* If key already exists within the structure, it's value is replaced with the new value and
* it's existing order is maintained.
* @param key
* @param value
*/
public synchronized void addToTop(KeyType key, ValueType value) {
if(hash.containsKey(key)) {
hash.put(key, value);
} else {
hash.put(key, value);
zlist.addToTop(key);
}
}
/**
* If key already exists within the structure, it's value is replaced with the new value and
* it's existing order is maintained.
* @param key
* @param value
*/
public synchronized void addToBottom(KeyType key, ValueType value) {
if(hash.containsKey(key)) {
hash.put(key, value);
} else {
hash.put(key, value);
zlist.addToBottom(key);
}
}
public synchronized boolean moveToTop(KeyType element) {
if(!hash.containsKey(element)) {
return false;
} else {
return zlist.moveToTop(element);
}
}
public synchronized boolean moveAbove(KeyType objectToMove, KeyType reference) {
if(objectToMove == reference) {
throw new IllegalArgumentException("Illegal argument to moveAbove(A, B); A cannot be equal to B.");
}
if(!hash.containsKey(reference) || !hash.containsKey(objectToMove)) {
return false;
} else {
return zlist.moveAbove(objectToMove, reference);
}
}
public synchronized boolean moveBeneath(KeyType objectToMove, KeyType reference) {
if(objectToMove == reference) {
throw new IllegalArgumentException("Illegal argument to moveBeaneath(A, B); A cannot be equal to B.");
}
if(!hash.containsKey(reference) || !hash.containsKey(objectToMove)) {
return false;
} else {
return zlist.moveBeneath(objectToMove, reference);
}
}
public synchronized boolean moveToBottom(KeyType key) {
if(!hash.containsKey(key)) {
return false;
} else {
return zlist.moveToBottom(key);
}
}
public synchronized boolean moveUp(KeyType key) {
if (!hash.containsKey(key)) {
return false;
} else {
return zlist.moveUp(key);
}
}
public synchronized boolean moveDown(KeyType key) {
if (!hash.containsKey(key)) {
return false;
} else {
return zlist.moveDown(key);
}
}
@Override
public List elements() {
return zlist;
}
/**
*
* @return Ordered list of keys.
*/
public List keys() {
return elements();
}
public synchronized boolean remove(KeyType key) {
if(hash.containsKey(key)) {
hash.remove(key);
zlist.remove(key);
return true;
} else {
return false;
}
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/ZIndexable.java 0000664 0000000 0000000 00000004261 12711435674 0030726 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import java.util.List;
/**
* Encapsulates the concept of z-indexable objects; Each object is stored above or below each other object and may
* be moved up and down in the queue relative to other elements in the hash or absolutely to the front or back of the queue.
*
* Note that the method names correspond to the order of items drawn directly on top of one another using an iterator;
* the first element drawn (lowest z-index) is effectively the "bottom" element.
* @param
*/
public interface ZIndexable {
/**
* Move above all other elements
* @param element
* @return
*/
boolean moveToTop(ElementType element);
/**
* Move above the specified element
* @param objectToMove
* @param reference
* @return
*/
boolean moveAbove(ElementType objectToMove, ElementType reference);
/**
* Move beneath the specified element
*
* @param objectToMove
* @param reference
* @return
*/
boolean moveBeneath(ElementType objectToMove, ElementType reference);
/**
* Move beneath all other elements
* @param key
* @return
*/
boolean moveToBottom(ElementType key);
/**
* Move up by one element
* @param key
* @return
*/
boolean moveUp(ElementType key);
/**
* Move down by one element
* @param key
* @return
*/
boolean moveDown(ElementType key);
List elements();
} androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/util/ZLinkedList.java 0000664 0000000 0000000 00000003614 12711435674 0031076 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import java.util.LinkedList;
import java.util.List;
public class ZLinkedList extends LinkedList implements ZIndexable {
private ListOrganizer organizer = new ListOrganizer<>(this);
@Override
public boolean moveToTop(Type element) {
return organizer.moveToTop(element);
}
@Override
public boolean moveAbove(Type objectToMove, Type reference) {
return organizer.moveAbove(objectToMove, reference);
}
@Override
public boolean moveBeneath(Type objectToMove, Type reference) {
return organizer.moveBeneath(objectToMove, reference);
}
@Override
public boolean moveToBottom(Type key) {
return organizer.moveToBottom(key);
}
@Override
public boolean moveUp(Type key) {
return organizer.moveUp(key);
}
@Override
public boolean moveDown(Type key) {
return organizer.moveDown(key);
}
@Override
public List elements() {
return organizer.elements();
}
public void addToBottom(Type element) {
organizer.addToBottom(element);
}
public void addToTop(Type element) {
organizer.addToTop(element);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/ 0000775 0000000 0000000 00000000000 12711435674 0025516 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/AxisValueLabelFormatter.java 0000664 0000000 0000000 00000001746 12711435674 0033116 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
public class AxisValueLabelFormatter {
//private Paint textPaint;
private int color;
public AxisValueLabelFormatter(int color) {
this.color = color;
}
public int getColor() {
return color;
}
public void setColor(int color) {
this.color = color;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/BarFormatter.java 0000664 0000000 0000000 00000003774 12711435674 0030764 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Paint;
import com.androidplot.ui.SeriesRenderer;
public class BarFormatter extends LineAndPointFormatter {
public Paint getFillPaint() {
return fillPaint;
}
public void setFillPaint(Paint fillPaint) {
this.fillPaint = fillPaint;
}
public Paint getBorderPaint() {
return borderPaint;
}
public void setBorderPaint(Paint borderPaint) {
this.borderPaint = borderPaint;
}
private Paint fillPaint;
private Paint borderPaint;
{
fillPaint = new Paint();
//fillPaint.setColor(Color.RED);
fillPaint.setStyle(Paint.Style.FILL);
fillPaint.setAlpha(100);
borderPaint = new Paint();
borderPaint.setStyle(Paint.Style.STROKE);
borderPaint.setAlpha(100);
}
/**
* Should only be used in conjunction with calls to configure()...
*/
public BarFormatter() {
}
public BarFormatter(int fillColor, int borderColor) {
fillPaint.setColor(fillColor);
borderPaint.setColor(borderColor);
}
@Override
public Class getRendererClass() {
return BarRenderer.class;
}
@Override
public SeriesRenderer getRendererInstance(XYPlot plot) {
return new BarRenderer(plot);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/BarRenderer.java 0000664 0000000 0000000 00000035271 12711435674 0030564 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map.Entry;
import java.util.TreeMap;
import android.graphics.Canvas;
import android.graphics.RectF;
import com.androidplot.ui.RenderStack;
import com.androidplot.ui.SeriesAndFormatter;
import com.androidplot.util.ValPixConverter;
/**
* Renders the points in an XYSeries as bars.
*/
public class BarRenderer extends GroupRenderer {
private BarRenderStyle renderStyle = BarRenderStyle.OVERLAID; // default Render Style
private BarWidthStyle widthStyle = BarWidthStyle.FIXED_WIDTH; // default Width Style
private float barWidth = 5;
private float barGap = 1;
private Comparator barComparator = new BarComparator();
public enum BarRenderStyle {
OVERLAID, // bars are overlaid in descending y-val order (largest val in back)
STACKED, // bars are drawn stacked vertically on top of each other
SIDE_BY_SIDE // bars are drawn horizontally next to each-other
}
public enum BarWidthStyle {
FIXED_WIDTH, // bar width is always barWidth
VARIABLE_WIDTH // bar width is calculated so that there is only barGap between each bar
}
public BarRenderer(XYPlot plot) {
super(plot);
}
/**
* Sets the width of the bars when using the FIXED_WIDTH render style
* @param barWidth
*/
public void setBarWidth(float barWidth) {
this.barWidth = barWidth;
}
/**
* Sets the size of the gap between the bar (or bar groups) when using the VARIABLE_WIDTH render style
* @param barGap
*/
public void setBarGap(float barGap) {
this.barGap = barGap;
}
public void setBarRenderStyle(BarRenderStyle renderStyle) {
this.renderStyle = renderStyle;
}
public void setBarWidthStyle(BarWidthStyle widthStyle) {
this.widthStyle = widthStyle;
}
public void setBarWidthStyle(BarWidthStyle style, float value) {
setBarWidthStyle(style);
switch (style) {
case FIXED_WIDTH:
setBarWidth(value);
break;
case VARIABLE_WIDTH:
setBarGap(value);
break;
default:
break;
}
}
/**
* Sets a {@link Comparator} used for sorting bars.
*/
public void setBarComparator(Comparator barComparator) {
this.barComparator = barComparator;
}
@Override
public void doDrawLegendIcon(Canvas canvas, RectF rect, BarFormatter formatter) {
canvas.drawRect(rect, formatter.getFillPaint());
canvas.drawRect(rect, formatter.getBorderPaint());
}
/**
* Retrieves the BarFormatter instance that corresponds with the series passed in.
* Can be overridden to return other BarFormatters as a result of touch events etc.
* @param index index of the point being rendered.
* @param series XYSeries to which the point being rendered belongs.
* @return The desired getFormatter or null to use the default.
*/
@SuppressWarnings("UnusedParameters")
public FormatterType getFormatter(int index, XYSeries series) {
return null;
}
@Override
public void onRender(Canvas canvas, RectF plotArea, List> sfList, int seriesSize, RenderStack stack) {
TreeMap axisMap = new TreeMap();
/*
* Build the axisMap (yVal,BarGroup)... a TreeMap of BarGroups
* BarGroups represent a point on the X axis where a single or group of bars need to be drawn.
*/
for(SeriesAndFormatter thisPair : sfList) {
BarGroup barGroup;
// For each value in the series
for(int i = 0; i < seriesSize; i++) {
if (thisPair.getSeries().getX(i) != null) {
// get a new bar object
Bar bar = new Bar(thisPair.getSeries(), thisPair.getFormatter(),i,plotArea);
// Find or create the barGroup
if (axisMap.containsKey(bar.intX)) {
barGroup = axisMap.get(bar.intX);
} else {
barGroup = new BarGroup(bar.intX,plotArea);
axisMap.put(bar.intX, barGroup);
}
barGroup.addBar(bar);
}
}
}
// Loop through the axisMap linking up prev pointers
BarGroup prev, current;
prev = null;
for(Entry mapEntry : axisMap.entrySet()) {
current = mapEntry.getValue();
current.prev = prev;
prev = current;
}
// The default gap between each bar section
int gap = (int) barGap;
// Determine roughly how wide (rough_width) this bar should be. This is then used as a default width
// when there are gaps in the data or for the first/last bars.
float f_rough_width = ((plotArea.width() - ((axisMap.size() - 1) * gap)) / (axisMap.size() - 1));
int rough_width = (int) f_rough_width;
if (rough_width < 0) rough_width = 0;
if (gap > rough_width) {
gap = rough_width / 2;
}
/*
* Calculate the dimensions of each barGroup and then draw each bar within it according to
* the Render Style and Width Style.
*/
for(Number key : axisMap.keySet()) {
BarGroup barGroup = axisMap.get(key);
// Determine the exact left and right X for the Bar Group
switch (widthStyle) {
case FIXED_WIDTH:
// use intX and go halfwidth either side.
barGroup.leftX = barGroup.intX - (int) (barWidth / 2);
barGroup.width = (int) barWidth;
barGroup.rightX = barGroup.leftX + barGroup.width;
break;
case VARIABLE_WIDTH:
if (barGroup.prev != null) {
if (barGroup.intX - barGroup.prev.intX - gap - 1 > (int)(rough_width * 1.5)) {
// use intX and go halfwidth either side.
barGroup.leftX = barGroup.intX - (rough_width / 2);
barGroup.width = rough_width;
barGroup.rightX = barGroup.leftX + barGroup.width;
} else {
// base left off prev right to get the gap correct.
barGroup.leftX = barGroup.prev.rightX + gap + 1;
if (barGroup.leftX > barGroup.intX) barGroup.leftX = barGroup.intX;
// base right off intX + halfwidth.
barGroup.rightX = barGroup.intX + (rough_width / 2);
// calculate the width
barGroup.width = barGroup.rightX - barGroup.leftX;
}
} else {
// use intX and go halfwidth either side.
barGroup.leftX = barGroup.intX - (rough_width / 2);
barGroup.width = rough_width;
barGroup.rightX = barGroup.leftX + barGroup.width;
}
break;
default:
break;
}
/*
* Draw the bars within the barGroup area.
*/
double rangeOrigin = getPlot().getRangeOrigin().doubleValue();
float basePositionY = ValPixConverter.valToPix(rangeOrigin,
getPlot().getCalculatedMinY().doubleValue(),
getPlot().getCalculatedMaxY().doubleValue(),
plotArea.height(), true) + plotArea.top;
switch (renderStyle) {
case OVERLAID:
Collections.sort(barGroup.bars, barComparator);
for (Bar bar : barGroup.bars) {
BarFormatter formatter = bar.getFormatter();
PointLabelFormatter plf = formatter.getPointLabelFormatter();
PointLabeler pointLabeler = null;
if (formatter != null) {
pointLabeler = formatter.getPointLabeler();
}
if (bar.yVal= 2) {
canvas.drawRect(bar.barGroup.leftX, basePositionY, bar.barGroup.rightX, bar.intY, formatter.getFillPaint());
}
canvas.drawRect(bar.barGroup.leftX, basePositionY, bar.barGroup.rightX, bar.intY, formatter.getBorderPaint());
} else { // rising bar
if (bar.barGroup.width >= 2) {
canvas.drawRect(bar.barGroup.leftX, bar.intY, bar.barGroup.rightX, basePositionY, formatter.getFillPaint());
}
canvas.drawRect(bar.barGroup.leftX, bar.intY, bar.barGroup.rightX, basePositionY, formatter.getBorderPaint());
}
if(plf != null && pointLabeler != null) {
canvas.drawText(pointLabeler.getLabel(bar.series, bar.seriesIndex), bar.intX + plf.hOffset, bar.intY + plf.vOffset, plf.getTextPaint());
}
}
break;
case SIDE_BY_SIDE:
int width = barGroup.width / barGroup.bars.size();
int leftX = barGroup.leftX;
Collections.sort(barGroup.bars, barComparator);
for (Bar bar : barGroup.bars) {
BarFormatter formatter = bar.getFormatter();
PointLabelFormatter plf = formatter.getPointLabelFormatter();
PointLabeler pointLabeler = null;
if (formatter != null) {
pointLabeler = formatter.getPointLabeler();
}
if (bar.yVal= 2) {
canvas.drawRect(leftX, basePositionY, leftX + width, bar.intY, formatter.getFillPaint());
}
canvas.drawRect(leftX, basePositionY, leftX + width, bar.intY, formatter.getBorderPaint());
} else { // rising bar
if (bar.barGroup.width >= 2) {
canvas.drawRect(leftX, bar.intY, leftX + width, basePositionY, formatter.getFillPaint());
}
canvas.drawRect(leftX, bar.intY, leftX + width, basePositionY, formatter.getBorderPaint());
}
if(plf != null && pointLabeler != null) {
canvas.drawText(pointLabeler.getLabel(bar.series, bar.seriesIndex), leftX + width/2 + plf.hOffset, bar.intY + plf.vOffset, plf.getTextPaint());
}
leftX = leftX + width;
}
break;
case STACKED:
int bottom = (int) barGroup.plotArea.bottom;
Collections.sort(barGroup.bars, barComparator);
for (Bar b : barGroup.bars) {
BarFormatter formatter = b.getFormatter();
PointLabelFormatter plf = formatter.getPointLabelFormatter();
PointLabeler pointLabeler = null;
if (formatter != null) {
pointLabeler = formatter.getPointLabeler();
}
int height = (int) b.barGroup.plotArea.bottom - b.intY;
int top = bottom - height;
if (b.barGroup.width >= 2) {
canvas.drawRect(b.barGroup.leftX, top, b.barGroup.rightX, bottom, formatter.getFillPaint());
}
canvas.drawRect(b.barGroup.leftX, top, b.barGroup.rightX, bottom, formatter.getBorderPaint());
if(plf != null && pointLabeler != null) {
//canvas.drawText(pointLabeler.getLabel(b.series, b.seriesIndex), b.intX + plf.hOffset, b.intY + plf.vOffset, plf.getTextPaint());
// b.intY should be replaced by top as Text label should be drawn on top of each bar
canvas.drawText(pointLabeler.getLabel(b.series, b.seriesIndex), b.intX + plf.hOffset, top + plf.vOffset, plf.getTextPaint());
}
bottom = top;
}
break;
default:
break;
}
}
}
public class Bar {
public final XYSeries series;
private final FormatterType formatter;
public final int seriesIndex;
public final double yVal, xVal;
public final int intX, intY;
public final float pixX, pixY;
protected BarGroup barGroup;
public Bar(XYSeries series, FormatterType formatter, int seriesIndex, RectF plotArea) {
this.series = series;
this.formatter = formatter;
this.seriesIndex = seriesIndex;
this.xVal = series.getX(seriesIndex).doubleValue();
this.pixX = ValPixConverter.valToPix(xVal, getPlot().getCalculatedMinX().doubleValue(), getPlot().getCalculatedMaxX().doubleValue(), plotArea.width(), false) + (plotArea.left);
this.intX = (int) pixX;
if (series.getY(seriesIndex) != null) {
this.yVal = series.getY(seriesIndex).doubleValue();
this.pixY = ValPixConverter.valToPix(yVal, getPlot().getCalculatedMinY().doubleValue(), getPlot().getCalculatedMaxY().doubleValue(), plotArea.height(), true) + plotArea.top;
this.intY = (int) pixY;
} else {
this.yVal = 0;
this.pixY = plotArea.bottom;
this.intY = (int) pixY;
}
}
public FormatterType getFormatter() {
FormatterType f = BarRenderer.this.getFormatter(seriesIndex, series);
return f != null ? f : formatter;
}
}
private class BarGroup {
public ArrayList bars;
public int intX;
public int width, leftX, rightX;
public RectF plotArea;
public BarGroup prev;
public BarGroup(int intX, RectF plotArea) {
// Setup the TreeMap with the required comparator
this.bars = new ArrayList(); // create a comparator that compares series title given the index.
this.intX = intX;
this.plotArea = plotArea;
}
public void addBar(Bar bar) {
bar.barGroup = this;
this.bars.add(bar);
}
}
@SuppressWarnings("WeakerAccess")
public class BarComparator implements Comparator{
@Override
public int compare(Bar bar1, Bar bar2) {
switch (renderStyle) {
case OVERLAID:
return Integer.valueOf(bar1.intY).compareTo(bar2.intY);
case SIDE_BY_SIDE:
return bar1.series.getTitle().compareToIgnoreCase(bar2.series.getTitle());
case STACKED:
return bar1.series.getTitle().compareToIgnoreCase(bar2.series.getTitle());
default:
return 0;
}
}
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/BoundaryMode.java 0000664 0000000 0000000 00000001363 12711435674 0030754 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
public enum BoundaryMode {
FIXED,
AUTO,
GROW,
SHRINK
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/CatmullRomInterpolator.java 0000664 0000000 0000000 00000024062 12711435674 0033047 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import java.util.ArrayList;
import java.util.List;
/**
* A primitive implementation of Catmull-Rom interpolation, based on the information found at:
* http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/19283471#19283471
*/
public class CatmullRomInterpolator implements Interpolator {
public enum Type {
Uniform,
Centripetal
}
public static class Params implements InterpolationParams {
private int pointPerSegment;
private Type type;
public Params(int pointPerSegment, Type type) {
this.pointPerSegment = pointPerSegment;
this.type = type;
}
@Override
public Class getInterpolatorClass() {
return CatmullRomInterpolator.class;
}
public int getPointPerSegment() {
return pointPerSegment;
}
public void setPointPerSegment(int pointPerSegment) {
this.pointPerSegment = pointPerSegment;
}
public Type getType() {
return type;
}
public void setType(Type type) {
this.type = type;
}
}
/**
* Wraps a normal XYSeries, inserting a new point at the beginning and end of the series.
*/
static class ExtrapolatedXYSeries implements XYSeries {
private final XY first;
private final XY last;
private final XYSeries series;
public ExtrapolatedXYSeries(XYSeries series, XY first, XY last) {
this.series = series;
this.first = first;
this.last = last;
}
@Override
public Number getX(int i) {
if(i == 0) {
return first.x;
} else if(i == series.size() + 1) {
return last.x;
} else {
return series.getX(i-1);
}
}
@Override
public Number getY(int i) {
if(i == 0) {
return first.y;
} else if(i == series.size() + 1) {
return last.y;
} else {
return series.getY(i-1);
}
}
@Override
public int size() {
return series.size() + 2;
}
@Override
public String getTitle() {
return series.getTitle();
}
}
/**
* This method will calculate the Catmull-Rom interpolation curve, returning it as a list of Coord coordinate
* objects. This method in particular adds the first and last control points which are not visible, but required
* for calculating the spline.
*
* @param series The list of original straight line points to calculate an interpolation from.
* @return The list of interpolated coordinates.
* @throws java.lang.IllegalArgumentException if pointsPerSegment is less than 2.
*/
@Override
public List interpolate(XYSeries series, Params params) {
if (params.getPointPerSegment() < 2) {
throw new IllegalArgumentException(
"pointsPerSegment must be greater than 2, since 2 points is just the linear segment.");
}
// Cannot interpolate curves given only two points. Two points
// is best represented as a simple line segment.
if (series.size() < 3) {
throw new IllegalArgumentException("Cannot interpolate a series with fewer than 3 vertices.");
}
// Get the change in x and y between the first and second coordinates.
double dx = series.getX(1).doubleValue() - series.getX(0).doubleValue();
double dy = series.getY(1).doubleValue() - series.getY(0).doubleValue();
// Then using the change, extrapolate backwards to find a control point.
double x1 = series.getX(0).doubleValue() - dx;
double y1 = series.getY(0).doubleValue() - dy;
// Actually create the start point from the extrapolated values.
XY start = new XY(x1, y1);
// Repeat for the end control point.
int n = series.size() -1;
dx = series.getX(n).doubleValue() - series.getX(n-1).doubleValue();
dy = series.getY(n).doubleValue() - series.getY(n - 1).doubleValue();
double xn = series.getX(n).doubleValue() + dx;
double yn = series.getY(n).doubleValue() + dy;
XY end = new XY(xn, yn);
// TODO: figure out whether this extra control-point synthesis is
// TODO: really necessary and either remove the above or fix the below.
// insert the start control point at the start of the vertices list.
// TODO vertices.add(0, start);
// append the end control ponit to the end of the vertices list.
// TODO vertices.add(end);
//}
ExtrapolatedXYSeries extrapolatedXYSeries = new ExtrapolatedXYSeries(series, start, end);
// Dimension a result list of coordinates.
List result = new ArrayList<>();
// When looping, remember that each cycle requires 4 points, starting
// with i and ending with i+3. So we don't loop through all the points.
for (int i = 0; i < extrapolatedXYSeries.size() - 3; i++) {
// Actually calculate the Catmull-Rom curve for one segment.
List points = interpolate(extrapolatedXYSeries, i, params);
// Since the middle points are added twice, once for each bordering
// segment, we only add the 0 index result point for the first
// segment. Otherwise we will have duplicate points.
if (result.size() > 0) {
points.remove(0);
}
// Add the coordinates for the segment to the result list.
result.addAll(points);
}
return result;
}
/**
* Given a list of control points, this will create a list of pointsPerSegment
* points spaced uniformly along the resulting Catmull-Rom curve.
*
* @param series The list of control points, leading and ending with a
* coordinate that is only used for controling the spline and is not visualized.
* @param index The index of control point p0, where p0, p1, p2, and p3 are
* used in order to create a curve between p1 and p2.
* @return the list of coordinates that define the CatmullRom curve
* between the points defined by index+1 and index+2.
*/
public List interpolate(XYSeries series, int index, Params params) {
List result = new ArrayList<>();
double[] x = new double[4];
double[] y = new double[4];
double[] time = new double[4];
for (int i = 0; i < 4; i++) {
x[i] = series.getX(index + i).doubleValue();
y[i] = series.getY(index + i).doubleValue();
time[i] = i;
}
double tstart = 1;
double tend = 2;
if (params.getType() != Type.Uniform) {
double total = 0;
for (int i = 1; i < 4; i++) {
double dx = x[i] - x[i - 1];
double dy = y[i] - y[i - 1];
if (params.getType() == Type.Centripetal) {
total += Math.pow(dx * dx + dy * dy, .25);
} else {
total += Math.pow(dx * dx + dy * dy, .5);
}
time[i] = total;
}
tstart = time[1];
tend = time[2];
}
int segments = params.getPointPerSegment() - 1;
result.add(new XY(series.getX(index + 1), series.getY(index + 1)));
for (int i = 1; i < segments; i++) {
double xi = interpolate(x, time, tstart + (i * (tend - tstart)) / segments);
double yi = interpolate(y, time, tstart + (i * (tend - tstart)) / segments);
result.add(new XY(xi, yi));
}
result.add(new XY(series.getX(index + 2), series.getY(index + 2)));
return result;
}
/**
* Unlike the other implementation here, which uses the default "uniform"
* treatment of t, this computation is used to calculate the same values but
* introduces the ability to "parameterize" the t values used in the
* calculation. This is based on Figure 3 from
* http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf
*
* @param p An array of double values of length 4, where interpolation
* occurs from p1 to p2.
* @param time An array of time measures of length 4, corresponding to each
* p value.
* @param t the actual interpolation ratio from 0 to 1 representing the
* position between p1 and p2 to interpolate the value.
* @return
*/
public static double interpolate(double[] p, double[] time, double t) {
double L01 = p[0] * (time[1] - t) / (time[1] - time[0]) + p[1] * (t - time[0]) / (time[1] - time[0]);
double L12 = p[1] * (time[2] - t) / (time[2] - time[1]) + p[2] * (t - time[1]) / (time[2] - time[1]);
double L23 = p[2] * (time[3] - t) / (time[3] - time[2]) + p[3] * (t - time[2]) / (time[3] - time[2]);
double L012 = L01 * (time[2] - t) / (time[2] - time[0]) + L12 * (t - time[0]) / (time[2] - time[0]);
double L123 = L12 * (time[3] - t) / (time[3] - time[1]) + L23 * (t - time[1]) / (time[3] - time[1]);
double C12 = L012 * (time[2] - t) / (time[2] - time[1]) + L123 * (t - time[1]) / (time[2] - time[1]);
return C12;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/FillDirection.java 0000664 0000000 0000000 00000002253 12711435674 0031112 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
/**
* Defines which edge is used to close a fill path for drawing lines.
*
* TOP - Use the top edge of the plot.
* BOTTOM - Use the bottom edge of the plot.
* LEFT - (Not implemented) Use the left edge of the plot.
* RIGHT - (Not implemented) Use the right edge of the plot.
* DOMAIN_ORIGIN - (Not implemented) Use the domain origin line.
* RANGE_ORIGIN - Use the range origin line.
*/
public enum FillDirection {
TOP,
BOTTOM,
LEFT,
RIGHT,
DOMAIN_ORIGIN,
RANGE_ORIGIN
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/GroupRenderer.java 0000664 0000000 0000000 00000005625 12711435674 0031154 0 ustar 00root root 0000000 0000000 /*
* Copyright 2016 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Canvas;
import android.graphics.RectF;
import android.util.Log;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.RenderStack;
import com.androidplot.ui.SeriesAndFormatter;
import java.util.List;
/**
* Renders data to an XYPlot that potentially contains more than a single yVal per index.
* Examples of such data are bar plot groups, candlestick charts, etc.
* @since 0.9.7
*/
public abstract class GroupRenderer>
extends XYSeriesRenderer {
private static final String TAG = GroupRenderer.class.getName();
public GroupRenderer(XYPlot plot) {
super(plot);
}
@Override
protected void onRender(Canvas canvas, RectF plotArea, XYSeries series,
FormatterType formatter, RenderStack stack) throws PlotRenderException {
// get all the data associated with this renderer:
List> sfList = getSeriesAndFormatterList();
// no data to render so exit:
if(sfList == null) {
return;
}
int seriesLength = sfList.get(0).getSeries().size();
// make sure all associated series are the same length:
for(int i = 1; i < sfList.size(); i++) {
if(sfList.get(i).getSeries().size() != seriesLength) {
// series sizes are irregular so don't try to render:
Log.w(TAG, getClass() + ": " + "not all associated series are of same size.");
return;
}
}
// this renderer uses special element-by-element z-indexing that results in
// all series associated with the renderer being rendered in a single pass, so
// we need to exclude the rest of the series on the render stack from being redrawn later:
stack.disable(getClass());
onRender(canvas, plotArea, sfList, seriesLength, stack);
}
/**
*
* @param canvas
* @param plotArea
* @param sfList
* @param stack
*/
public abstract void onRender(Canvas canvas, RectF plotArea, List> sfList, int size, RenderStack stack);
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/InterpolationParams.java 0000664 0000000 0000000 00000001505 12711435674 0032355 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
/**
* Created by nick_f on 9/25/14.
*/
public interface InterpolationParams {
public Class getInterpolatorClass();
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/Interpolator.java 0000664 0000000 0000000 00000001533 12711435674 0031045 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import java.util.List;
/**
* Created by nick_f on 9/25/14.
*/
public interface Interpolator {
List interpolate(XYSeries series, ParamsType params);
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/LineAndPointFormatter.java 0000664 0000000 0000000 00000013560 12711435674 0032576 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Color;
import android.graphics.Paint;
import com.androidplot.ui.SeriesRenderer;
import com.androidplot.util.PixelUtils;
/**
* Defines the visual aesthetics of an XYSeries; outline color and width, fill style,
* vertex size and color, shadowing, etc.
*/
public class LineAndPointFormatter extends XYSeriesFormatter {
private static final float DEFAULT_LINE_STROKE_WIDTH_DP = 1.5f;
private static final float DEFAULT_VERTEX_STROKE_WIDTH_DP = 4.5f;
// default implementation prints point's yVal:
private PointLabeler pointLabeler = new PointLabeler() {
@Override
public String getLabel(XYSeries series, int index) {
return series.getY(index) + "";
}
};
public FillDirection getFillDirection() {
return fillDirection;
}
/**
* Sets which edge to use to close the line's path for filling purposes.
* See {@link FillDirection}.
* @param fillDirection
*/
public void setFillDirection(FillDirection fillDirection) {
this.fillDirection = fillDirection;
}
protected FillDirection fillDirection = FillDirection.BOTTOM;
protected Paint linePaint;
protected Paint vertexPaint;
protected Paint fillPaint;
protected InterpolationParams interpolationParams;
private PointLabelFormatter pointLabelFormatter;
{
initLinePaint(Color.BLACK);
}
/**
* Should only be used in conjunction with calls to configure()...
*/
public LineAndPointFormatter() {
this(Color.RED, Color.GREEN, Color.BLUE, null);
}
public LineAndPointFormatter(Integer lineColor, Integer vertexColor, Integer fillColor, PointLabelFormatter plf) {
this(lineColor, vertexColor, fillColor, plf, FillDirection.BOTTOM);
}
public LineAndPointFormatter(Integer lineColor, Integer vertexColor,
Integer fillColor, PointLabelFormatter plf, FillDirection fillDir) {
initLinePaint(lineColor);
initVertexPaint(vertexColor);
initFillPaint(fillColor);
setFillDirection(fillDir);
this.setPointLabelFormatter(plf);
}
@Override
public Class getRendererClass() {
return LineAndPointRenderer.class;
}
@Override
public SeriesRenderer getRendererInstance(XYPlot plot) {
return new LineAndPointRenderer(plot);
}
protected void initLinePaint(Integer lineColor) {
if (lineColor == null) {
linePaint = null;
} else {
linePaint = new Paint();
linePaint.setAntiAlias(true);
linePaint.setStrokeWidth(PixelUtils.dpToPix(DEFAULT_LINE_STROKE_WIDTH_DP));
linePaint.setColor(lineColor);
linePaint.setStyle(Paint.Style.STROKE);
}
}
protected void initVertexPaint(Integer vertexColor) {
if (vertexColor == null) {
vertexPaint = null;
} else {
vertexPaint = new Paint();
vertexPaint.setAntiAlias(true);
vertexPaint.setStrokeWidth(PixelUtils.dpToPix(DEFAULT_VERTEX_STROKE_WIDTH_DP));
vertexPaint.setColor(vertexColor);
vertexPaint.setStrokeCap(Paint.Cap.ROUND);
}
}
protected void initFillPaint(Integer fillColor) {
if (fillColor == null) {
fillPaint = null;
} else {
fillPaint = new Paint();
fillPaint.setAntiAlias(true);
fillPaint.setColor(fillColor);
}
}
/**
* Enables the shadow layer on linePaint and shadowPaint by calling
* setShadowLayer() with preset values.
*/
public void enableShadows() {
linePaint.setShadowLayer(1, 3, 3, Color.BLACK);
vertexPaint.setShadowLayer(1, 3, 3, Color.BLACK);
}
public void disableShadows() {
linePaint.setShadowLayer(0, 0, 0, Color.BLACK);
vertexPaint.setShadowLayer(0, 0, 0, Color.BLACK);
}
public Paint getLinePaint() {
return linePaint;
}
public void setLinePaint(Paint linePaint) {
this.linePaint = linePaint;
}
public Paint getVertexPaint() {
return vertexPaint;
}
public void setVertexPaint(Paint vertexPaint) {
this.vertexPaint = vertexPaint;
}
public Paint getFillPaint() {
return fillPaint;
}
public void setFillPaint(Paint fillPaint) {
this.fillPaint = fillPaint;
}
public PointLabelFormatter getPointLabelFormatter() {
return pointLabelFormatter;
}
public void setPointLabelFormatter(PointLabelFormatter pointLabelFormatter) {
this.pointLabelFormatter = pointLabelFormatter;
}
public PointLabeler getPointLabeler() {
return pointLabeler;
}
public void setPointLabeler(PointLabeler pointLabeler) {
this.pointLabeler = pointLabeler;
}
public InterpolationParams getInterpolationParams() {
return interpolationParams;
}
public void setInterpolationParams(InterpolationParams params) {
this.interpolationParams = params;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/LineAndPointRenderer.java 0000664 0000000 0000000 00000024412 12711435674 0032377 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.*;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.RenderStack;
import com.androidplot.util.ValPixConverter;
import java.util.ArrayList;
import java.util.List;
/**
* Renders a point as a line with the vertices marked. Requires 2 or more points to
* be rendered.
*/
public class LineAndPointRenderer extends XYSeriesRenderer {
protected static final int ZERO = 0;
protected static final int ONE = 1;
public LineAndPointRenderer(XYPlot plot) {
super(plot);
}
@Override
public void onRender(Canvas canvas, RectF plotArea, XYSeries series, FormatterType formatter, RenderStack stack) throws PlotRenderException {
drawSeries(canvas, plotArea, series, formatter);
}
@Override
public void doDrawLegendIcon(Canvas canvas, RectF rect, LineAndPointFormatter formatter) {
// horizontal icon:
float centerY = rect.centerY();
float centerX = rect.centerX();
if(formatter.getFillPaint() != null) {
canvas.drawRect(rect, formatter.getFillPaint());
}
if(formatter.getLinePaint() != null) {
canvas.drawLine(rect.left, rect.bottom, rect.right, rect.top, formatter.getLinePaint());
}
if(formatter.getVertexPaint() != null) {
canvas.drawPoint(centerX, centerY, formatter.getVertexPaint());
}
}
/**
* This method exists for StepRenderer to override without having to duplicate any
* additional code.
*/
protected void appendToPath(Path path, PointF thisPoint, PointF lastPoint) {
path.lineTo(thisPoint.x, thisPoint.y);
}
protected void drawSeries(Canvas canvas, RectF plotArea, XYSeries series, LineAndPointFormatter formatter) {
PointF thisPoint;
PointF lastPoint = null;
PointF firstPoint = null;
Paint linePaint = formatter.getLinePaint();
Path path = null;
ArrayList points = new ArrayList<>(series.size());
for (int i = 0; i < series.size(); i++) {
Number y = series.getY(i);
Number x = series.getX(i);
if (y != null && x != null) {
thisPoint = ValPixConverter.valToPix(
x, y,
plotArea,
getPlot().getCalculatedMinX(),
getPlot().getCalculatedMaxX(),
getPlot().getCalculatedMinY(),
getPlot().getCalculatedMaxY());
points.add(thisPoint);
} else {
thisPoint = null;
}
// don't need to do any of this if the line isnt going to be drawn:
if(linePaint != null && formatter.getInterpolationParams() == null) {
if (thisPoint != null) {
// record the first point of the new Path
if (firstPoint == null) {
path = new Path();
firstPoint = thisPoint;
// create our first point at the bottom/x position so filling will look good:
path.moveTo(firstPoint.x, firstPoint.y);
}
if (lastPoint != null) {
appendToPath(path, thisPoint, lastPoint);
}
lastPoint = thisPoint;
} else {
if (lastPoint != null) {
renderPath(canvas, plotArea, path, firstPoint, lastPoint, formatter);
}
firstPoint = null;
lastPoint = null;
}
}
}
if(linePaint != null) {
if(formatter.getInterpolationParams() != null) {
List interpolatedPoints = getInterpolator(
formatter.getInterpolationParams()).interpolate(series,
formatter.getInterpolationParams());
firstPoint = convertPoint(interpolatedPoints.get(ZERO), plotArea);
lastPoint = convertPoint(interpolatedPoints.get(interpolatedPoints.size()-ONE), plotArea);
path = new Path();
path.moveTo(firstPoint.x, firstPoint.y);
for(int i = 1; i < interpolatedPoints.size(); i++) {
thisPoint = convertPoint(interpolatedPoints.get(i), plotArea);
path.lineTo(thisPoint.x, thisPoint.y);
}
}
if(firstPoint != null) {
renderPath(canvas, plotArea, path, firstPoint, lastPoint, formatter);
}
}
renderPoints(canvas, plotArea, series, points, formatter);
}
/**
* TODO: retrieve from a persistent registry
* @param params
* @return An interpol
*/
protected Interpolator getInterpolator(InterpolationParams params) {
try {
return (Interpolator) params.getInterpolatorClass().newInstance();
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
protected PointF convertPoint(XY coord, RectF plotArea) {
return ValPixConverter.valToPix(
coord.x.doubleValue(),
coord.y.doubleValue(),
plotArea,
getPlot().getCalculatedMinX(),
getPlot().getCalculatedMaxX(),
getPlot().getCalculatedMinY(),
getPlot().getCalculatedMaxY());
}
protected void renderPoints(Canvas canvas, RectF plotArea, XYSeries series, List points,
LineAndPointFormatter formatter) {
Paint vertexPaint = formatter.getVertexPaint();
PointLabelFormatter plf = formatter.getPointLabelFormatter();
if (vertexPaint != null || plf != null) {
int i = 0;
for (PointF p : points) {
PointLabeler pointLabeler = formatter.getPointLabeler();
// if vertexPaint is available, draw vertex:
if (vertexPaint != null) {
canvas.drawPoint(p.x, p.y, formatter.getVertexPaint());
}
// if textPaint and pointLabeler are available, draw point's text label:
if (plf != null && pointLabeler != null) {
canvas.drawText(pointLabeler.getLabel(series, i),
p.x + plf.hOffset, p.y + plf.vOffset, plf.getTextPaint());
}
i++;
}
}
}
protected void renderPath(Canvas canvas, RectF plotArea, Path path, PointF firstPoint, PointF lastPoint, LineAndPointFormatter formatter) {
Path outlinePath = new Path(path);
// determine how to close the path for filling purposes:
// We always need to calculate this path because it is also used for
// masking off for region highlighting.
switch (formatter.getFillDirection()) {
case BOTTOM:
path.lineTo(lastPoint.x, plotArea.bottom);
path.lineTo(firstPoint.x, plotArea.bottom);
path.close();
break;
case TOP:
path.lineTo(lastPoint.x, plotArea.top);
path.lineTo(firstPoint.x, plotArea.top);
path.close();
break;
case RANGE_ORIGIN:
float originPix = ValPixConverter.valToPix(
getPlot().getRangeOrigin().doubleValue(),
getPlot().getCalculatedMinY().doubleValue(),
getPlot().getCalculatedMaxY().doubleValue(),
plotArea.height(),
true);
originPix += plotArea.top;
path.lineTo(lastPoint.x, originPix);
path.lineTo(firstPoint.x, originPix);
path.close();
break;
default:
throw new UnsupportedOperationException("Fill direction not yet implemented: " + formatter.getFillDirection());
}
if (formatter.getFillPaint() != null) {
canvas.drawPath(path, formatter.getFillPaint());
}
// draw any visible regions on top of the base region:
double minX = getPlot().getCalculatedMinX().doubleValue();
double maxX = getPlot().getCalculatedMaxX().doubleValue();
double minY = getPlot().getCalculatedMinY().doubleValue();
double maxY = getPlot().getCalculatedMaxY().doubleValue();
// draw each region:
for (RectRegion r : RectRegion.regionsWithin(formatter.getRegions().elements(), minX, maxX, minY, maxY)) {
XYRegionFormatter f = formatter.getRegionFormatter(r);
RectF regionRect = r.getRectF(plotArea, minX, maxX, minY, maxY);
if (regionRect != null) {
try {
canvas.save(Canvas.ALL_SAVE_FLAG);
canvas.clipPath(path);
canvas.drawRect(regionRect, f.getPaint());
} finally {
canvas.restore();
}
}
}
// finally we draw the outline path on top of everything else:
if(formatter.getLinePaint() != null) {
canvas.drawPath(outlinePath, formatter.getLinePaint());
}
path.rewind();
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/PointLabelFormatter.java 0000664 0000000 0000000 00000004746 12711435674 0032311 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PointF;
import com.androidplot.util.PixelUtils;
public class PointLabelFormatter {
private static final float DEFAULT_H_OFFSET_DP = 0;
private static final float DEFAULT_V_OFFSET_DP = -4;
private static final float DEFAULT_TEXT_SIZE_SP = 12;
private Paint textPaint;
public float hOffset;
public float vOffset;
public PointLabelFormatter() {
this(Color.WHITE);
}
public PointLabelFormatter(int textColor) {
this(textColor, PixelUtils.dpToPix(DEFAULT_H_OFFSET_DP),
PixelUtils.dpToPix(DEFAULT_V_OFFSET_DP));
}
/**
*
* @param textColor
* @param hOffset Horizontal offset of text in pixels.
* @param vOffset Vertical offset of text in pixels. Offset is in screen coordinates;
* positive values shift the text further down the screen.
*/
public PointLabelFormatter(int textColor, float hOffset, float vOffset) {
initTextPaint(textColor);
this.hOffset = hOffset;
this.vOffset = vOffset;
}
public Paint getTextPaint() {
return textPaint;
}
public void setTextPaint(Paint textPaint) {
this.textPaint = textPaint;
}
protected void initTextPaint(Integer textColor) {
if (textColor == null) {
setTextPaint(null);
} else {
setTextPaint(new Paint());
getTextPaint().setAntiAlias(true);
getTextPaint().setColor(textColor);
getTextPaint().setTextAlign(Paint.Align.CENTER);
getTextPaint().setTextSize(PixelUtils.spToPix(DEFAULT_TEXT_SIZE_SP));
//textPaint.setStyle(Paint.Style.STROKE);
}
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/PointLabeler.java 0000664 0000000 0000000 00000001353 12711435674 0030743 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
public interface PointLabeler {
public String getLabel(XYSeries series, int index);
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/RectRegion.java 0000664 0000000 0000000 00000015037 12711435674 0030430 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.PointF;
import android.graphics.RectF;
import com.androidplot.LineRegion;
import com.androidplot.util.ValPixConverter;
import java.util.ArrayList;
import java.util.List;
/**
* RectRegion is just a rectangle with additional methods for determining
* intersections with other RectRegion instances. RectRegion operates on
* "native units" which are simply whatever unit type is passed into it by the user.
*/
public class RectRegion {
LineRegion xLineRegion;
LineRegion yLineRegion;
private String label;
/**
*
* @param minX
* @param maxX
* @param minY
* @param maxY
*/
public RectRegion(Number minX, Number maxX, Number minY, Number maxY, String label) {
xLineRegion = new LineRegion(minX, maxX);
yLineRegion = new LineRegion(minY, maxY);
this.setLabel(label);
}
@SuppressWarnings("SameParameterValue")
public RectRegion(Number minX, Number maxX, Number minY, Number maxY) {
this(minX, maxX, minY, maxY, null);
}
public boolean containsPoint(PointF point) {
throw new UnsupportedOperationException("Not yet implemented.");
}
public boolean containsValue(Number x, Number y) {
throw new UnsupportedOperationException("Not yet implemented.");
}
public boolean containsDomainValue(Number value) {
return xLineRegion.contains(value);
}
public boolean containsRangeValue(Number value) {
return yLineRegion.contains(value);
}
public boolean intersects(RectRegion region) {
return intersects(region.getMinX(), region.getMaxX(), region.getMinY(), region.getMaxY());
}
/**
* Tests whether this region intersects the region defined by params. Use
* null to represent infinity. Negative and positive infinity is implied by
* the boundary edge, ie. a maxX of null equals positive infinity while a
* minX of null equals negative infinity.
* @param minX
* @param maxX
* @param minY
* @param maxY
* @return
*/
public boolean intersects(Number minX, Number maxX, Number minY, Number maxY) {
return xLineRegion.intersects(minX, maxX) && yLineRegion.intersects(minY, maxY);
}
public boolean intersects(RectF region, Number visMinX, Number visMaxX, Number visMinY, Number visMaxY) {
RectF thisRegion = getRectF(region, visMinX.doubleValue(), visMaxX.doubleValue(),
visMinY.doubleValue(), visMaxY.doubleValue());
return RectF.intersects(thisRegion, region);
}
public RectF getRectF(RectF plotRect, Number visMinX, Number visMaxX, Number visMinY, Number visMaxY) {
PointF topLeftPoint = ValPixConverter.valToPix(
xLineRegion.getMinVal().doubleValue() != Double.NEGATIVE_INFINITY ? xLineRegion.getMinVal() : visMinX,
yLineRegion.getMaxVal().doubleValue() != Double.POSITIVE_INFINITY ? yLineRegion.getMaxVal() : visMaxY,
plotRect,
visMinX,
visMaxX,
visMinY,
visMaxY);
PointF bottomRightPoint = ValPixConverter.valToPix(
xLineRegion.getMaxVal().doubleValue() != Double.POSITIVE_INFINITY ? xLineRegion.getMaxVal() : visMaxX,
yLineRegion.getMinVal().doubleValue() != Double.NEGATIVE_INFINITY ? yLineRegion.getMinVal() : visMinY,
plotRect,
visMinX,
visMaxX,
visMinY,
visMaxY);
// TODO: figure out why the y-values are inverted
return new RectF(topLeftPoint.x, topLeftPoint.y, bottomRightPoint.x, bottomRightPoint.y);
}
/**
* Returns a list of XYRegions that either completely or partially intersect the area
* defined by params. A null value for any parameter represents infinity / no boundary.
* @param regions The list of regions to search through
* @param minX
* @param maxX
* @param minY
* @param maxY
* @return
*/
public static List regionsWithin(List regions, Number minX, Number maxX, Number minY, Number maxY) {
ArrayList intersectingRegions = new ArrayList();
for(RectRegion r : regions) {
if(r.intersects(minX, maxX, minY, maxY)) {
intersectingRegions.add(r);
}
}
return intersectingRegions;
}
/**
*
* @return Width of this region, in native units
*/
public Number getWidth() {
return distanceBetween(getMinX(), getMaxX());
}
/**
*
* @return Height of this region, in native units
*/
public Number getHeight() {
return distanceBetween(getMinY(), getMaxY());
}
/**
* Calculate the distance between two points in a single dimension.
* @param x
* @param y
* @return
*/
private Number distanceBetween(Number x, Number y) {
return Math.abs(x.doubleValue() - y.doubleValue());
}
public Number getMinX() {
return xLineRegion.getMinVal();
}
public void setMinX(double minX) {
xLineRegion.setMinVal(minX);
}
public Number getMaxX() {
return xLineRegion.getMaxVal();
}
public void setMaxX(Number maxX) {
xLineRegion.setMaxVal(maxX);
}
public Number getMinY() {
return yLineRegion.getMinVal();
}
public void setMinY(Number minY) {
yLineRegion.setMinVal(minY);
}
public Number getMaxY() {
return yLineRegion.getMaxVal();
}
public void setMaxY(Number maxY) {
yLineRegion.setMaxVal(maxY);
}
public String getLabel() {
return label;
}
public void setLabel(String label) {
this.label = label;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/SimpleXYSeries.java 0000664 0000000 0000000 00000021250 12711435674 0031246 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Canvas;
import com.androidplot.Plot;
import com.androidplot.PlotListener;
import java.util.*;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* A convenience class used to create instances of XYPlot generated from Lists of Numbers.
*/
public class SimpleXYSeries implements XYSeries, PlotListener {
private static final String TAG = SimpleXYSeries.class.getName();
@Override
public void onBeforeDraw(Plot source, Canvas canvas) {
lock.readLock().lock();
}
@Override
public void onAfterDraw(Plot source, Canvas canvas) {
lock.readLock().unlock();
}
public enum ArrayFormat {
Y_VALS_ONLY,
XY_VALS_INTERLEAVED
}
private volatile LinkedList xVals = new LinkedList();
private volatile LinkedList yVals = new LinkedList();
private volatile String title = null;
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
public SimpleXYSeries(String title) {
this.title = title;
}
public SimpleXYSeries(ArrayFormat format, String title, Number... model) {
this(asNumberList(model), format, title);
}
protected static List asNumberList(Number... model) {
List numbers = new ArrayList<>();
for(Number n : model) {
numbers.add(n);
}
return numbers;
}
/**
* Generates an XYSeries instance from the List of numbers passed in. This is a convenience class
* and should only be used for static data models; it is not suitable for representing dynamically
* changing data.
*
* @param model A List of Number elements comprising the data model.
* @param format Format of the model. A format of Y_VALS_ONLY means that the array only contains y-values.
* For this format x values are autogenerated using values of 0 through n-1 where n is the size of the model.
* @param title Title of the series
*/
public SimpleXYSeries(List model, ArrayFormat format, String title) {
this(title);
setModel(model, format);
}
public SimpleXYSeries(List xVals, List yVals, String title) {
this(title);
if(xVals == null || yVals == null) {
throw new IllegalArgumentException("Neither the xVals nor the yVals parameters may be null.");
}
if(xVals.size() != yVals.size()) {
throw new IllegalArgumentException("xVals and yVals List parameters must be of the same size.");
}
this.xVals.addAll(xVals);
this.yVals.addAll(yVals);
}
/**
* Use index value as xVal, instead of explicit, user provided xVals.
*/
public void useImplicitXVals() {
lock.writeLock().lock();
try {
xVals = null;
} finally {
lock.writeLock().unlock();
}
}
/**
* Use the provided list of Numbers as yVals and their corresponding indexes as xVals.
* @param model A List of Number elements comprising the data model.
* @param format Format of the model. A format of Y_VALS_ONLY means that the array only contains y-values.
* For this format x values are autogenerated using values of 0 through n-1 where n is the size of the model.
*/
public void setModel(List model, ArrayFormat format) {
lock.writeLock().lock();
try {
// empty the current values:
xVals = null;
yVals.clear();
// make sure the new model has data:
if (model == null || model.size() == 0) {
return;
}
switch (format) {
// array containing only y-vals. assume x = index:
case Y_VALS_ONLY:
for(Number n : model) {
yVals.add(n);
}
break;
// xy interleaved array:
case XY_VALS_INTERLEAVED:
if (xVals == null) {
xVals = new LinkedList();
}
if (model.size() % 2 != 0) {
throw new IndexOutOfBoundsException("Cannot auto-generate series from odd-sized xy List.");
}
// always need an x and y array so init them now:
int sz = model.size() / 2;
for (int i = 0, j = 0; i < sz; i++, j += 2) {
xVals.add(model.get(j));
yVals.add(model.get(j + 1));
}
break;
default:
throw new IllegalArgumentException("Unexpected enum value: " + format);
}
} finally {
lock.writeLock().unlock();
}
}
/**
* Sets individual x value based on index
* @param value
* @param index
*/
public void setX(Number value, int index) {
lock.writeLock().lock();
try {
xVals.set(index, value);
} finally {
lock.writeLock().unlock();
}
}
/**
* Sets individual y value based on index
* @param value
* @param index
*/
public void setY(Number value, int index) {
lock.writeLock().lock();
try {
yVals.set(index, value);
} finally {
lock.writeLock().unlock();
}
}
/**
* Sets xy values based on index
* @param xVal
* @param yVal
* @param index
*/
public void setXY(Number xVal, Number yVal, int index) {
lock.writeLock().lock();
try {
yVals.set(index, yVal);
xVals.set(index, xVal);
} finally {lock.writeLock().unlock();}
}
public void addFirst(Number x, Number y) {
lock.writeLock().lock();
try {
if (xVals != null) {
xVals.addFirst(x);
}
yVals.addFirst(y);
} finally {
lock.writeLock().unlock();
}
}
/**
*
* @return {@link XY} with first equal to x-val and second equal to y-val.
*/
public XY removeFirst() {
lock.writeLock().lock();
try {
if (size() <= 0) {
throw new NoSuchElementException();
}
return new XY(xVals != null ? xVals.removeFirst() : 0, yVals.removeFirst());
} finally {
lock.writeLock().unlock();
}
}
public void addLast(Number x, Number y) {
lock.writeLock().lock();
try {
if (xVals != null) {
xVals.addLast(x);
}
yVals.addLast(y);
} finally {
lock.writeLock().unlock();
}
}
/**
*
* @return {@link XY} with first equal to x-val and second equal to y-val.
*/
public XY removeLast() {
lock.writeLock().lock();
try {
if (size() <= 0) {
throw new NoSuchElementException();
}
return new XY(xVals != null ? xVals.removeLast() : yVals.size() - 1, yVals.removeLast());
} finally {
lock.writeLock().unlock();
}
}
@Override
public String getTitle() {
return title;
}
public void setTitle(String title) {
lock.writeLock().lock();
try {
this.title = title;
} finally {lock.writeLock().unlock();}
}
@Override
public int size() {
return yVals != null ? yVals.size() : 0;
}
@Override
public Number getX(int index) {
return xVals != null ? xVals.get(index) : index;
}
@Override
public Number getY(int index) {
return yVals.get(index);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/StepFormatter.java 0000664 0000000 0000000 00000002541 12711435674 0031162 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.content.Context;
import com.androidplot.ui.SeriesRenderer;
import com.androidplot.util.Configurator;
public class StepFormatter extends LineAndPointFormatter {
/**
* Should only be used in conjunction with calls to configure()...
*/
public StepFormatter() {}
public StepFormatter(Integer lineColor, Integer fillColor) {
initLinePaint(lineColor);
initFillPaint(fillColor);
}
@Override
public Class getRendererClass() {
return StepRenderer.class;
}
@Override
public SeriesRenderer getRendererInstance(XYPlot plot) {
return new StepRenderer(plot);
}
} androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/StepRenderer.java 0000664 0000000 0000000 00000013466 12711435674 0030775 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Path;
import android.graphics.PointF;
/**
* Renders a point as a line with the vertices marked. Requires 2 or more points to
* be rendered.
*/
public class StepRenderer extends LineAndPointRenderer {
public StepRenderer(XYPlot plot) {
super(plot);
}
@Override
protected void appendToPath(Path path, PointF thisPoint, PointF lastPoint) {
//path.lineTo(thisPoint.x, thisPoint.y);
path.lineTo(thisPoint.x, lastPoint.y);
path.lineTo(thisPoint.x, thisPoint.y);
//canvas.drawPoint(point.x, lastPoint.y, format.getVertexPaint());
// next the vertical:
//canvas.drawLine(point.x, lastPoint.y, point.x, point.y, format.getLinePaint());
}
}
/*
public class StepRenderer extends XYSeriesRenderer {
private PointF lastPoint;
private boolean drawLinesEnabled = true;
private boolean drawPointsEnabled = true;
private XYAxisType stepAxis = XYAxisType.DOMAIN;
public StepRenderer(XYPlot plot) {
super(plot);
}
@Override
public void onRender(Canvas canvas, RectF plotArea) throws PlotRenderException {
for(XYSeries series : getPlot().getSeriesListForRenderer(this.getClass())) {
drawSeries(canvas, plotArea, series, getFormatter(series));
}
//foreach(this.)
//foreach()
}
@Override
public void doDrawLegendIcon(Canvas canvas, RectF rect, String text, StepFormatter getFormatter) {
// horizontal icon:
float centerY = rect.centerY();
float centerX = rect.centerX();
canvas.drawLine(rect.left, rect.top, rect.right, rect.bottom, getFormatter.getLinePaint());
canvas.drawPoint(centerX, centerY, getFormatter.getVertexPaint());
//canvas.drawRect(rect, getFormatter.getLinePaint());
}
private void drawSeries(Canvas canvas, RectF plotArea, XYSeries series, StepFormatter getFormatter) throws PlotRenderException {
beginSeries(canvas, plotArea, getFormatter);
//XYDataset series = bundle.getDataset();
//int seriesIndex = bundle.getSeriesIndex();
PointF thisPoint;
for (int i = 0; i < series.size(); i++) {
Number y = series.getY(i);
Number x = series.getD(i);
if (y != null && x != null) {
thisPoint = ValPixConverter.valToPix(
x,
y,
plotArea,
getPlot().getCalculatedMinX(),
getPlot().getCalculatedMaxX(),
getPlot().getCalculatedMinY(),
getPlot().getCalculatedMaxY());
//float pixX = ValPixConverter.valToPix(x.doubleValue(), getPlot().getCalculatedMinX().doubleValue(), getPlot().getCalculatedMaxX().doubleValue(), plotArea.width(), false) + (plotArea.left);
//float pixY = ValPixConverter.valToPix(y.doubleValue(), getPlot().getCalculatedMinY().doubleValue(), getPlot().getCalculatedMaxY().doubleValue(), plotArea.height(), true) + plotArea.top;
//thisPoint = new PointF(pixX, pixY);
} else {
thisPoint = null;
}
drawPoint(canvas, thisPoint, plotArea, getFormatter);
}
endSeries(canvas, plotArea, getFormatter);
}
private void beginSeries(Canvas canvas, RectF plotArea, StepFormatter format) throws PlotRenderException {
lastPoint = null;
}
private void drawPoint(Canvas canvas, PointF point, RectF plotArea, StepFormatter format) throws PlotRenderException {
if (lastPoint != null) {
if (point != null) {
switch(stepAxis) {
case DOMAIN:
// first draw the horizontal line:
canvas.drawLine(lastPoint.x, lastPoint.y, point.x, lastPoint.y, format.getLinePaint());
canvas.drawPoint(point.x, lastPoint.y, format.getVertexPaint());
// next the vertical:
canvas.drawLine(point.x, lastPoint.y, point.x, point.y, format.getLinePaint());
break;
case RANGE:
break;
}
//doDrawLine(canvas, lastPoint, point, plotArea, format);
}
drawLastPoint(canvas, plotArea, format);
}
lastPoint = point;
}
private void endSeries(Canvas canvas, RectF plotArea, StepFormatter format) throws PlotRenderException {
if(lastPoint != null) {
drawLastPoint(canvas, plotArea, format);
}
}
protected void drawLastPoint(Canvas canvas, RectF plotArea, StepFormatter format) throws PlotRenderException {
canvas.drawPoint(lastPoint.x, lastPoint.y, format.getVertexPaint());
}
public XYAxisType getStepAxis() {
return stepAxis;
}
public void setStepAxis(XYAxisType stepAxis) {
this.stepAxis = stepAxis;
}
}
*/
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/ValueMarker.java 0000664 0000000 0000000 00000010372 12711435674 0030602 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Color;
import android.graphics.Paint;
import com.androidplot.ui.PositionMetric;
/**
* Encapsulates a single axis line marker drawn onto an XYPlot at a specified value.
* @param
*/
public abstract class ValueMarker {
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public enum TextOrientation {
HORIZONTAL,
VERTICAL
}
private Number value;
private Paint linePaint;
private Paint textPaint;
//private Paint backgroundPaint;
private TextOrientation textOrientation;
private int textMargin = 2;
private PositionMetricType textPosition;
private String text;
{
linePaint = new Paint();
linePaint.setColor(Color.RED);
linePaint.setAntiAlias(true);
linePaint.setStyle(Paint.Style.STROKE);
textPaint = new Paint();
textPaint.setAntiAlias(true);
textPaint.setColor(Color.RED);
//backgroundPaint = new Paint();
//backgroundPaint.setColor(Color.argb(100, 100, 100, 100));
//backgroundPaint.setColor(Color.DKGRAY);
}
public ValueMarker(Number value, String text, PositionMetricType textPosition) {
this.value = value;
this.textPosition = textPosition;
this.text = text;
}
/**
*
* @param value
* @param text
* @param textPosition
* @param linePaint
* @param textPaint
*/
public ValueMarker(Number value, String text, PositionMetricType textPosition, Paint linePaint, Paint textPaint) {
this(value, text, textPosition);
this.linePaint = linePaint;
this.textPaint = textPaint;
//this.backgroundPaint = backgroundPaint;
}
public ValueMarker(Number value, String text, PositionMetricType textPosition, int linePaint, int textPaint) {
this(value, text, textPosition);
this.linePaint.setColor(linePaint);
this.textPaint.setColor(textPaint);
}
public Number getValue() {
return value;
}
public void setValue(Number value) {
this.value = value;
}
public Paint getLinePaint() {
return linePaint;
}
public void setLinePaint(Paint linePaint) {
this.linePaint = linePaint;
}
public Paint getTextPaint() {
return textPaint;
}
public void setTextPaint(Paint textPaint) {
this.textPaint = textPaint;
}
/*public Paint getBackgroundPaint() {
return backgroundPaint;
}
public void setBackgroundPaint(Paint backgroundPaint) {
this.backgroundPaint = backgroundPaint;
}*/
public TextOrientation getTextOrientation() {
return textOrientation;
}
/**
* Currently not implemented. Sets the orientation of the text portion of this
* ValueMarker.
* @param textOrientation
*/
public void setTextOrientation(TextOrientation textOrientation) {
this.textOrientation = textOrientation;
}
/**
* Currently not implemented.
* @return
*/
public int getTextMargin() {
return textMargin;
}
public void setTextMargin(int textMargin) {
this.textMargin = textMargin;
}
public PositionMetricType getTextPosition() {
return textPosition;
}
public void setTextPosition(PositionMetricType textPosition) {
this.textPosition = textPosition;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XValueMarker.java 0000664 0000000 0000000 00000003561 12711435674 0030734 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Paint;
import com.androidplot.ui.YLayoutStyle;
import com.androidplot.ui.YPositionMetric;
public class XValueMarker extends ValueMarker {
/**
*
* @param value
* @param text Set to null to use the plot's default getFormatter.
*/
public XValueMarker(Number value, String text) {
super(value, text, new YPositionMetric(3, YLayoutStyle.ABSOLUTE_FROM_TOP));
}
/**
*
* @param value
* @param text Set to null to use the plot's default getFormatter.
* @param textPosition
* @param linePaint
* @param textPaint
*/
public XValueMarker(Number value, String text, YPositionMetric textPosition, Paint linePaint, Paint textPaint) {
super(value, text, textPosition, linePaint, textPaint);
}
/**
*
* @param value
* @param text Set to null to use the plot's default getFormatter.
* @param textPosition
* @param linePaint
* @param textPaint
*/
public XValueMarker(Number value, String text, YPositionMetric textPosition, int linePaint, int textPaint) {
super(value, text, textPosition, linePaint, textPaint);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XY.java 0000664 0000000 0000000 00000001506 12711435674 0026723 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
/**
* A pair of x/y coordinates
*/
public class XY {
public Number x;
public Number y;
public XY(Number x, Number y) {
this.x = x;
this.y = y;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYAxisType.java 0000664 0000000 0000000 00000001327 12711435674 0030413 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
public enum XYAxisType {
DOMAIN,
RANGE
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYBounds.java 0000664 0000000 0000000 00000004653 12711435674 0030104 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import com.androidplot.Bounds;
/**
* Defines a rectangle using xy min/max values. XYBounds differs from {@link RectRegion} in that
* it accepts null values.
* @since 0.9.7
*/
public class XYBounds {
private Bounds xBounds;
private Bounds yBounds;
public XYBounds() {
this(null, null, null, null);
}
public XYBounds(Number minX, Number maxX, Number minY, Number maxY) {
xBounds = new Bounds(minX, maxX);
yBounds = new Bounds(minY, maxY);
}
/**
* Compares the input bounds xy min/max vals against this instance's current xy min/max vals.
* If the input.min is less than this.min then this.min will be set to input.min.
* If the input.max is greater than this.max then this.max will be set to input.max
* @param input
*/
public void union(XYBounds input) {
xBounds.union(input.getXBounds());
yBounds.union(input.getYBounds());
}
public void setXBounds(Bounds xBounds) {
this.xBounds = xBounds;
}
public void setYBounds(Bounds yBounds) {
this.yBounds = yBounds;
}
public Bounds getXBounds() {
return xBounds;
}
public Bounds getYBounds() {
return yBounds;
}
public Number getMinX() {
return xBounds.getMin();
}
public void setMinX(Number minX) {
xBounds.setMin(minX);
}
public Number getMaxX() {
return xBounds.getMax();
}
public void setMaxX(Number maxX) {
xBounds.setMax(maxX);
}
public Number getMinY() {
return yBounds.getMin();
}
public void setMinY(Number minY) {
yBounds.setMin(minY);
}
public Number getMaxY() {
return yBounds.getMax();
}
public void setMaxY(Number maxY) {
yBounds.setMax(maxY);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYConstraints.java 0000664 0000000 0000000 00000011124 12711435674 0031150 0 ustar 00root root 0000000 0000000 /*
* Copyright 2016 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
/**
* Calculates the min/max constraints for an xy plane.
* @since 0.9.7
*/
public class XYConstraints {
// used for calculating the domain/range extents that will be displayed on the plot.
// using boundaries and origins are mutually exclusive. because of this,
// setting one will disable the other. when only setting the FramingModel,
// the origin or boundary is set to the current value of the plot.
private XYFramingModel domainFramingModel = XYFramingModel.EDGE;
private XYFramingModel rangeFramingModel = XYFramingModel.EDGE;
// determines how boundaries adjust as new min/max values are encountered:
private BoundaryMode domainUpperBoundaryMode = BoundaryMode.AUTO;
private BoundaryMode domainLowerBoundaryMode = BoundaryMode.AUTO;
private BoundaryMode rangeUpperBoundaryMode = BoundaryMode.AUTO;
private BoundaryMode rangeLowerBoundaryMode = BoundaryMode.AUTO;
private Number minX;
private Number maxX;
private Number minY;
private Number maxY;
public XYConstraints() {
this(null, null, null, null);
}
public XYConstraints(Number minX, Number maxX, Number minY, Number maxY) {
this.minX = minX;
this.minY = minY;
this.maxX = maxX;
this.maxY = maxY;
}
public boolean contains(Number x, Number y) {
if(x == null || y == null) {
// this is essentially an invisible point:
return false;
} else {
final double dx = x.doubleValue();
if(minX != null && dx < minX.doubleValue()) {
return false;
} else if(maxX != null && dx > maxX.doubleValue()) {
return false;
} else {
final double dy = y.doubleValue();
if(minY != null && dy < minY.doubleValue()) {
return false;
} else if(maxY != null && dy > maxY.doubleValue()) {
return false;
}
}
return true;
}
}
public Number getMinX() {
return minX;
}
public Number getMaxX() {
return maxX;
}
public Number getMinY() {
return minY;
}
public Number getMaxY() {
return maxY;
}
public XYFramingModel getDomainFramingModel() {
return domainFramingModel;
}
public void setDomainFramingModel(XYFramingModel domainFramingModel) {
this.domainFramingModel = domainFramingModel;
}
public XYFramingModel getRangeFramingModel() {
return rangeFramingModel;
}
public void setRangeFramingModel(XYFramingModel rangeFramingModel) {
this.rangeFramingModel = rangeFramingModel;
}
public BoundaryMode getDomainUpperBoundaryMode() {
return domainUpperBoundaryMode;
}
public void setDomainUpperBoundaryMode(BoundaryMode domainUpperBoundaryMode) {
this.domainUpperBoundaryMode = domainUpperBoundaryMode;
}
public BoundaryMode getDomainLowerBoundaryMode() {
return domainLowerBoundaryMode;
}
public void setDomainLowerBoundaryMode(BoundaryMode domainLowerBoundaryMode) {
this.domainLowerBoundaryMode = domainLowerBoundaryMode;
}
public BoundaryMode getRangeUpperBoundaryMode() {
return rangeUpperBoundaryMode;
}
public void setRangeUpperBoundaryMode(BoundaryMode rangeUpperBoundaryMode) {
this.rangeUpperBoundaryMode = rangeUpperBoundaryMode;
}
public BoundaryMode getRangeLowerBoundaryMode() {
return rangeLowerBoundaryMode;
}
public void setRangeLowerBoundaryMode(BoundaryMode rangeLowerBoundaryMode) {
this.rangeLowerBoundaryMode = rangeLowerBoundaryMode;
}
public void setMinX(Number minX) {
this.minX = minX;
}
public void setMaxX(Number maxX) {
this.maxX = maxX;
}
public void setMinY(Number minY) {
this.minY = minY;
}
public void setMaxY(Number maxY) {
this.maxY = maxY;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYFramingModel.java 0000664 0000000 0000000 00000001333 12711435674 0031206 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
public enum XYFramingModel {
ORIGIN,
EDGE,
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYGraphWidget.java 0000664 0000000 0000000 00000140565 12711435674 0031062 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.*;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.BoxModel;
import com.androidplot.ui.LayoutManager;
import com.androidplot.ui.RenderStack;
import com.androidplot.ui.Size;
import com.androidplot.ui.widget.Widget;
import com.androidplot.util.*;
import java.text.DecimalFormat;
import java.text.Format;
/**
* Displays graphical data (lines, points, etc.) annotated with domain and range tick markers.
*/
public class XYGraphWidget extends Widget {
private static final int ZERO = 0;
private static final int ONE = 1;
private static final int TWO = 2;
private static final float FLOAT_ONE = 1;
private static final int MARKER_LABEL_SPACING = TWO;
// max size of domain tick labels in pixels
private float domainTickLabelWidth = 15;
// ...
private float rangeTickLabelWidth = 41;
private float domainTickLabelVerticalOffset = -5;
private float domainTickLabelHorizontalOffset = ZERO;
// allows tweaking of text position
private float rangeTickLabelHorizontalOffset = FLOAT_ONE;
// allows tweaking of text position
private float rangeTickLabelVerticalOffset = ZERO;
private int ticksPerRangeLabel = ONE;
private int ticksPerDomainLabel = ONE;
private BoxModel gridBox = new BoxModel();
private DisplayDimensions gridDimensions;
private int domainTickExtension = 5;
private int rangeTickExtension = 5;
private int domainLabelSubTickExtension = ZERO;
private int rangeLabelSubTickExtension = ZERO;
private Paint gridBackgroundPaint;
private Paint rangeGridLinePaint;
private Paint rangeSubGridLinePaint;
private Paint domainGridLinePaint;
private Paint domainSubGridLinePaint;
private Paint domainTickLabelPaint;
private Paint rangeTickLabelPaint;
private Paint domainCursorPaint;
private Paint rangeCursorPaint;
private Paint cursorLabelPaint;
private Paint cursorLabelBackgroundPaint;
private XYPlot plot;
private Format rangeValueFormat;
private Format domainValueFormat;
private Paint domainOriginLinePaint;
private Paint rangeOriginLinePaint;
private Paint domainOriginTickLabelPaint;
private Paint rangeOriginTickLabelPaint;
private float domainCursorPosition;
private float rangeCursorPosition;
private boolean drawCursorLabelEnabled = true;
private boolean drawMarkersEnabled = true;
private boolean rangeAxisLeft = true;
private boolean domainAxisBottom = true;
private boolean rangeTick = true;
private boolean rangeSubTick = true;
private boolean domainTick = true;
private boolean domainSubTick = true;
private float rangeLabelOrientation;
private float domainLabelOrientation;
private Mapping domainTickLabelPaintMap;
private Mapping rangeTickLabelPaintMap;
private ZHash axisValueLabelRegions;
private RenderStack renderStack;
private static final float DEFAULT_TICK_LABEL_TEXT_SIZE_PX = PixelUtils.spToPix(15); // 15sp
public float getRangeLabelOrientation() {
return rangeLabelOrientation;
}
public void setRangeLabelOrientation(float rangeLabelOrientation) {
this.rangeLabelOrientation = rangeLabelOrientation;
}
public float getDomainLabelOrientation() {
return domainLabelOrientation;
}
public void setDomainLabelOrientation(float domainLabelOrientation) {
this.domainLabelOrientation = domainLabelOrientation;
}
/**
*
* @return
*/
public Mapping getDomainTickLabelPaintMap() {
return domainTickLabelPaintMap;
}
/**
* Set a mapping to override the Paint used to draw domain labels. The mapping should
* return null for values that should not be overridden.
* @param domainTickLabelPaintMap
*/
public void setDomainTickLabelPaintMap(Mapping domainTickLabelPaintMap) {
this.domainTickLabelPaintMap = domainTickLabelPaintMap;
}
public Mapping getRangeTickLabelPaintMap() {
return rangeTickLabelPaintMap;
}
/**
* Set a mapping to override the Paint used to draw range labels. The mapping should
* return null for values that should not be overridden.
* @param rangeLabelTickPaintMap
*/
public void setRangeLabelTickPaintMap(Mapping rangeLabelTickPaintMap) {
this.rangeTickLabelPaintMap = rangeLabelTickPaintMap;
}
public BoxModel getGridBox() {
return gridBox;
}
public void setGridBox(BoxModel gridBox) {
this.gridBox = gridBox;
}
public Paint getDomainCursorPaint() {
return domainCursorPaint;
}
/**
*
* @param domainCursorPaint The {@link Paint} used to draw the domain cursor line.
* Set to null (default) to disable.
*/
public void setDomainCursorPaint(Paint domainCursorPaint) {
this.domainCursorPaint = domainCursorPaint;
}
public Paint getRangeCursorPaint() {
return rangeCursorPaint;
}
/**
*
* @param rangeCursorPaint The {@link Paint} used to draw the range cursor line.
* Set to null (default) to disable.
*/
public void setRangeCursorPaint(Paint rangeCursorPaint) {
this.rangeCursorPaint = rangeCursorPaint;
}
{
gridBackgroundPaint = new Paint();
gridBackgroundPaint.setColor(Color.rgb(140, 140, 140));
gridBackgroundPaint.setStyle(Paint.Style.FILL);
rangeGridLinePaint = new Paint();
rangeGridLinePaint.setColor(Color.rgb(180, 180, 180));
rangeGridLinePaint.setAntiAlias(true);
rangeGridLinePaint.setStyle(Paint.Style.STROKE);
domainGridLinePaint = new Paint(rangeGridLinePaint);
domainSubGridLinePaint = new Paint(domainGridLinePaint);
rangeSubGridLinePaint = new Paint(rangeGridLinePaint);
domainOriginLinePaint = new Paint();
domainOriginLinePaint.setColor(Color.WHITE);
domainOriginLinePaint.setAntiAlias(true);
rangeOriginLinePaint = new Paint();
rangeOriginLinePaint.setColor(Color.WHITE);
rangeOriginLinePaint.setAntiAlias(true);
domainOriginTickLabelPaint = new Paint();
domainOriginTickLabelPaint.setColor(Color.WHITE);
domainOriginTickLabelPaint.setAntiAlias(true);
domainOriginTickLabelPaint.setTextAlign(Paint.Align.CENTER);
domainOriginTickLabelPaint.setTextSize(DEFAULT_TICK_LABEL_TEXT_SIZE_PX);
rangeOriginTickLabelPaint = new Paint();
rangeOriginTickLabelPaint.setColor(Color.WHITE);
rangeOriginTickLabelPaint.setAntiAlias(true);
rangeOriginTickLabelPaint.setTextAlign(Paint.Align.RIGHT);
rangeOriginTickLabelPaint.setTextSize(DEFAULT_TICK_LABEL_TEXT_SIZE_PX);
domainTickLabelPaint = new Paint();
domainTickLabelPaint.setColor(Color.LTGRAY);
domainTickLabelPaint.setAntiAlias(true);
domainTickLabelPaint.setTextAlign(Paint.Align.CENTER);
domainTickLabelPaint.setTextSize(DEFAULT_TICK_LABEL_TEXT_SIZE_PX);
rangeTickLabelPaint = new Paint();
rangeTickLabelPaint.setColor(Color.LTGRAY);
rangeTickLabelPaint.setAntiAlias(true);
rangeTickLabelPaint.setTextAlign(Paint.Align.RIGHT);
rangeTickLabelPaint.setTextSize(DEFAULT_TICK_LABEL_TEXT_SIZE_PX);
domainCursorPaint = new Paint();
domainCursorPaint.setColor(Color.YELLOW);
rangeCursorPaint = new Paint();
rangeCursorPaint.setColor(Color.YELLOW);
cursorLabelPaint = new Paint();
cursorLabelPaint.setColor(Color.YELLOW);
cursorLabelBackgroundPaint = new Paint();
cursorLabelBackgroundPaint.setColor(Color.argb(100, 50, 50, 50));
setMarginTop(7);
setMarginRight(4);
setMarginBottom(4);
rangeValueFormat = new DecimalFormat("0.0");
domainValueFormat = new DecimalFormat("0.0");
axisValueLabelRegions = new ZHash<>();
setClippingEnabled(true);
}
public XYGraphWidget(LayoutManager layoutManager, XYPlot plot, Size size) {
super(layoutManager, size);
this.plot = plot;
renderStack = new RenderStack(plot);
}
public ZIndexable getAxisValueLabelRegions() {
return axisValueLabelRegions;
}
/**
* Add a new Region used for rendering axis valuelabels. Note that it is
* possible to add multiple Region instances which overlap, in which cast
* the last region to be added will be used. It is up to the developer to
* guard against this often undesireable situation.
*
* @param region
* @param formatter
*/
public void addAxisValueLabelRegion(RectRegion region,
AxisValueLabelFormatter formatter) {
axisValueLabelRegions.addToTop(region, formatter);
}
/**
* Convenience method - wraps addAxisValueLabelRegion, using
* Double.POSITIVE_INFINITY and Double.NEGATIVE_INFINITY to mask off range
* axis value labels.
*
* @param min
* @param max
* @param formatter
*
*/
public void addDomainAxisValueLabelRegion(double min, double max,
AxisValueLabelFormatter formatter) {
addAxisValueLabelRegion(new RectRegion(min, max,
Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, null),
formatter);
}
/**
* Convenience method - wraps addAxisValueLabelRegion, using
* Double.POSITIVE_INFINITY and Double.NEGATIVE_INFINITY to mask off domain
* axis value labels.
*
* @param min
* @param max
* @param formatter
*/
public void addRangeAxisValueLabelRegion(double min, double max,
AxisValueLabelFormatter formatter) {
addAxisValueLabelRegion(new RectRegion(Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY, min, max, null), formatter);
}
/**
* Returns the formatter associated with the first (bottom) Region
* containing x and y.
*
* @param x
* @param y
* @return the formatter associated with the first (bottom) region
* containing x and y. null otherwise.
*/
public AxisValueLabelFormatter getAxisValueLabelFormatterForVal(double x,
double y) {
for (RectRegion r : axisValueLabelRegions.elements()) {
if (r.containsValue(x, y)) {
return axisValueLabelRegions.get(r);
}
}
return null;
}
public AxisValueLabelFormatter getAxisValueLabelFormatterForDomainVal(
double val) {
for (RectRegion r : axisValueLabelRegions.elements()) {
if (r.containsDomainValue(val)) {
return axisValueLabelRegions.get(r);
}
}
return null;
}
public AxisValueLabelFormatter getAxisValueLabelFormatterForRangeVal(
double val) {
for (RectRegion r : axisValueLabelRegions.elements()) {
if (r.containsRangeValue(val)) {
return axisValueLabelRegions.get(r);
}
}
return null;
}
private String getFormattedRangeValue(Number value) {
return rangeValueFormat.format(value);
}
private String getFormattedDomainValue(Number value) {
return domainValueFormat.format(value);
}
/**
* Convenience method. Wraps getYVal(float)
*
* @param point
* @return
*/
public Double getYVal(PointF point) {
return getYVal(point.y);
}
/**
* Converts a y pixel to a y value.
*
* @param yPix
* @return
*/
public Double getYVal(float yPix) {
if (plot.getCalculatedMinY() == null
|| plot.getCalculatedMaxY() == null) {
return null;
}
return ValPixConverter.pixToVal(yPix - gridDimensions.paddedRect.top, plot
.getCalculatedMinY().doubleValue(), plot.getCalculatedMaxY()
.doubleValue(), gridDimensions.paddedRect.height(), true);
}
/**
* Convenience method. Wraps getXVal(float)
*
* @param point
* @return
*/
public Double getXVal(PointF point) {
return getXVal(point.x);
}
/**
* Converts an x pixel into an x value.
*
* @param xPix
* @return
*/
public Double getXVal(float xPix) {
if (plot.getCalculatedMinX() == null
|| plot.getCalculatedMaxX() == null) {
return null;
}
return ValPixConverter.pixToVal(xPix - gridDimensions.paddedRect.left, plot
.getCalculatedMinX().doubleValue(), plot.getCalculatedMaxX()
.doubleValue(), gridDimensions.paddedRect.width(), false);
}
@Override
protected void doOnDraw(Canvas canvas, RectF widgetRect)
throws PlotRenderException {
calculateGridDimensions(widgetRect);
// don't draw if we have no space to draw into
if ((gridDimensions.paddedRect.height() > ZERO) && (gridDimensions.paddedRect.width() > ZERO)) {
if (plot.getCalculatedMinX() != null
&& plot.getCalculatedMaxX() != null
&& plot.getCalculatedMinY() != null
&& plot.getCalculatedMaxY() != null) {
drawGrid(canvas);
drawData(canvas);
drawCursors(canvas);
if (isDrawMarkersEnabled()) {
drawMarkers(canvas);
}
}
}
}
private void calculateGridDimensions(RectF widgetRect) {
RectF r = new RectF(widgetRect.left + ((rangeAxisLeft) ?
rangeTickLabelWidth : ONE),
widgetRect.top + ((domainAxisBottom) ? ONE : domainTickLabelWidth),
widgetRect.right - ((rangeAxisLeft) ? ONE : rangeTickLabelWidth),
widgetRect.bottom - ((domainAxisBottom) ? domainTickLabelWidth : ONE));
// don't calculate if nothing has changed:
if(gridDimensions == null || !RectFUtils.areIdentical(r, gridDimensions.canvasRect)) {
RectF mRect = gridBox.getMarginatedRect(r);
RectF pRect = gridBox.getPaddedRect(mRect);
gridDimensions = new DisplayDimensions(r, mRect, pRect);
}
}
private void drawTickText(Canvas canvas, XYAxisType axis, Number value,
float xPix, float yPix, Paint labelPaint) {
AxisValueLabelFormatter rf = null;
String txt = null;
double v = value.doubleValue();
int canvasState = canvas.save();
try {
switch (axis) {
case DOMAIN:
rf = getAxisValueLabelFormatterForDomainVal(v);
txt = getFormattedDomainValue(value);
canvas.rotate(getDomainLabelOrientation(), xPix, yPix);
break;
case RANGE:
rf = getAxisValueLabelFormatterForRangeVal(v);
txt = getFormattedRangeValue(value);
canvas.rotate(getRangeLabelOrientation(), xPix, yPix);
break;
default:
throw new RuntimeException("Invalid axis type: " + axis);
}
// if a matching region formatter was found, create a clone
// of labelPaint and use the formatter's color. Otherwise
// just use labelPaint:
Paint p;
if (rf != null) {
p = new Paint(labelPaint);
p.setColor(rf.getColor());
} else {
p = labelPaint;
}
canvas.drawText(txt, xPix, yPix, p);
} finally {
canvas.restoreToCount(canvasState);
}
}
private void drawDomainTick(Canvas canvas, float xPix, Number xVal,
Paint labelPaint, Paint linePaint, boolean drawLineOnly) {
final RectF gridRect = gridDimensions.paddedRect;
if (!drawLineOnly) {
if (linePaint != null && (domainTick || domainTickExtension > ZERO)) {
if (domainAxisBottom){
canvas.drawLine(xPix, domainTick ? gridRect.top : gridRect.bottom,
xPix, gridRect.bottom + domainTickExtension, linePaint);
} else {
canvas.drawLine(xPix, gridRect.top - domainTickExtension,
xPix, domainTick ? gridRect.bottom : gridRect.top, linePaint);
}
}
if (labelPaint != null) {
float fontHeight = FontUtils.getFontHeight(labelPaint);
float yPix;
if (domainAxisBottom){
yPix = gridRect.bottom + domainTickExtension
+ domainTickLabelVerticalOffset + fontHeight;
} else {
yPix = gridRect.top - domainTickExtension
- domainTickLabelVerticalOffset;
}
drawTickText(canvas, XYAxisType.DOMAIN, xVal,
xPix + domainTickLabelHorizontalOffset, yPix,
labelPaint);
}
} else if (linePaint != null && (domainSubTick || domainLabelSubTickExtension > ZERO)) {
if (domainAxisBottom){
canvas.drawLine(xPix, domainSubTick ? gridRect.top : gridRect.bottom,
xPix, gridRect.bottom + domainLabelSubTickExtension, linePaint);
} else {
canvas.drawLine(xPix, gridRect.top - domainLabelSubTickExtension,
xPix, domainSubTick ? gridRect.bottom : gridRect.top, linePaint);
}
}
}
public void drawRangeTick(Canvas canvas, float yPix, Number yVal,
Paint labelPaint, Paint linePaint, boolean drawLineOnly) {
final RectF gridRect = gridDimensions.paddedRect;
if (!drawLineOnly) {
if (linePaint != null && (rangeTick || rangeTickExtension > ZERO)) {
if (rangeAxisLeft){
canvas.drawLine(gridRect.left - rangeTickExtension, yPix,
rangeTick ? gridRect.right : gridRect.left, yPix, linePaint);
} else {
canvas.drawLine(rangeTick ? gridRect.left : gridRect.right, yPix,
gridRect.right + rangeTickExtension, yPix, linePaint);
}
}
if (labelPaint != null) {
float xPix;
if (rangeAxisLeft){
xPix = gridRect.left
- (rangeTickExtension + rangeTickLabelHorizontalOffset);
} else {
xPix = gridRect.right
+ (rangeTickExtension + rangeTickLabelHorizontalOffset);
}
drawTickText(canvas, XYAxisType.RANGE, yVal, xPix, yPix - rangeTickLabelVerticalOffset,
labelPaint);
}
} else if (linePaint != null && (rangeSubTick || rangeLabelSubTickExtension > ZERO)) {
if (rangeAxisLeft){
canvas.drawLine(gridRect.left - rangeLabelSubTickExtension, yPix,
rangeSubTick ? gridRect.right : gridRect.left, yPix, linePaint);
} else {
canvas.drawLine(rangeTick ? gridRect.left : gridRect.right, yPix,
gridRect.right + rangeLabelSubTickExtension, yPix, linePaint);
}
}
}
/**
* Draws the drid and domain/range labels for the plot.
*
* @param canvas
*/
protected void drawGrid(Canvas canvas) {
final RectF paddedGridRect = gridDimensions.paddedRect;
if (gridBackgroundPaint != null) {
canvas.drawRect(gridDimensions.paddedRect, gridBackgroundPaint);
}
float domainOriginF;
if (plot.getDomainOrigin() != null) {
double domainOriginVal = plot.getDomainOrigin().doubleValue();
domainOriginF = ValPixConverter.valToPix(domainOriginVal, plot
.getCalculatedMinX().doubleValue(), plot
.getCalculatedMaxX().doubleValue(), paddedGridRect.width(),
false);
domainOriginF += paddedGridRect.left;
// if no origin is set, use the leftmost value visible on the grid:
} else {
domainOriginF = paddedGridRect.left;
}
XYStep domainStep = XYStepCalculator.getStep(plot, XYAxisType.DOMAIN,
paddedGridRect, plot.getCalculatedMinX().doubleValue(), plot
.getCalculatedMaxX().doubleValue());
// draw domain origin:
if (domainOriginF >= paddedGridRect.left
&& domainOriginF <= paddedGridRect.right) {
if (domainOriginLinePaint != null){
domainOriginLinePaint.setTextAlign(Paint.Align.CENTER);
}
Paint olp = domainTickLabelPaintMap != null ?
domainTickLabelPaintMap.get(plot.getDomainOrigin()) : domainOriginTickLabelPaint;
if(olp == null) {
olp = domainTickLabelPaint;
}
drawDomainTick(canvas, domainOriginF, plot.getDomainOrigin()
.doubleValue(), olp, domainOriginLinePaint, false);
}
// draw ticks LEFT of origin:
float xPix = domainOriginF - domainStep.getStepPix();
for (int i = ONE; xPix >= paddedGridRect.left; xPix = domainOriginF
- (i * domainStep.getStepPix())) {
double xVal = plot.getDomainOrigin().doubleValue() - i
* domainStep.getStepVal();
Paint dlp = domainTickLabelPaintMap != null ?
domainTickLabelPaintMap.get(xVal) : domainTickLabelPaint;
if (dlp == null) {
dlp = domainTickLabelPaint;
}
if (xPix >= paddedGridRect.left && xPix <= paddedGridRect.right) {
if (i % getTicksPerDomainLabel() == ZERO) {
drawDomainTick(canvas, xPix, xVal, dlp, domainGridLinePaint, false);
} else {
drawDomainTick(canvas, xPix, xVal, dlp, domainSubGridLinePaint, true);
}
}
i++;
}
// draw ticks RIGHT of origin:
xPix = domainOriginF + domainStep.getStepPix();
for (int i = ONE; xPix <= paddedGridRect.right; xPix = domainOriginF
+ (i * domainStep.getStepPix())) {
double xVal = plot.getDomainOrigin().doubleValue() + i
* domainStep.getStepVal();
Paint dlp = domainTickLabelPaintMap != null ?
domainTickLabelPaintMap.get(xVal) : domainTickLabelPaint;
if (dlp == null) {
dlp = domainTickLabelPaint;
}
if (xPix >= paddedGridRect.left && xPix <= paddedGridRect.right) {
if (i % getTicksPerDomainLabel() == ZERO) {
drawDomainTick(canvas, xPix, xVal, dlp, domainGridLinePaint, false);
} else {
drawDomainTick(canvas, xPix, xVal, dlp, domainSubGridLinePaint, true);
}
}
i++;
}
// draw range origin:
float rangeOriginF;
if (plot.getRangeOrigin() != null) {
double rangeOriginD = plot.getRangeOrigin().doubleValue();
rangeOriginF = ValPixConverter.valToPix(rangeOriginD, plot
.getCalculatedMinY().doubleValue(), plot
.getCalculatedMaxY().doubleValue(),
paddedGridRect.height(), true);
rangeOriginF += paddedGridRect.top;
// if no origin is set, use the leftmost value visible on the grid
} else {
rangeOriginF = paddedGridRect.bottom;
}
XYStep rangeStep = XYStepCalculator.getStep(plot, XYAxisType.RANGE,
paddedGridRect, plot.getCalculatedMinY().doubleValue(), plot
.getCalculatedMaxY().doubleValue());
// draw range origin:
if (rangeOriginF >= paddedGridRect.top
&& rangeOriginF <= paddedGridRect.bottom) {
if (rangeOriginLinePaint != null){
rangeOriginLinePaint.setTextAlign(Paint.Align.RIGHT);
}
Paint olp = rangeTickLabelPaintMap != null ?
rangeTickLabelPaintMap.get(plot.getRangeOrigin()) : rangeOriginTickLabelPaint;
if(olp == null) {
olp = rangeTickLabelPaint;
}
drawRangeTick(canvas, rangeOriginF, plot.getRangeOrigin()
.doubleValue(), olp,
rangeOriginLinePaint, false);
}
// draw ticks ABOVE origin:
float yPix = rangeOriginF - rangeStep.getStepPix();
for (int i = ONE; yPix >= paddedGridRect.top; yPix = rangeOriginF
- (i * rangeStep.getStepPix())) {
double yVal = plot.getRangeOrigin().doubleValue() + i
* rangeStep.getStepVal();
Paint rlp = rangeTickLabelPaintMap != null ?
rangeTickLabelPaintMap.get(yVal) : rangeTickLabelPaint;
if (rlp == null) {
rlp = rangeTickLabelPaint;
}
if (yPix >= paddedGridRect.top && yPix <= paddedGridRect.bottom) {
if (i % getTicksPerRangeLabel() == ZERO) {
drawRangeTick(canvas, yPix, yVal, rlp,
rangeGridLinePaint, false);
} else {
drawRangeTick(canvas, yPix, yVal, rlp,
rangeSubGridLinePaint, true);
}
}
i++;
}
// draw ticks BENEATH origin:
yPix = rangeOriginF + rangeStep.getStepPix();
for (int i = ONE; yPix <= paddedGridRect.bottom; yPix = rangeOriginF
+ (i * rangeStep.getStepPix())) {
double yVal = plot.getRangeOrigin().doubleValue() - i
* rangeStep.getStepVal();
Paint rlp = rangeTickLabelPaintMap != null ?
rangeTickLabelPaintMap.get(yVal) : rangeTickLabelPaint;
if (rlp == null) {
rlp = rangeTickLabelPaint;
}
if (yPix >= paddedGridRect.top && yPix <= paddedGridRect.bottom) {
if (i % getTicksPerRangeLabel() == ZERO) {
drawRangeTick(canvas, yPix, yVal, rlp,
rangeGridLinePaint, false);
} else {
drawRangeTick(canvas, yPix, yVal, rlp,
rangeSubGridLinePaint, true);
}
}
i++;
}
}
/**
* Renders the text associated with user defined markers
*
* @param canvas
* @param text
* @param marker
* @param x
* @param y
*/
private void drawMarkerText(Canvas canvas, String text, ValueMarker marker,
float x, float y) {
final RectF paddedRect = gridDimensions.paddedRect;
x += MARKER_LABEL_SPACING;
y -= MARKER_LABEL_SPACING;
RectF textRect = new RectF(FontUtils.getStringDimensions(text,
marker.getTextPaint()));
textRect.offsetTo(x, y - textRect.height());
if (textRect.right > paddedRect.right) {
textRect.offset(-(textRect.right - paddedRect.right), ZERO);
}
if (textRect.top < paddedRect.top) {
textRect.offset(0, paddedRect.top - textRect.top);
}
canvas.drawText(text, textRect.left, textRect.bottom,
marker.getTextPaint());
}
protected void drawMarkers(Canvas canvas) {
for (YValueMarker marker : plot.getYValueMarkers()) {
final RectF paddedRect = gridDimensions.paddedRect;
if (marker.getValue() != null) {
double yVal = marker.getValue().doubleValue();
float yPix = ValPixConverter.valToPix(yVal, plot
.getCalculatedMinY().doubleValue(), plot
.getCalculatedMaxY().doubleValue(), paddedRect
.height(), true);
yPix += paddedRect.top;
canvas.drawLine(paddedRect.left, yPix,
paddedRect.right, yPix, marker.getLinePaint());
float xPix = marker.getTextPosition().getPixelValue(
paddedRect.width());
xPix += paddedRect.left;
if (marker.getText() != null) {
drawMarkerText(canvas, marker.getText(), marker, xPix, yPix);
} else {
drawMarkerText(canvas,
getFormattedRangeValue(marker.getValue()), marker,
xPix, yPix);
}
}
}
for (XValueMarker marker : plot.getXValueMarkers()) {
final RectF paddedRect = gridDimensions.paddedRect;
if (marker.getValue() != null) {
double xVal = marker.getValue().doubleValue();
float xPix = ValPixConverter.valToPix(xVal, plot
.getCalculatedMinX().doubleValue(), plot
.getCalculatedMaxX().doubleValue(), paddedRect
.width(), false);
xPix += paddedRect.left;
canvas.drawLine(xPix, paddedRect.top, xPix,
paddedRect.bottom, marker.getLinePaint());
float yPix = marker.getTextPosition().getPixelValue(
paddedRect.height());
yPix += paddedRect.top;
if (marker.getText() != null) {
drawMarkerText(canvas, marker.getText(), marker, xPix, yPix);
} else {
drawMarkerText(canvas,
getFormattedDomainValue(marker.getValue()), marker,
xPix, yPix);
}
}
}
}
protected void drawCursors(Canvas canvas) {
final RectF paddedRect = gridDimensions.paddedRect;
boolean hasDomainCursor = false;
// draw the domain cursor:
if (domainCursorPaint != null
&& domainCursorPosition <= paddedRect.right
&& domainCursorPosition >= paddedRect.left) {
hasDomainCursor = true;
canvas.drawLine(domainCursorPosition, paddedRect.top,
domainCursorPosition, paddedRect.bottom,
domainCursorPaint);
}
boolean hasRangeCursor = false;
// draw the range cursor:
if (rangeCursorPaint != null
&& rangeCursorPosition >= paddedRect.top
&& rangeCursorPosition <= paddedRect.bottom) {
hasRangeCursor = true;
canvas.drawLine(paddedRect.left, rangeCursorPosition,
paddedRect.right, rangeCursorPosition, rangeCursorPaint);
}
if (drawCursorLabelEnabled && cursorLabelPaint != null
&& hasRangeCursor && hasDomainCursor) {
String label = "X="
+ getDomainValueFormat().format(getDomainCursorVal());
label += " Y=" + getRangeValueFormat().format(getRangeCursorVal());
// convert the label dimensions rect into floating-point:
RectF cursorRect = new RectF(FontUtils.getPackedStringDimensions(
label, cursorLabelPaint));
cursorRect.offsetTo(domainCursorPosition, rangeCursorPosition
- cursorRect.height());
// if we are too close to the right edge of the plot, we will move
// the label to the left side of our cursor:
if (cursorRect.right >= paddedRect.right) {
cursorRect.offsetTo(domainCursorPosition - cursorRect.width(),
cursorRect.top);
}
// same thing for the top edge of the plot:
// dunno why but these rects can have negative values for top and bottom.
if (cursorRect.top <= paddedRect.top) {
cursorRect.offsetTo(cursorRect.left, rangeCursorPosition);
}
if (cursorLabelBackgroundPaint != null) {
canvas.drawRect(cursorRect, cursorLabelBackgroundPaint);
}
canvas.drawText(label, cursorRect.left, cursorRect.bottom,
cursorLabelPaint);
}
}
/**
* Draws lines and points for each element in the series.
*
* @param canvas
* @throws PlotRenderException
*/
protected void drawData(Canvas canvas) throws PlotRenderException {
try {
canvas.save(Canvas.ALL_SAVE_FLAG);
canvas.clipRect(gridDimensions.marginatedRect, android.graphics.Region.Op.INTERSECT);
renderStack.sync();
for(RenderStack.StackElement thisElement : renderStack.getElements()) {
if(thisElement.isEnabled()) {
plot.getRenderer(thisElement.get().getFormatter().getRendererClass()).
render(canvas, gridDimensions.paddedRect, thisElement.get(), renderStack);
}
}
} finally {
canvas.restore();
}
}
protected void drawPoint(Canvas canvas, PointF point, Paint paint) {
canvas.drawPoint(point.x, point.y, paint);
}
public float getDomainTickLabelWidth() {
return domainTickLabelWidth;
}
public void setDomainTickLabelWidth(float domainTickLabelWidth) {
this.domainTickLabelWidth = domainTickLabelWidth;
}
public float getRangeTickLabelWidth() {
return rangeTickLabelWidth;
}
public void setRangeTickLabelWidth(float rangeTickLabelWidth) {
this.rangeTickLabelWidth = rangeTickLabelWidth;
}
public float getDomainTickLabelVerticalOffset() {
return domainTickLabelVerticalOffset;
}
public void setDomainTickLabelVerticalOffset(float domainTickLabelVerticalOffset) {
this.domainTickLabelVerticalOffset = domainTickLabelVerticalOffset;
}
public float getDomainTickLabelHorizontalOffset() {
return domainTickLabelHorizontalOffset;
}
public void setDomainTickLabelHorizontalOffset(float domainTickLabelHorizontalOffset) {
this.domainTickLabelHorizontalOffset = domainTickLabelHorizontalOffset;
}
public float getRangeTickLabelHorizontalOffset() {
return rangeTickLabelHorizontalOffset;
}
public void setRangeTickLabelHorizontalOffset(float rangeTickLabelHorizontalOffset) {
this.rangeTickLabelHorizontalOffset = rangeTickLabelHorizontalOffset;
}
public float getRangeTickLabelVerticalOffset() {
return rangeTickLabelVerticalOffset;
}
public void setRangeTickLabelVerticalOffset(float rangeTickLabelVerticalOffset) {
this.rangeTickLabelVerticalOffset = rangeTickLabelVerticalOffset;
}
public Paint getGridBackgroundPaint() {
return gridBackgroundPaint;
}
public void setGridBackgroundPaint(Paint gridBackgroundPaint) {
this.gridBackgroundPaint = gridBackgroundPaint;
}
public Paint getDomainTickLabelPaint() {
return domainTickLabelPaint;
}
public void setDomainTickLabelPaint(Paint domainTickLabelPaint) {
this.domainTickLabelPaint = domainTickLabelPaint;
}
public Paint getRangeTickLabelPaint() {
return rangeTickLabelPaint;
}
public void setRangeTickLabelPaint(Paint rangeTickLabelPaint) {
this.rangeTickLabelPaint = rangeTickLabelPaint;
}
/**
* Get the paint used to draw the domain grid line.
*/
public Paint getDomainGridLinePaint() {
return domainGridLinePaint;
}
/**
* Set the paint used to draw the domain grid line.
* @param gridLinePaint
*/
public void setDomainGridLinePaint(Paint gridLinePaint) {
this.domainGridLinePaint = gridLinePaint;
}
/**
* Get the paint used to draw the range grid line.
*/
public Paint getRangeGridLinePaint() {
return rangeGridLinePaint;
}
/**
* Get the paint used to draw the domain grid line.
*/
public Paint getDomainSubGridLinePaint() {
return domainSubGridLinePaint;
}
/**
* Set the paint used to draw the domain grid line.
* @param gridLinePaint
*/
public void setDomainSubGridLinePaint(Paint gridLinePaint) {
this.domainSubGridLinePaint = gridLinePaint;
}
/**
* Set the Paint used to draw the range grid line.
* @param gridLinePaint
*/
public void setRangeGridLinePaint(Paint gridLinePaint) {
this.rangeGridLinePaint = gridLinePaint;
}
/**
* Get the paint used to draw the range grid line.
*/
public Paint getRangeSubGridLinePaint() {
return rangeSubGridLinePaint;
}
/**
* Set the Paint used to draw the range grid line.
* @param gridLinePaint
*/
public void setRangeSubGridLinePaint(Paint gridLinePaint) {
this.rangeSubGridLinePaint = gridLinePaint;
}
// TODO: make a generic renderer queue.
public Format getRangeValueFormat() {
return rangeValueFormat;
}
public void setRangeValueFormat(Format rangeValueFormat) {
this.rangeValueFormat = rangeValueFormat;
}
public Format getDomainValueFormat() {
return domainValueFormat;
}
public void setDomainValueFormat(Format domainValueFormat) {
this.domainValueFormat = domainValueFormat;
}
public int getDomainTickExtension() {
return domainTickExtension;
}
public void setDomainTickExtension(int domainTickExtension) {
this.domainTickExtension = domainTickExtension;
}
public int getRangeTickExtension() {
return rangeTickExtension;
}
public int getDomainLabelSubTickExtension() {
return domainLabelSubTickExtension;
}
public void setDomainLabelSubTickExtension(int domainLabelSubTickExtension) {
this.domainLabelSubTickExtension = domainLabelSubTickExtension;
}
public void setRangeTickExtension(int rangeTickExtension) {
this.rangeTickExtension = rangeTickExtension;
}
public int getRangeLabelSubTickExtension() {
return rangeLabelSubTickExtension;
}
public void setRangeLabelSubTickExtension(int rangeLabelSubTickExtension) {
this.rangeLabelSubTickExtension = rangeLabelSubTickExtension;
}
public int getTicksPerRangeLabel() {
return ticksPerRangeLabel;
}
public void setTicksPerRangeLabel(int ticksPerRangeLabel) {
this.ticksPerRangeLabel = ticksPerRangeLabel;
}
public int getTicksPerDomainLabel() {
return ticksPerDomainLabel;
}
public void setTicksPerDomainLabel(int ticksPerDomainLabel) {
this.ticksPerDomainLabel = ticksPerDomainLabel;
}
public Paint getDomainOriginLinePaint() {
return domainOriginLinePaint;
}
public void setDomainOriginLinePaint(Paint domainOriginLinePaint) {
this.domainOriginLinePaint = domainOriginLinePaint;
}
public Paint getRangeOriginLinePaint() {
return rangeOriginLinePaint;
}
public void setRangeOriginLinePaint(Paint rangeOriginLinePaint) {
this.rangeOriginLinePaint = rangeOriginLinePaint;
}
public Paint getDomainOriginTickLabelPaint() {
return domainOriginTickLabelPaint;
}
public void setDomainOriginTickLabelPaint(Paint domainOriginTickLabelPaint) {
this.domainOriginTickLabelPaint = domainOriginTickLabelPaint;
}
public Paint getRangeOriginTickLabelPaint() {
return rangeOriginTickLabelPaint;
}
public void setRangeOriginTickLabelPaint(Paint rangeOriginTickLabelPaint) {
this.rangeOriginTickLabelPaint = rangeOriginTickLabelPaint;
}
public void setCursorPosition(float x, float y) {
setDomainCursorPosition(x);
setRangeCursorPosition(y);
}
public void setCursorPosition(PointF point) {
setCursorPosition(point.x, point.y);
}
public float getDomainCursorPosition() {
return domainCursorPosition;
}
public Double getDomainCursorVal() {
return getXVal(getDomainCursorPosition());
}
public void setDomainCursorPosition(float domainCursorPosition) {
this.domainCursorPosition = domainCursorPosition;
}
public float getRangeCursorPosition() {
return rangeCursorPosition;
}
public Double getRangeCursorVal() {
return getYVal(getRangeCursorPosition());
}
public void setRangeCursorPosition(float rangeCursorPosition) {
this.rangeCursorPosition = rangeCursorPosition;
}
public Paint getCursorLabelPaint() {
return cursorLabelPaint;
}
public void setCursorLabelPaint(Paint cursorLabelPaint) {
this.cursorLabelPaint = cursorLabelPaint;
}
public Paint getCursorLabelBackgroundPaint() {
return cursorLabelBackgroundPaint;
}
public void setCursorLabelBackgroundPaint(Paint cursorLabelBackgroundPaint) {
this.cursorLabelBackgroundPaint = cursorLabelBackgroundPaint;
}
public boolean isDrawMarkersEnabled() {
return drawMarkersEnabled;
}
public void setDrawMarkersEnabled(boolean drawMarkersEnabled) {
this.drawMarkersEnabled = drawMarkersEnabled;
}
public boolean isRangeAxisLeft() {
return rangeAxisLeft;
}
public void setRangeAxisLeft(boolean rangeAxisLeft) {
this.rangeAxisLeft = rangeAxisLeft;
}
public boolean isDomainAxisBottom() {
return domainAxisBottom;
}
public void setDomainAxisBottom(boolean domainAxisBottom) {
this.domainAxisBottom = domainAxisBottom;
}
public boolean isRangeTick() {
return rangeTick;
}
public void setRangeTick(boolean rangeTick) {
this.rangeTick = rangeTick;
}
public boolean isRangeSubTick() {
return rangeSubTick;
}
public void setRangeSubTick(boolean rangeSubTick) {
this.rangeSubTick = rangeSubTick;
}
public boolean isDomainTick() {
return domainTick;
}
public void setDomainTick(boolean domainTick) {
this.domainTick = domainTick;
}
public boolean isDomainSubTick() {
return domainSubTick;
}
public void setDomainSubTick(boolean domainSubTick) {
this.domainSubTick = domainSubTick;
}
/*
* set the position of the range axis labels. Set the labelPaint textSizes before setting this.
* This call sets the various vertical and horizontal offsets and widths to good defaults.
*
* @param rangeAxisLeft axis labels are on the left hand side not the right hand side.
* @param rangeAxisOverlay axis labels are overlaid on the plot, not external to it.
* @param tickSize the size of the tick extensions for none overlaid axis.
* @param maxLableString Sample label representing the biggest size space needs to be allocated for.
*/
public void setRangeAxisPosition(boolean rangeAxisLeft, boolean rangeAxisOverlay, int tickSize, String maxLableString){
setRangeAxisLeft(rangeAxisLeft);
if (rangeAxisOverlay) {
setRangeTickLabelWidth(1); // needs to be at least 1 to display grid line.
setRangeTickLabelHorizontalOffset(-TWO);
setRangeTickLabelVerticalOffset(TWO); // get above the line
Paint p = getRangeTickLabelPaint();
if (p != null) {
p.setTextAlign(((rangeAxisLeft)?Paint.Align.LEFT:Paint.Align.RIGHT));
}
Paint po = getRangeOriginTickLabelPaint();
if (po != null) {
po.setTextAlign(((rangeAxisLeft)?Paint.Align.LEFT:Paint.Align.RIGHT));
}
setRangeTickExtension(ZERO);
} else {
setRangeTickLabelWidth(ONE); // needs to be at least 1 to display grid line.
// if we have a paint this gets bigger.
setRangeTickLabelHorizontalOffset(FLOAT_ONE);
setRangeTickExtension(tickSize);
Paint p = getRangeTickLabelPaint();
if (p != null) {
p.setTextAlign(((!rangeAxisLeft)?Paint.Align.LEFT:Paint.Align.RIGHT));
Rect r = FontUtils.getPackedStringDimensions(maxLableString,p);
setRangeTickLabelVerticalOffset(r.top / TWO);
setRangeTickLabelWidth(r.right + getRangeTickExtension());
}
Paint po = getRangeOriginTickLabelPaint();
if (po != null) {
po.setTextAlign(((!rangeAxisLeft)?Paint.Align.LEFT:Paint.Align.RIGHT));
}
}
}
/*
* set the position of the domain axis labels. Set the labelPaint textSizes before setting this.
* This call sets the various vertical and horizontal offsets and widths to good defaults.
*
* @param domainAxisBottom axis labels are on the bottom not the top of the plot.
* @param domainAxisOverlay axis labels are overlaid on the plot, not external to it.
* @param tickSize the size of the tick extensions for non overlaid axis.
* @param maxLableString Sample label representing the biggest size space needs to be allocated for.
*/
public void setDomainAxisPosition(boolean domainAxisBottom, boolean domainAxisOverlay, int tickSize, String maxLabelString){
setDomainAxisBottom(domainAxisBottom);
if (domainAxisOverlay) {
setDomainTickLabelWidth(ONE); // needs to be at least 1 to display grid line.
setDomainTickLabelVerticalOffset(TWO); // get above the line
setDomainTickExtension(ZERO);
Paint p = getDomainTickLabelPaint();
if (p != null) {
Rect r = FontUtils.getPackedStringDimensions(maxLabelString,p);
if (domainAxisBottom){
setDomainTickLabelVerticalOffset(TWO * r.top);
} else {
setDomainTickLabelVerticalOffset(r.top - FLOAT_ONE);
}
}
} else {
setDomainTickLabelWidth(1); // needs to be at least 1 to display grid line.
// if we have a paint this gets bigger.
setDomainTickExtension(tickSize);
Paint p = getDomainTickLabelPaint();
if (p != null) {
float fontHeight = FontUtils.getFontHeight(p);
if (domainAxisBottom){
setDomainTickLabelVerticalOffset(-4.0f);
} else {
setDomainTickLabelVerticalOffset(FLOAT_ONE);
}
setDomainTickLabelWidth(fontHeight + getDomainTickExtension());
}
}
}
public DisplayDimensions getGridDimensions() {
return gridDimensions;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYLegendWidget.java 0000664 0000000 0000000 00000020234 12711435674 0031205 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.*;
import com.androidplot.ui.LayoutManager;
import com.androidplot.ui.SeriesAndFormatter;
import com.androidplot.ui.Size;
import com.androidplot.ui.TableModel;
import com.androidplot.ui.widget.Widget;
import com.androidplot.util.FontUtils;
import java.util.*;
public class XYLegendWidget extends Widget {
/**
* This class is of no use outside of XYLegendWidget. It's just used to alphabetically sort
* Region legend entries.
*/
private static class RegionEntryComparator implements Comparator> {
@Override
public int compare(Map.Entry o1, Map.Entry o2) {
return o1.getValue().compareTo(o2.getValue());
}
}
private enum CellType {
SERIES,
REGION
}
private XYPlot plot;
//private float iconWidth = 12;
private Paint textPaint;
private Paint iconBorderPaint;
private TableModel tableModel;
private boolean drawIconBackgroundEnabled = true;
private boolean drawIconBorderEnabled = true;
private Size iconSize;
private static final RegionEntryComparator regionEntryComparator = new RegionEntryComparator();
//private RectF iconRect = new RectF(0, 0, ICON_WIDTH_DEFAULT, ICON_HEIGHT_DEFAULT);
{
textPaint = new Paint();
textPaint.setColor(Color.LTGRAY);
textPaint.setAntiAlias(true);
iconBorderPaint = new Paint();
iconBorderPaint.setStyle(Paint.Style.STROKE);
//regionEntryComparator = new RegionEntryComparator();
}
public XYLegendWidget(LayoutManager layoutManager, XYPlot plot,
Size widgetSize,
TableModel tableModel,
Size iconSize) {
super(layoutManager, widgetSize);
this.plot = plot;
setTableModel(tableModel);
this.iconSize = iconSize;
}
public synchronized void setTableModel(TableModel tableModel) {
this.tableModel = tableModel;
}
private RectF getIconRect(RectF cellRect) {
float cellRectCenterY = cellRect.top + (cellRect.height()/2);
RectF iconRect = iconSize.getRectF(cellRect);
// center the icon rect vertically
float centeredIconOriginY = cellRectCenterY - (iconRect.height()/2);
iconRect.offsetTo(cellRect.left + 1, centeredIconOriginY);
return iconRect;
}
private static float getRectCenterY(RectF cellRect) {
return cellRect.top + (cellRect.height()/2);
}
private void beginDrawingCell(Canvas canvas, RectF iconRect) {
Paint bgPaint = plot.getGraphWidget().getGridBackgroundPaint();
if(drawIconBackgroundEnabled && bgPaint != null) {
canvas.drawRect(iconRect, bgPaint);
}
}
private void finishDrawingCell(Canvas canvas, RectF cellRect, RectF iconRect, String text) {
Paint bgPaint = plot.getGraphWidget().getGridBackgroundPaint();
if(drawIconBorderEnabled && bgPaint != null) {
iconBorderPaint.setColor(bgPaint.getColor());
canvas.drawRect(iconRect, iconBorderPaint);
}
float centeredTextOriginY = getRectCenterY(cellRect) + (FontUtils.getFontHeight(textPaint)/2);
if (textPaint.getTextAlign().equals(Paint.Align.RIGHT)) {
canvas.drawText(text, iconRect.left - 2, centeredTextOriginY, textPaint);
} else {
canvas.drawText(text, iconRect.right + 2, centeredTextOriginY, textPaint);
}
}
protected void drawRegionLegendIcon(Canvas canvas, RectF rect, XYRegionFormatter formatter) {
canvas.drawRect(rect, formatter.getPaint());
}
private void drawRegionLegendCell(Canvas canvas, XYRegionFormatter formatter, RectF cellRect, String text) {
RectF iconRect = getIconRect(cellRect);
beginDrawingCell(canvas, iconRect);
drawRegionLegendIcon(
canvas,
iconRect,
formatter
);
finishDrawingCell(canvas, cellRect, iconRect, text);
}
private void drawSeriesLegendCell(Canvas canvas, XYSeriesRenderer renderer, XYSeriesFormatter formatter, RectF cellRect, String seriesTitle) {
RectF iconRect = getIconRect(cellRect);
beginDrawingCell(canvas, iconRect);
renderer.drawSeriesLegendIcon(
canvas,
iconRect,
formatter);
finishDrawingCell(canvas, cellRect, iconRect, seriesTitle);
}
@Override
protected synchronized void doOnDraw(Canvas canvas, RectF widgetRect) {
if(plot.isEmpty()) {
return;
}
// Keep an alphabetically sorted list of regions:
TreeSet> sortedRegions = new TreeSet>(new RegionEntryComparator());
// Calculate the number of cells needed to draw the Legend:
int seriesCount = plot.getSeriesRegistry().size();
for(XYSeriesRenderer renderer : plot.getRendererList()) {
Hashtable urf = renderer.getUniqueRegionFormatters();
sortedRegions.addAll(urf.entrySet());
}
seriesCount += sortedRegions.size();
// Create an iterator specially created to draw the number of cells we calculated:
Iterator it = tableModel.getIterator(widgetRect, seriesCount);
RectF cellRect;
// draw each series legend item:
for(SeriesAndFormatter sfPair : plot.getSeriesRegistry()) {
cellRect = it.next();
XYSeriesFormatter format = sfPair.getFormatter();
drawSeriesLegendCell(canvas, plot.getRenderer(sfPair.getFormatter().getRendererClass()),
format, cellRect, sfPair.getSeries().getTitle());
}
// draw each region legend item:
for(Map.Entry entry : sortedRegions) {
if(!it.hasNext()) {
break;
}
cellRect = it.next();
XYRegionFormatter formatter = entry.getKey();
drawRegionLegendCell(canvas, formatter, cellRect, entry.getValue());
}
}
public Paint getTextPaint() {
return textPaint;
}
public void setTextPaint(Paint textPaint) {
this.textPaint = textPaint;
}
public boolean isDrawIconBackgroundEnabled() {
return drawIconBackgroundEnabled;
}
public void setDrawIconBackgroundEnabled(boolean drawIconBackgroundEnabled) {
this.drawIconBackgroundEnabled = drawIconBackgroundEnabled;
}
public boolean isDrawIconBorderEnabled() {
return drawIconBorderEnabled;
}
public void setDrawIconBorderEnabled(boolean drawIconBorderEnabled) {
this.drawIconBorderEnabled = drawIconBorderEnabled;
}
public TableModel getTableModel() {
return tableModel;
}
public Size getIconSize() {
return iconSize;
}
/**
* Set the size of each legend's icon. Note that when using relative sizing,
* the size is calculated against the countaining cell's size, not the plot's size.
* @param iconSize
*/
public void setIconSize(Size iconSize) {
this.iconSize = iconSize;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYPlot.java 0000664 0000000 0000000 00000136346 12711435674 0027575 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PointF;
import android.util.AttributeSet;
import com.androidplot.Plot;
import com.androidplot.R;
import com.androidplot.ui.*;
import com.androidplot.ui.TextOrientationType;
import com.androidplot.ui.widget.TextLabelWidget;
import com.androidplot.util.AttrUtils;
import com.androidplot.util.PixelUtils;
import com.androidplot.util.SeriesUtils;
import java.text.Format;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* A View to graphically display x/y coordinates.
*/
public class XYPlot extends Plot {
private static final int DEFAULT_LEGEND_WIDGET_H_DP = 10;
private static final int DEFAULT_LEGEND_WIDGET_ICON_SIZE_DP = 7;
private static final int DEFAULT_GRAPH_WIDGET_H_DP = 18;
private static final int DEFAULT_GRAPH_WIDGET_W_DP = 10;
private static final int DEFAULT_DOMAIN_LABEL_WIDGET_H_DP = 10;
private static final int DEFAULT_DOMAIN_LABEL_WIDGET_W_DP = 80;
private static final int DEFAULT_RANGE_LABEL_WIDGET_H_DP = 50;
private static final int DEFAULT_RANGE_LABEL_WIDGET_W_DP = 10;
private static final int DEFAULT_LEGEND_WIDGET_Y_OFFSET_DP = 0;
private static final int DEFAULT_LEGEND_WIDGET_X_OFFSET_DP = 40;
private static final int DEFAULT_GRAPH_WIDGET_Y_OFFSET_DP = 0;
private static final int DEFAULT_GRAPH_WIDGET_X_OFFSET_DP = 0;
private static final int DEFAULT_DOMAIN_LABEL_WIDGET_Y_OFFSET_DP = 0;
private static final int DEFAULT_DOMAIN_LABEL_WIDGET_X_OFFSET_DP = 20;
private static final int DEFAULT_RANGE_LABEL_WIDGET_Y_OFFSET_DP = 0;
private static final int DEFAULT_RANGE_LABEL_WIDGET_X_OFFSET_DP = 0;
private static final int DEFAULT_GRAPH_WIDGET_TOP_MARGIN_DP = 3;
private static final int DEFAULT_GRAPH_WIDGET_BOTTOM_MARGIN_DP = 3;
private static final int DEFAULT_GRAPH_WIDGET_LEFT_MARGIN_DP = 3;
private static final int DEFAULT_GRAPH_WIDGET_RIGHT_MARGIN_DP = 3;
private static final int DEFAULT_PLOT_LEFT_MARGIN_DP = 2;
private static final int DEFAULT_PLOT_RIGHT_MARGIN_DP = 2;
private static final int DEFAULT_PLOT_BOTTOM_MARGIN_DP = 2;
private BoundaryMode domainOriginBoundaryMode;
private BoundaryMode rangeOriginBoundaryMode;
// widgets
private XYLegendWidget legendWidget;
private XYGraphWidget graphWidget;
private TextLabelWidget domainLabelWidget;
private TextLabelWidget rangeLabelWidget;
private XYStepModel domainStepModel;
private XYStepModel rangeStepModel;
private XYConstraints constraints = new XYConstraints();
// these are the final min/max used for dispplaying data
private Number calculatedMinX;
private Number calculatedMaxX;
private Number calculatedMinY;
private Number calculatedMaxY;
// previous calculated min/max vals.
// primarily used for GROW/SHRINK operations.
private Number prevMinX;
private Number prevMaxX;
private Number prevMinY;
private Number prevMaxY;
// uses set boundary min and max values
// should be null if not used.
private Number rangeTopMin = null;
private Number rangeTopMax = null;
private Number rangeBottomMin = null;
private Number rangeBottomMax = null;
private Number domainLeftMin = null;
private Number domainLeftMax = null;
private Number domainRightMin = null;
private Number domainRightMax = null;
private Number userDomainOrigin;
private Number userRangeOrigin;
private Number calculatedDomainOrigin;
private Number calculatedRangeOrigin;
@SuppressWarnings("FieldCanBeLocal")
private Number domainOriginExtent = null;
@SuppressWarnings("FieldCanBeLocal")
private Number rangeOriginExtent = null;
private boolean drawDomainOriginEnabled = true;
private boolean drawRangeOriginEnabled = true;
private ArrayList yValueMarkers;
private ArrayList xValueMarkers;
private RectRegion defaultBounds;
public XYPlot(Context context, String title) {
super(context, title);
}
public XYPlot(Context context, String title, RenderMode mode) {
super(context, title, mode);
}
public XYPlot(Context context, AttributeSet attributes) {
super(context, attributes);
}
public XYPlot(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
@Override
protected void onPreInit() {
legendWidget = new XYLegendWidget(
getLayoutManager(),
this,
new Size(
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_H_DP),
SizeLayoutType.ABSOLUTE, 0.5f, SizeLayoutType.RELATIVE),
new DynamicTableModel(0, 1),
new Size(
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_ICON_SIZE_DP),
SizeLayoutType.ABSOLUTE,
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_ICON_SIZE_DP),
SizeLayoutType.ABSOLUTE));
graphWidget = new XYGraphWidget(
getLayoutManager(),
this,
new Size(
PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_H_DP),
SizeLayoutType.FILL,
PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_W_DP),
SizeLayoutType.FILL));
Paint backgroundPaint = new Paint();
backgroundPaint.setColor(Color.DKGRAY);
backgroundPaint.setStyle(Paint.Style.FILL);
graphWidget.setBackgroundPaint(backgroundPaint);
domainLabelWidget = new TextLabelWidget(
getLayoutManager(),
new Size(
PixelUtils.dpToPix(DEFAULT_DOMAIN_LABEL_WIDGET_H_DP),
SizeLayoutType.ABSOLUTE,
PixelUtils.dpToPix(DEFAULT_DOMAIN_LABEL_WIDGET_W_DP),
SizeLayoutType.ABSOLUTE),
TextOrientationType.HORIZONTAL);
rangeLabelWidget = new TextLabelWidget(
getLayoutManager(),
new Size(
PixelUtils.dpToPix(DEFAULT_RANGE_LABEL_WIDGET_H_DP),
SizeLayoutType.ABSOLUTE,
PixelUtils.dpToPix(DEFAULT_RANGE_LABEL_WIDGET_W_DP),
SizeLayoutType.ABSOLUTE),
TextOrientationType.VERTICAL_ASCENDING);
legendWidget.position(
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_X_OFFSET_DP),
XLayoutStyle.ABSOLUTE_FROM_RIGHT,
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_Y_OFFSET_DP),
YLayoutStyle.ABSOLUTE_FROM_BOTTOM,
AnchorPosition.RIGHT_BOTTOM);
graphWidget.position(
PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_X_OFFSET_DP),
XLayoutStyle.ABSOLUTE_FROM_RIGHT,
PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_Y_OFFSET_DP),
YLayoutStyle.ABSOLUTE_FROM_CENTER,
AnchorPosition.RIGHT_MIDDLE);
domainLabelWidget.position(
PixelUtils.dpToPix(DEFAULT_DOMAIN_LABEL_WIDGET_X_OFFSET_DP),
XLayoutStyle.ABSOLUTE_FROM_LEFT,
PixelUtils.dpToPix(DEFAULT_DOMAIN_LABEL_WIDGET_Y_OFFSET_DP),
YLayoutStyle.ABSOLUTE_FROM_BOTTOM,
AnchorPosition.LEFT_BOTTOM);
rangeLabelWidget.position(
PixelUtils.dpToPix(DEFAULT_RANGE_LABEL_WIDGET_X_OFFSET_DP),
XLayoutStyle.ABSOLUTE_FROM_LEFT,
PixelUtils.dpToPix(DEFAULT_RANGE_LABEL_WIDGET_Y_OFFSET_DP),
YLayoutStyle.ABSOLUTE_FROM_CENTER,
AnchorPosition.LEFT_MIDDLE);
getLayoutManager().moveToTop(getTitleWidget());
getLayoutManager().moveToTop(getLegendWidget());
graphWidget.setMarginTop(PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_TOP_MARGIN_DP));
graphWidget.setMarginBottom(PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_BOTTOM_MARGIN_DP));
graphWidget.setMarginLeft(PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_LEFT_MARGIN_DP));
graphWidget.setMarginRight(PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_RIGHT_MARGIN_DP));
getDomainLabelWidget().pack();
getRangeLabelWidget().pack();
setPlotMarginLeft(PixelUtils.dpToPix(DEFAULT_PLOT_LEFT_MARGIN_DP));
setPlotMarginRight(PixelUtils.dpToPix(DEFAULT_PLOT_RIGHT_MARGIN_DP));
setPlotMarginBottom(PixelUtils.dpToPix(DEFAULT_PLOT_BOTTOM_MARGIN_DP));
xValueMarkers = new ArrayList<>();
yValueMarkers = new ArrayList<>();
setDefaultBounds(new RectRegion(-1, 1, -1, 1));
// display some generic series data in editors that support it:
if(isInEditMode()) {
addSeries(new SimpleXYSeries(Arrays.asList(1, 2, 3, 3, 4), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Red"),
new LineAndPointFormatter(Color.RED, null, null, null));
addSeries(new SimpleXYSeries(Arrays.asList(2, 1, 4, 2, 5), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Green"),
new LineAndPointFormatter(Color.GREEN, null, null, null));
addSeries(new SimpleXYSeries(Arrays.asList(3, 3, 2, 3, 3), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Blue"),
new LineAndPointFormatter(Color.BLUE, null, null, null));
}
domainStepModel = new XYStepModel(XYStepMode.SUBDIVIDE, 10);
rangeStepModel = new XYStepModel(XYStepMode.SUBDIVIDE, 10);
}
@Override
protected void processAttrs(TypedArray attrs) {
// graph size & position
AttrUtils.configureWidget(attrs, getGraphWidget(),
R.styleable.xy_XYPlot_graphHeightSizeLayoutType, R.styleable.xy_XYPlot_domainLabelHeight,
R.styleable.xy_XYPlot_graphWidthSizeLayoutType, R.styleable.xy_XYPlot_graphWidth,
R.styleable.xy_XYPlot_graphLayoutStyleX, R.styleable.xy_XYPlot_graphPositionX,
R.styleable.xy_XYPlot_graphLayoutStyleY, R.styleable.xy_XYPlot_graphPositionY,
R.styleable.xy_XYPlot_graphAnchorPosition, R.styleable.xy_XYPlot_graphVisible);
String domainLabelAttr = attrs.getString(R.styleable.xy_XYPlot_domainLabel);
if(domainLabelAttr != null) {
setDomainLabel(domainLabelAttr);
}
String rangeLabelAttr = attrs.getString(R.styleable.xy_XYPlot_rangeLabel);
if(rangeLabelAttr != null) {
setRangeLabel(rangeLabelAttr);
}
AttrUtils.configureStep(attrs, getDomainStepModel(),
R.styleable.xy_XYPlot_domainStepMode, R.styleable.xy_XYPlot_domainStep);
AttrUtils.configureStep(attrs, getRangeStepModel(),
R.styleable.xy_XYPlot_rangeStepMode, R.styleable.xy_XYPlot_rangeStep);
// domainLabel size & position
AttrUtils.configureWidget(attrs, getDomainLabelWidget(),
R.styleable.xy_XYPlot_domainLabelHeightSizeLayoutType, R.styleable.xy_XYPlot_domainLabelHeight,
R.styleable.xy_XYPlot_domainLabelWidthSizeLayoutType, R.styleable.xy_XYPlot_domainLabelWidth,
R.styleable.xy_XYPlot_domainLabelLayoutStyleX, R.styleable.xy_XYPlot_domainLabelPositionX,
R.styleable.xy_XYPlot_domainLabelLayoutStyleY, R.styleable.xy_XYPlot_domainLabelPositionY,
R.styleable.xy_XYPlot_domainLabelAnchorPosition, R.styleable.xy_XYPlot_domainLabelVisible);
// rangeLabel size & position
AttrUtils.configureWidget(attrs, getRangeLabelWidget(),
R.styleable.xy_XYPlot_rangeLabelHeightSizeLayoutType, R.styleable.xy_XYPlot_rangeLabelHeight,
R.styleable.xy_XYPlot_rangeLabelWidthSizeLayoutType, R.styleable.xy_XYPlot_rangeLabelWidth,
R.styleable.xy_XYPlot_rangeLabelLayoutStyleX, R.styleable.xy_XYPlot_rangeLabelPositionX,
R.styleable.xy_XYPlot_rangeLabelLayoutStyleY, R.styleable.xy_XYPlot_rangeLabelPositionY,
R.styleable.xy_XYPlot_rangeLabelAnchorPosition, R.styleable.xy_XYPlot_rangeLabelVisible);
// domainLabelPaint
AttrUtils.configureTextPaint(attrs, getDomainLabelWidget().getLabelPaint(),
R.styleable.xy_XYPlot_domainLabelTextColor, R.styleable.xy_XYPlot_domainLabelTextSize);
// rangeLabelPaint
AttrUtils.configureTextPaint(attrs, getRangeLabelWidget().getLabelPaint(),
R.styleable.xy_XYPlot_rangeLabelTextColor, R.styleable.xy_XYPlot_rangeLabelTextSize);
// graphWidget
AttrUtils.configureBoxModelable(attrs, getGraphWidget(),
R.styleable.xy_XYPlot_graphMarginTop, R.styleable.xy_XYPlot_graphMarginBottom,
R.styleable.xy_XYPlot_graphMarginLeft, R.styleable.xy_XYPlot_graphMarginRight,
R.styleable.xy_XYPlot_graphPaddingTop, R.styleable.xy_XYPlot_graphPaddingBottom,
R.styleable.xy_XYPlot_graphPaddingLeft, R.styleable.xy_XYPlot_graphPaddingRight);
// gridRect
AttrUtils.configureBoxModelable(attrs, getGraphWidget().getGridBox(),
R.styleable.xy_XYPlot_gridMarginTop, R.styleable.xy_XYPlot_gridMarginBottom,
R.styleable.xy_XYPlot_gridMarginLeft, R.styleable.xy_XYPlot_gridMarginRight,
R.styleable.xy_XYPlot_gridPaddingTop, R.styleable.xy_XYPlot_gridPaddingBottom,
R.styleable.xy_XYPlot_gridPaddingLeft, R.styleable.xy_XYPlot_gridPaddingRight);
// domainTickLabelPaint
AttrUtils.configureTextPaint(attrs, getGraphWidget().getDomainTickLabelPaint(),
R.styleable.xy_XYPlot_domainTickLabelTextColor,
R.styleable.xy_XYPlot_domainTickLabelTextSize);
// rangeTickLabelPaint
AttrUtils.configureTextPaint(attrs, getGraphWidget().getRangeTickLabelPaint(),
R.styleable.xy_XYPlot_rangeTickLabelTextColor,
R.styleable.xy_XYPlot_rangeTickLabelTextSize);
// domainOriginTickLabelPaint
AttrUtils.configureTextPaint(attrs, getGraphWidget().getDomainOriginTickLabelPaint(),
R.styleable.xy_XYPlot_domainOriginTickLabelTextColor,
R.styleable.xy_XYPlot_domainOriginTickLabelTextSize);
// rangeOriginTickLabelPaint
AttrUtils.configureTextPaint(attrs, getGraphWidget().getRangeOriginTickLabelPaint(),
R.styleable.xy_XYPlot_rangeOriginTickLabelTextColor,
R.styleable.xy_XYPlot_rangeOriginTickLabelTextSize);
// legendWTextPaint
AttrUtils.configureTextPaint(attrs, getLegendWidget().getTextPaint(),
R.styleable.xy_XYPlot_legendTextColor,
R.styleable.xy_XYPlot_legendTextSize);
// legendIconSize
AttrUtils.configureSize(attrs, getLegendWidget().getIconSize(),
R.styleable.xy_XYPlot_legendIconHeightSizeLayoutType, R.styleable.xy_XYPlot_legendIconHeight,
R.styleable.xy_XYPlot_legendIconWidthSizeLayoutType, R.styleable.xy_XYPlot_legendIconWidth);
// legend size & position
AttrUtils.configureWidget(attrs, getLegendWidget(),
R.styleable.xy_XYPlot_legendHeightSizeLayoutType, R.styleable.xy_XYPlot_legendHeight,
R.styleable.xy_XYPlot_legendWidthSizeLayoutType, R.styleable.xy_XYPlot_legendWidth,
R.styleable.xy_XYPlot_legendLayoutStyleX, R.styleable.xy_XYPlot_legendPositionX,
R.styleable.xy_XYPlot_legendLayoutStyleY, R.styleable.xy_XYPlot_legendPositionY,
R.styleable.xy_XYPlot_legendAnchorPosition, R.styleable.xy_XYPlot_legendVisible);
AttrUtils.configureLinePaint(attrs, getGraphWidget().getDomainGridLinePaint(),
R.styleable.xy_XYPlot_graphDomainLineColor, R.styleable.xy_XYPlot_graphDomainLineThickness);
AttrUtils.configureLinePaint(attrs, getGraphWidget().getRangeGridLinePaint(),
R.styleable.xy_XYPlot_graphRangeLineColor, R.styleable.xy_XYPlot_graphRangeLineThickness);
getGraphWidget().getBackgroundPaint().setColor(attrs.getColor(
R.styleable.xy_XYPlot_graphBackgroundColor, getGraphWidget().getBackgroundPaint().getColor()));
getGraphWidget().getGridBackgroundPaint().setColor(attrs.getColor(
R.styleable.xy_XYPlot_gridBackgroundColor, getGraphWidget().getGridBackgroundPaint().getColor()));
}
public void setGridPadding(float left, float top, float right, float bottom) {
getGraphWidget().getGridBox().setPadding(left, top, right, bottom);
}
@Override
protected void notifyListenersBeforeDraw(Canvas canvas) {
super.notifyListenersBeforeDraw(canvas);
// this call must be AFTER the notify so that if the listener
// is a synchronized series, it has the opportunity to
// place a read lock on it's data.
calculateMinMaxVals();
}
/**
* Checks whether the point is within the plot's graph area.
*
* @param x
* @param y
* @return
*/
public boolean containsPoint(float x, float y) {
if (getGraphWidget().getGridDimensions().marginatedRect != null) {
return getGraphWidget().getGridDimensions().marginatedRect.contains(x, y);
}
return false;
}
/** `
* Convenience method - wraps containsPoint(PointF).
*
* @param point
* @return
*/
public boolean containsPoint(PointF point) {
return containsPoint(point.x, point.y);
}
public void setCursorPosition(PointF point) {
getGraphWidget().setCursorPosition(point);
}
public void setCursorPosition(float x, float y) {
getGraphWidget().setCursorPosition(x, y);
}
public Number getYVal(PointF point) {
return getGraphWidget().getYVal(point);
}
public Number getXVal(PointF point) {
return getGraphWidget().getXVal(point);
}
public void calculateMinMaxVals() {
prevMinX = calculatedMinX;
prevMaxX = calculatedMaxX;
prevMinY = calculatedMinY;
prevMaxY = calculatedMaxY;
calculatedMinX = constraints.getMinX();
calculatedMaxX = constraints.getMaxX();
calculatedMinY = constraints.getMinY();
calculatedMaxY = constraints.getMaxY();
// only calculate if we must:
if(calculatedMinX == null || calculatedMaxX == null || calculatedMinY == null || calculatedMaxY == null) {
XYBounds bounds = SeriesUtils.minMax(constraints, getSeriesRegistry().getSeriesList());
if(calculatedMinX == null) calculatedMinX = bounds.getMinX();
if(calculatedMaxX == null) calculatedMaxX = bounds.getMaxX();
if(calculatedMinY == null) calculatedMinY = bounds.getMinY();
if(calculatedMaxY == null) calculatedMaxY = bounds.getMaxY();
}
// at this point we now know what points are going to be visible on our
// plot, but we still need to make corrections based on modes being used:
// (grow, shrink etc.)
switch (constraints.getDomainFramingModel()) {
case ORIGIN:
updateDomainMinMaxForOriginModel();
break;
case EDGE:
calculatedMaxX = getCalculatedUpperBoundary(
constraints.getDomainUpperBoundaryMode(), prevMaxX, calculatedMaxX);
calculatedMinX = getCalculatedLowerBoundary(
constraints.getDomainLowerBoundaryMode(), prevMinX, calculatedMinX);
calculatedMinX = applyUserMinMax(calculatedMinX, domainLeftMin,
domainLeftMax);
calculatedMaxX = applyUserMinMax(calculatedMaxX,
domainRightMin, domainRightMax);
break;
default:
throw new UnsupportedOperationException(
"Domain Framing Model not yet supported: " + constraints.getDomainFramingModel());
}
switch (constraints.getRangeFramingModel()) {
case ORIGIN:
updateRangeMinMaxForOriginModel();
break;
case EDGE:
if (getSeriesRegistry().size() > 0) {
calculatedMaxY = getCalculatedUpperBoundary(
constraints.getRangeUpperBoundaryMode(), prevMaxY, calculatedMaxY);
calculatedMinY = getCalculatedLowerBoundary(
constraints.getRangeLowerBoundaryMode(), prevMinY, calculatedMinY);
calculatedMinY = applyUserMinMax(calculatedMinY, rangeBottomMin, rangeBottomMax);
calculatedMaxY = applyUserMinMax(calculatedMaxY, rangeTopMin, rangeTopMax);
}
break;
default:
throw new UnsupportedOperationException(
"Range Framing Model not yet supported: " + constraints.getRangeFramingModel());
}
calculatedDomainOrigin = userDomainOrigin != null ?
userDomainOrigin : getCalculatedMinX();
calculatedRangeOrigin = this.userRangeOrigin != null ?
userRangeOrigin : getCalculatedMinY();
}
protected Number getCalculatedUpperBoundary(BoundaryMode mode, Number previousMax, Number calculatedMax) {
switch (mode) {
case FIXED:
break;
case AUTO:
break;
case GROW:
if (!(previousMax == null || calculatedMax.doubleValue() > previousMax.doubleValue())) {
calculatedMax = previousMax;
}
break;
case SHRINK:
if (!(previousMax == null || calculatedMax.doubleValue() < previousMax.doubleValue())) {
calculatedMax = previousMax;
}
break;
default:
throw new UnsupportedOperationException("BoundaryMode not supported: " + mode);
}
return calculatedMax;
}
protected Number getCalculatedLowerBoundary(BoundaryMode mode, Number previousMin, Number calculatedMin) {
switch (mode) {
case FIXED:
break;
case AUTO:
break;
case GROW:
if (!(previousMin == null || calculatedMin.doubleValue() < previousMin.doubleValue())) {
return previousMin;
}
break;
case SHRINK:
if (!(previousMin == null || calculatedMin.doubleValue() > previousMin.doubleValue())) {
return previousMin;
}
break;
default:
throw new UnsupportedOperationException(
"BoundaryMode not supported: " + mode);
}
return calculatedMin;
}
/**
* Apply user supplied min and max to the calculated boundary value.
*
* @param value
* @param min
* @param max
*/
private Number applyUserMinMax(Number value, Number min, Number max) {
value = (((min == null) || (value == null) || (value.doubleValue() > min.doubleValue()))
? value
: min);
value = (((max == null) || (value == null) || (value.doubleValue() < max.doubleValue()))
? value
: max);
return value;
}
/**
* Centers the domain axis on origin.
*
* @param origin
*/
public void centerOnDomainOrigin(Number origin) {
centerOnDomainOrigin(origin, null, BoundaryMode.AUTO);
}
/**
* Centers the domain on origin, calculating the upper and lower boundaries of the axis
* using mode and extent.
*
* @param origin
* @param extent
* @param mode
*/
public void centerOnDomainOrigin(Number origin, Number extent, BoundaryMode mode) {
if (origin == null) {
throw new NullPointerException("Origin param cannot be null.");
}
constraints.setDomainFramingModel(XYFramingModel.ORIGIN);
setUserDomainOrigin(origin);
domainOriginExtent = extent;
domainOriginBoundaryMode = mode;
Number[] minMax = getOriginMinMax(domainOriginBoundaryMode, userDomainOrigin, domainOriginExtent);
constraints.setMinX(minMax[0]);
constraints.setMaxX(minMax[1]);
}
/**
* Centers the range axis on origin.
*
* @param origin
*/
public void centerOnRangeOrigin(Number origin) {
centerOnRangeOrigin(origin, null, BoundaryMode.AUTO);
}
/**
* Centers the domain on origin, calculating the upper and lower boundaries of the axis
* using mode and extent.
*
* @param origin
* @param extent
* @param mode
*/
@SuppressWarnings("SameParameterValue")
public void centerOnRangeOrigin(Number origin, Number extent, BoundaryMode mode) {
if (origin == null) {
throw new NullPointerException("Origin param cannot be null.");
}
constraints.setRangeFramingModel(XYFramingModel.ORIGIN);
setUserRangeOrigin(origin);
rangeOriginExtent = extent;
rangeOriginBoundaryMode = mode;
Number[] minMax = getOriginMinMax(rangeOriginBoundaryMode, userRangeOrigin, rangeOriginExtent);
constraints.setMinY(minMax[0]);
constraints.setMaxY(minMax[1]);
}
/**
*
* @param mode
* @param origin
* @param extent
* @return result[0] is min, result[1] is max
*/
protected Number[] getOriginMinMax(BoundaryMode mode, Number origin, Number extent) {
if (mode == BoundaryMode.FIXED) {
double o = origin.doubleValue();
double e = extent.doubleValue();
return new Number[] {o - e, o + e};
}
return new Number[] {null, null};
}
/**
* Returns the distance between x and y.
* Result is never a negative number.
*
* @param x
* @param y
* @return
*/
private double distance(double x, double y) {
if (x > y) {
return x - y;
} else {
return y - x;
}
}
public void updateDomainMinMaxForOriginModel() {
double origin = userDomainOrigin.doubleValue();
double maxXDelta = distance(calculatedMaxX.doubleValue(), origin);
double minXDelta = distance(calculatedMinX.doubleValue(), origin);
double delta = maxXDelta > minXDelta ? maxXDelta : minXDelta;
double dlb = origin - delta;
double dub = origin + delta;
switch (domainOriginBoundaryMode) {
case AUTO:
calculatedMinX = dlb;
calculatedMaxX = dub;
break;
// if fixed, then the value already exists within "user" vals.
case FIXED:
break;
case GROW: {
if (prevMinX == null || dlb < prevMinX.doubleValue()) {
calculatedMinX = dlb;
} else {
calculatedMinX = prevMinX;
}
if (prevMaxX == null || dub > prevMaxX.doubleValue()) {
calculatedMaxX = dub;
} else {
calculatedMaxX = prevMaxX;
}
}
break;
case SHRINK:
if (prevMinX == null || dlb > prevMinX.doubleValue()) {
calculatedMinX = dlb;
} else {
calculatedMinX = prevMinX;
}
if (prevMaxX == null || dub < prevMaxX.doubleValue()) {
calculatedMaxX = dub;
} else {
calculatedMaxX = prevMaxX;
}
break;
default:
throw new UnsupportedOperationException("Domain Origin Boundary Mode not yet supported: " + domainOriginBoundaryMode);
}
}
public void updateRangeMinMaxForOriginModel() {
switch (rangeOriginBoundaryMode) {
case AUTO:
double origin = userRangeOrigin.doubleValue();
double maxYDelta = distance(calculatedMaxY.doubleValue(), origin);
double minYDelta = distance(calculatedMinY.doubleValue(), origin);
if (maxYDelta > minYDelta) {
calculatedMinY = origin - maxYDelta;
calculatedMaxY = origin + maxYDelta;
} else {
calculatedMinY = origin - minYDelta;
calculatedMaxY = origin + minYDelta;
}
break;
case FIXED:
case GROW:
case SHRINK:
default:
throw new UnsupportedOperationException(
"Range Origin Boundary Mode not yet supported: " + rangeOriginBoundaryMode);
}
}
/**
* Convenience method - wraps XYGraphWidget.getTicksPerRangeLabel().
* Equivalent to getGraphWidget().getTicksPerRangeLabel().
*
* @return
*/
public int getTicksPerRangeLabel() {
return graphWidget.getTicksPerRangeLabel();
}
/**
* Convenience method - wraps XYGraphWidget.setTicksPerRangeLabel().
* Equivalent to getGraphWidget().setTicksPerRangeLabel().
*
* @param ticksPerRangeLabel
*/
public void setTicksPerRangeLabel(int ticksPerRangeLabel) {
graphWidget.setTicksPerRangeLabel(ticksPerRangeLabel);
}
/**
* Convenience method - wraps XYGraphWidget.getTicksPerDomainLabel().
* Equivalent to getGraphWidget().getTicksPerDomainLabel().
*
* @return
*/
public int getTicksPerDomainLabel() {
return graphWidget.getTicksPerDomainLabel();
}
/**
* Convenience method - wraps XYGraphWidget.setTicksPerDomainLabel().
* Equivalent to getGraphWidget().setTicksPerDomainLabel().
*
* @param ticksPerDomainLabel
*/
public void setTicksPerDomainLabel(int ticksPerDomainLabel) {
graphWidget.setTicksPerDomainLabel(ticksPerDomainLabel);
}
public XYStepMode getDomainStepMode() {
return domainStepModel.getMode();
}
public void setDomainStepMode(XYStepMode domainStepMode) {
domainStepModel.setMode(domainStepMode);
}
public double getDomainStepValue() {
return domainStepModel.getValue();
}
public void setDomainStepValue(double domainStepValue) {
domainStepModel.setValue(domainStepValue);
}
public void setDomainStep(XYStepMode mode, double value) {
setDomainStepMode(mode);
setDomainStepValue(value);
}
public XYStepMode getRangeStepMode() {
return rangeStepModel.getMode();
}
public void setRangeStepMode(XYStepMode rangeStepMode) {
rangeStepModel.setMode(rangeStepMode);
}
public double getRangeStepValue() {
return rangeStepModel.getValue();
}
public void setRangeStepValue(double rangeStepValue) {
rangeStepModel.setValue(rangeStepValue);
}
public void setRangeStep(XYStepMode mode, double value) {
setRangeStepMode(mode);
setRangeStepValue(value);
}
public String getDomainLabel() {
return getDomainLabelWidget().getText();
}
public void setDomainLabel(String domainLabel) {
getDomainLabelWidget().setText(domainLabel);
}
public String getRangeLabel() {
return getRangeLabelWidget().getText();
}
public void setRangeLabel(String rangeLabel) {
getRangeLabelWidget().setText(rangeLabel);
}
public XYLegendWidget getLegendWidget() {
return legendWidget;
}
public void setLegendWidget(XYLegendWidget legendWidget) {
this.legendWidget = legendWidget;
}
public XYGraphWidget getGraphWidget() {
return graphWidget;
}
public void setGraphWidget(XYGraphWidget graphWidget) {
this.graphWidget = graphWidget;
}
public TextLabelWidget getDomainLabelWidget() {
return domainLabelWidget;
}
public void setDomainLabelWidget(TextLabelWidget domainLabelWidget) {
this.domainLabelWidget = domainLabelWidget;
}
public TextLabelWidget getRangeLabelWidget() {
return rangeLabelWidget;
}
public void setRangeLabelWidget(TextLabelWidget rangeLabelWidget) {
this.rangeLabelWidget = rangeLabelWidget;
}
/**
* Convenience method - wraps XYGraphWidget.getRangeValueFormat().
*
* @return
*/
public Format getRangeValueFormat() {
return graphWidget.getRangeValueFormat();
}
/**
* Convenience method - wraps XYGraphWidget.setRangeValueFormat().
*
* @param rangeValueFormat
*/
public void setRangeValueFormat(Format rangeValueFormat) {
graphWidget.setRangeValueFormat(rangeValueFormat);
}
/**
* Convenience method - wraps XYGraphWidget.getDomainValueFormat().
*
* @return
*/
public Format getDomainValueFormat() {
return graphWidget.getDomainValueFormat();
}
/**
* Convenience method - wraps XYGraphWidget.setDomainValueFormat().
*
* @param domainValueFormat
*/
public void setDomainValueFormat(Format domainValueFormat) {
graphWidget.setDomainValueFormat(domainValueFormat);
}
/**
* Setup the boundary mode, boundary values only applicable in FIXED mode.
*
* @param lowerBoundary
* @param upperBoundary
* @param mode
*/
public synchronized void setDomainBoundaries(Number lowerBoundary, Number upperBoundary, BoundaryMode mode) {
setDomainBoundaries(lowerBoundary, mode, upperBoundary, mode);
}
/**
* Setup the boundary mode, boundary values only applicable in FIXED mode.
*
* @param lowerBoundary
* @param lowerBoundaryMode
* @param upperBoundary
* @param upperBoundaryMode
*/
public synchronized void setDomainBoundaries(Number lowerBoundary, BoundaryMode lowerBoundaryMode,
Number upperBoundary, BoundaryMode upperBoundaryMode) {
setDomainLowerBoundary(lowerBoundary, lowerBoundaryMode);
setDomainUpperBoundary(upperBoundary, upperBoundaryMode);
}
/**
* Setup the boundary mode, boundary values only applicable in FIXED mode.
*
* @param lowerBoundary
* @param upperBoundary
* @param mode
*/
public synchronized void setRangeBoundaries(Number lowerBoundary, Number upperBoundary, BoundaryMode mode) {
setRangeBoundaries(lowerBoundary, mode, upperBoundary, mode);
}
/**
* Setup the boundary mode, boundary values only applicable in FIXED mode.
*
* @param lowerBoundary
* @param lowerBoundaryMode
* @param upperBoundary
* @param upperBoundaryMode
*/
public synchronized void setRangeBoundaries(Number lowerBoundary, BoundaryMode lowerBoundaryMode,
Number upperBoundary, BoundaryMode upperBoundaryMode) {
setRangeLowerBoundary(lowerBoundary, lowerBoundaryMode);
setRangeUpperBoundary(upperBoundary, upperBoundaryMode);
}
protected synchronized void setDomainUpperBoundaryMode(BoundaryMode mode) {
constraints.setDomainUpperBoundaryMode(mode);
}
protected synchronized void setUserMaxX(Number maxX) {
constraints.setMaxX(maxX);
}
/**
* Setup the boundary mode, boundary values only applicable in FIXED mode.
*
* @param boundary
* @param mode
*/
public synchronized void setDomainUpperBoundary(Number boundary, BoundaryMode mode) {
setUserMaxX((mode == BoundaryMode.FIXED) ? boundary : null);
setDomainUpperBoundaryMode(mode);
setDomainFramingModel(XYFramingModel.EDGE);
}
protected synchronized void setDomainLowerBoundaryMode(BoundaryMode mode) {
constraints.setDomainLowerBoundaryMode(mode);
}
protected synchronized void setUserMinX(Number minX) {
constraints.setMinX(minX);
}
/**
* Setup the boundary mode, boundary values only applicable in FIXED mode.
*
* @param boundary
* @param mode
*/
public synchronized void setDomainLowerBoundary(Number boundary, BoundaryMode mode) {
setUserMinX((mode == BoundaryMode.FIXED) ? boundary : null);
setDomainLowerBoundaryMode(mode);
setDomainFramingModel(XYFramingModel.EDGE);
}
protected synchronized void setRangeUpperBoundaryMode(BoundaryMode mode) {
constraints.setRangeUpperBoundaryMode(mode);
}
protected synchronized void setUserMaxY(Number maxY) {
constraints.setMaxY(maxY);
}
/**
* Setup the boundary mode, boundary values only applicable in FIXED mode.
*
* @param boundary
* @param mode
*/
public synchronized void setRangeUpperBoundary(Number boundary, BoundaryMode mode) {
setUserMaxY((mode == BoundaryMode.FIXED) ? boundary : null);
setRangeUpperBoundaryMode(mode);
setRangeFramingModel(XYFramingModel.EDGE);
}
protected synchronized void setRangeLowerBoundaryMode(BoundaryMode mode) {
constraints.setRangeLowerBoundaryMode(mode);
}
protected synchronized void setUserMinY(Number minY) {
constraints.setMinY(minY);
}
/**
* Setup the boundary mode, boundary values only applicable in FIXED mode.
*
* @param boundary
* @param mode
*/
public synchronized void setRangeLowerBoundary(Number boundary, BoundaryMode mode) {
setUserMinY((mode == BoundaryMode.FIXED) ? boundary : null);
setRangeLowerBoundaryMode(mode);
setRangeFramingModel(XYFramingModel.EDGE);
}
public Number getDomainOrigin() {
return calculatedDomainOrigin;
}
public Number getRangeOrigin() {
return calculatedRangeOrigin;
}
public synchronized void setUserDomainOrigin(Number origin) {
if (origin == null) {
throw new NullPointerException("Origin value cannot be null.");
}
this.userDomainOrigin = origin;
}
public synchronized void setUserRangeOrigin(Number origin) {
if (origin == null) {
throw new NullPointerException("Origin value cannot be null.");
}
this.userRangeOrigin = origin;
}
@SuppressWarnings("SameParameterValue")
protected void setDomainFramingModel(XYFramingModel model) {
constraints.setDomainFramingModel(model);
}
@SuppressWarnings("SameParameterValue")
protected void setRangeFramingModel(XYFramingModel model) {
constraints.setRangeFramingModel(model);
}
/**
* CalculatedMinX value after the the framing model has been applied.
*
* @return
*/
public Number getCalculatedMinX() {
return calculatedMinX != null ? calculatedMinX : getDefaultBounds().getMinX();
}
/**
* CalculatedMaxX value after the the framing model has been applied.
*
* @return
*/
public Number getCalculatedMaxX() {
return calculatedMaxX != null ? calculatedMaxX : getDefaultBounds().getMaxX();
}
/**
* CalculatedMinY value after the the framing model has been applied.
*
* @return
*/
public Number getCalculatedMinY() {
return calculatedMinY != null ? calculatedMinY : getDefaultBounds().getMinY();
}
/**
* CalculatedMaxY value after the the framing model has been applied.
*
* @return
*/
public Number getCalculatedMaxY() {
return calculatedMaxY != null ? calculatedMaxY : getDefaultBounds().getMaxY();
}
public boolean isDrawDomainOriginEnabled() {
return drawDomainOriginEnabled;
}
public void setDrawDomainOriginEnabled(boolean drawDomainOriginEnabled) {
this.drawDomainOriginEnabled = drawDomainOriginEnabled;
}
public boolean isDrawRangeOriginEnabled() {
return drawRangeOriginEnabled;
}
public void setDrawRangeOriginEnabled(boolean drawRangeOriginEnabled) {
this.drawRangeOriginEnabled = drawRangeOriginEnabled;
}
/**
* Appends the specified marker to the end of plot's yValueMarkers list.
*
* @param marker The YValueMarker to be added.
* @return true if the object was successfully added, false otherwise.
*/
public boolean addMarker(YValueMarker marker) {
if (yValueMarkers.contains(marker)) {
return false;
} else {
return yValueMarkers.add(marker);
}
}
/**
* Removes the specified marker from the plot.
*
* @param marker
* @return The YValueMarker removed if successfull, null otherwise.
*/
public YValueMarker removeMarker(YValueMarker marker) {
int markerIndex = yValueMarkers.indexOf(marker);
if (markerIndex == -1) {
return null;
} else {
return yValueMarkers.remove(markerIndex);
}
}
/**
* Convenience method - combines removeYMarkers() and removeXMarkers().
*
* @return
*/
public int removeMarkers() {
int removed = removeXMarkers();
removed += removeYMarkers();
return removed;
}
/**
* Removes all YValueMarker instances from the plot.
*
* @return
*/
public int removeYMarkers() {
int numMarkersRemoved = yValueMarkers.size();
yValueMarkers.clear();
return numMarkersRemoved;
}
/**
* Appends the specified marker to the end of plot's xValueMarkers list.
*
* @param marker The XValueMarker to be added.
* @return true if the object was successfully added, false otherwise.
*/
public boolean addMarker(XValueMarker marker) {
return !xValueMarkers.contains(marker) && xValueMarkers.add(marker);
}
/**
* Removes the specified marker from the plot.
*
* @param marker
* @return The XValueMarker removed if successfull, null otherwise.
*/
public XValueMarker removeMarker(XValueMarker marker) {
int markerIndex = xValueMarkers.indexOf(marker);
if (markerIndex == -1) {
return null;
} else {
return xValueMarkers.remove(markerIndex);
}
}
/**
* Removes all XValueMarker instances from the plot.
*
* @return
*/
public int removeXMarkers() {
int numMarkersRemoved = xValueMarkers.size();
xValueMarkers.clear();
return numMarkersRemoved;
}
protected List getYValueMarkers() {
return yValueMarkers;
}
protected List getXValueMarkers() {
return xValueMarkers;
}
public RectRegion getDefaultBounds() {
return defaultBounds;
}
public void setDefaultBounds(RectRegion defaultBounds) {
this.defaultBounds = defaultBounds;
}
/**
* @return the rangeTopMin
*/
public Number getRangeTopMin() {
return rangeTopMin;
}
/**
* @param rangeTopMin the rangeTopMin to set
*/
public synchronized void setRangeTopMin(Number rangeTopMin) {
this.rangeTopMin = rangeTopMin;
}
/**
* @return the rangeTopMax
*/
public Number getRangeTopMax() {
return rangeTopMax;
}
/**
* @param rangeTopMax the rangeTopMax to set
*/
public synchronized void setRangeTopMax(Number rangeTopMax) {
this.rangeTopMax = rangeTopMax;
}
/**
* @return the rangeBottomMin
*/
public Number getRangeBottomMin() {
return rangeBottomMin;
}
/**
* @param rangeBottomMin the rangeBottomMin to set
*/
public synchronized void setRangeBottomMin(Number rangeBottomMin) {
this.rangeBottomMin = rangeBottomMin;
}
/**
* @return the rangeBottomMax
*/
public Number getRangeBottomMax() {
return rangeBottomMax;
}
/**
* @param rangeBottomMax the rangeBottomMax to set
*/
public synchronized void setRangeBottomMax(Number rangeBottomMax) {
this.rangeBottomMax = rangeBottomMax;
}
/**
* @return the domainLeftMin
*/
public Number getDomainLeftMin() {
return domainLeftMin;
}
/**
* @param domainLeftMin the domainLeftMin to set
*/
public synchronized void setDomainLeftMin(Number domainLeftMin) {
this.domainLeftMin = domainLeftMin;
}
/**
* @return the domainLeftMax
*/
public Number getDomainLeftMax() {
return domainLeftMax;
}
/**
* @param domainLeftMax the domainLeftMax to set
*/
public synchronized void setDomainLeftMax(Number domainLeftMax) {
this.domainLeftMax = domainLeftMax;
}
/**
* @return the domainRightMin
*/
public Number getDomainRightMin() {
return domainRightMin;
}
/**
* @param domainRightMin the domainRightMin to set
*/
public synchronized void setDomainRightMin(Number domainRightMin) {
this.domainRightMin = domainRightMin;
}
/**
* @return the domainRightMax
*/
public Number getDomainRightMax() {
return domainRightMax;
}
/**
* @param domainRightMax the domainRightMax to set
*/
public synchronized void setDomainRightMax(Number domainRightMax) {
this.domainRightMax = domainRightMax;
}
public XYStepModel getDomainStepModel() {
return domainStepModel;
}
public void setDomainStepModel(XYStepModel domainStepModel) {
this.domainStepModel = domainStepModel;
}
public XYStepModel getRangeStepModel() {
return rangeStepModel;
}
public void setRangeStepModel(XYStepModel rangeStepModel) {
this.rangeStepModel = rangeStepModel;
}
} androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYPlotZoomPan.java 0000664 0000000 0000000 00000032777 12711435674 0031104 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.content.Context;
import android.graphics.PointF;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
public class XYPlotZoomPan extends XYPlot implements OnTouchListener {
private static final float MIN_DIST_2_FING = 5f;
// Definition of the touch states
private enum State
{
NONE,
ONE_FINGER_DRAG,
TWO_FINGERS_DRAG
}
private State mode = State.NONE;
private float minXLimit = Float.MAX_VALUE;
private float maxXLimit = Float.MAX_VALUE;
private float minYLimit = Float.MAX_VALUE;
private float maxYLimit = Float.MAX_VALUE;
private float lastMinX = Float.MAX_VALUE;
private float lastMaxX = Float.MAX_VALUE;
private float lastMinY = Float.MAX_VALUE;
private float lastMaxY = Float.MAX_VALUE;
private PointF firstFingerPos;
private float mDistX;
private boolean mZoomEnabled; //default is enabled
private boolean mZoomVertically;
private boolean mZoomHorizontally;
private boolean mCalledBySelf;
private boolean mZoomEnabledInit;
private boolean mZoomVerticallyInit;
private boolean mZoomHorizontallyInit;
public XYPlotZoomPan(Context context, String title, RenderMode mode) {
super(context, title, mode);
setZoomEnabled(true); //Default is ZoomEnabled if instantiated programmatically
}
public XYPlotZoomPan(final Context context, final AttributeSet attrs) {
super(context, attrs);
if(mZoomEnabled || !mZoomEnabledInit) {
setZoomEnabled(true);
}
if(!mZoomHorizontallyInit) {
mZoomHorizontally = true;
}
if(!mZoomVerticallyInit) {
mZoomVertically = true;
}
}
public XYPlotZoomPan(final Context context, final AttributeSet attrs, final int defStyle) {
super(context, attrs, defStyle);
if(mZoomEnabled || !mZoomEnabledInit) {
setZoomEnabled(true);
}
if(!mZoomHorizontallyInit) {
mZoomHorizontally = true;
}
if(!mZoomVerticallyInit) {
mZoomVertically = true;
}
}
public XYPlotZoomPan(final Context context, final String title) {
super(context, title);
}
@Override
public void setOnTouchListener(OnTouchListener l) {
if(l != this) {
mZoomEnabled = false;
}
super.setOnTouchListener(l);
}
public boolean getZoomVertically() {
return mZoomVertically;
}
public void setZoomVertically(boolean zoomVertically) {
mZoomVertically = zoomVertically;
mZoomVerticallyInit = true;
}
public boolean getZoomHorizontally() {
return mZoomHorizontally;
}
public void setZoomHorizontally(boolean zoomHorizontally) {
mZoomHorizontally = zoomHorizontally;
mZoomHorizontallyInit = true;
}
public void setZoomEnabled(boolean enabled) {
if(enabled) {
setOnTouchListener(this);
} else {
setOnTouchListener(null);
}
mZoomEnabled = enabled;
mZoomEnabledInit = true;
}
public boolean getZoomEnabled() {
return mZoomEnabled;
}
private float getMinXLimit() {
if(minXLimit == Float.MAX_VALUE) {
minXLimit = getCalculatedMinX().floatValue();
lastMinX = minXLimit;
}
return minXLimit;
}
private float getMaxXLimit() {
if(maxXLimit == Float.MAX_VALUE) {
maxXLimit = getCalculatedMaxX().floatValue();
lastMaxX = maxXLimit;
}
return maxXLimit;
}
private float getMinYLimit() {
if(minYLimit == Float.MAX_VALUE) {
minYLimit = getCalculatedMinY().floatValue();
lastMinY = minYLimit;
}
return minYLimit;
}
private float getMaxYLimit() {
if(maxYLimit == Float.MAX_VALUE) {
maxYLimit = getCalculatedMaxY().floatValue();
lastMaxY = maxYLimit;
}
return maxYLimit;
}
private float getLastMinX() {
if(lastMinX == Float.MAX_VALUE) {
lastMinX = getCalculatedMinX().floatValue();
}
return lastMinX;
}
private float getLastMaxX() {
if(lastMaxX == Float.MAX_VALUE) {
lastMaxX = getCalculatedMaxX().floatValue();
}
return lastMaxX;
}
private float getLastMinY() {
if(lastMinY == Float.MAX_VALUE) {
lastMinY = getCalculatedMinY().floatValue();
}
return lastMinY;
}
private float getLastMaxY() {
if(lastMaxY == Float.MAX_VALUE) {
lastMaxY = getCalculatedMaxY().floatValue();
}
return lastMaxY;
}
@Override
public synchronized void setDomainBoundaries(final Number lowerBoundary, final BoundaryMode lowerBoundaryMode, final Number upperBoundary, final BoundaryMode upperBoundaryMode) {
super.setDomainBoundaries(lowerBoundary, lowerBoundaryMode, upperBoundary, upperBoundaryMode);
if(mCalledBySelf) {
mCalledBySelf = false;
} else {
minXLimit = lowerBoundaryMode == BoundaryMode.FIXED ? lowerBoundary.floatValue() : getCalculatedMinX().floatValue();
maxXLimit = upperBoundaryMode == BoundaryMode.FIXED ? upperBoundary.floatValue() : getCalculatedMaxX().floatValue();
lastMinX = minXLimit;
lastMaxX = maxXLimit;
}
}
@Override
public synchronized void setRangeBoundaries(final Number lowerBoundary, final BoundaryMode lowerBoundaryMode, final Number upperBoundary, final BoundaryMode upperBoundaryMode) {
super.setRangeBoundaries(lowerBoundary, lowerBoundaryMode, upperBoundary, upperBoundaryMode);
if(mCalledBySelf) {
mCalledBySelf = false;
} else {
minYLimit = lowerBoundaryMode == BoundaryMode.FIXED ? lowerBoundary.floatValue() : getCalculatedMinY().floatValue();
maxYLimit = upperBoundaryMode == BoundaryMode.FIXED ? upperBoundary.floatValue() : getCalculatedMaxY().floatValue();
lastMinY = minYLimit;
lastMaxY = maxYLimit;
}
}
@Override
public synchronized void setDomainBoundaries(final Number lowerBoundary, final Number upperBoundary, final BoundaryMode mode) {
super.setDomainBoundaries(lowerBoundary, upperBoundary, mode);
if(mCalledBySelf) {
mCalledBySelf = false;
} else {
minXLimit = mode == BoundaryMode.FIXED ? lowerBoundary.floatValue() : getCalculatedMinX().floatValue();
maxXLimit = mode == BoundaryMode.FIXED ? upperBoundary.floatValue() : getCalculatedMaxX().floatValue();
lastMinX = minXLimit;
lastMaxX = maxXLimit;
}
}
@Override
public synchronized void setRangeBoundaries(final Number lowerBoundary, final Number upperBoundary, final BoundaryMode mode) {
super.setRangeBoundaries(lowerBoundary, upperBoundary, mode);
if(mCalledBySelf) {
mCalledBySelf = false;
} else {
minYLimit = mode == BoundaryMode.FIXED ? lowerBoundary.floatValue() : getCalculatedMinY().floatValue();
maxYLimit = mode == BoundaryMode.FIXED ? upperBoundary.floatValue() : getCalculatedMaxY().floatValue();
lastMinY = minYLimit;
lastMaxY = maxYLimit;
}
}
@Override
public boolean onTouch(final View view, final MotionEvent event) {
switch (event.getAction() & MotionEvent.ACTION_MASK)
{
case MotionEvent.ACTION_DOWN: // start gesture
firstFingerPos = new PointF(event.getX(), event.getY());
mode = State.ONE_FINGER_DRAG;
break;
case MotionEvent.ACTION_POINTER_DOWN: // second finger
{
mDistX = getXDistance(event);
// the distance check is done to avoid false alarms
if(mDistX > MIN_DIST_2_FING || mDistX < -MIN_DIST_2_FING) {
mode = State.TWO_FINGERS_DRAG;
}
break;
}
case MotionEvent.ACTION_POINTER_UP: // end zoom
mode = State.NONE;
break;
case MotionEvent.ACTION_MOVE:
if(mode == State.ONE_FINGER_DRAG) {
pan(event);
} else if(mode == State.TWO_FINGERS_DRAG) {
zoom(event);
}
break;
}
return true;
}
private float getXDistance(final MotionEvent event) {
return event.getX(0) - event.getX(1);
}
private void pan(final MotionEvent motionEvent) {
final PointF oldFirstFinger = firstFingerPos; //save old position of finger
firstFingerPos = new PointF(motionEvent.getX(), motionEvent.getY()); //update finger position
PointF newX = new PointF();
if(mZoomHorizontally) {
calculatePan(oldFirstFinger, newX, true);
mCalledBySelf = true;
super.setDomainBoundaries(newX.x, newX.y, BoundaryMode.FIXED);
lastMinX = newX.x;
lastMaxX = newX.y;
}
if(mZoomVertically) {
calculatePan(oldFirstFinger, newX, false);
mCalledBySelf = true;
super.setRangeBoundaries(newX.x, newX.y, BoundaryMode.FIXED);
lastMinY = newX.x;
lastMaxY = newX.y;
}
redraw();
}
private void calculatePan(final PointF oldFirstFinger, PointF newX, final boolean horizontal) {
final float offset;
// multiply the absolute finger movement for a factor.
// the factor is dependent on the calculated min and max
if(horizontal) {
newX.x = getLastMinX();
newX.y = getLastMaxX();
offset = (oldFirstFinger.x - firstFingerPos.x) * ((newX.y - newX.x) / getWidth());
} else {
newX.x = getLastMinY();
newX.y = getLastMaxY();
offset = -(oldFirstFinger.y - firstFingerPos.y) * ((newX.y - newX.x) / getHeight());
}
// move the calculated offset
newX.x = newX.x + offset;
newX.y = newX.y + offset;
//get the distance between max and min
final float diff = newX.y - newX.x;
//check if we reached the limit of panning
if(horizontal) {
if(newX.x < getMinXLimit()) {
newX.x = getMinXLimit();
newX.y = newX.x + diff;
}
if(newX.y > getMaxXLimit()) {
newX.y = getMaxXLimit();
newX.x = newX.y - diff;
}
} else {
if(newX.x < getMinYLimit()) {
newX.x = getMinYLimit();
newX.y = newX.x + diff;
}
if(newX.y > getMaxYLimit()) {
newX.y = getMaxYLimit();
newX.x = newX.y - diff;
}
}
}
private void zoom(final MotionEvent motionEvent) {
final float oldDist = mDistX;
final float newDist = getXDistance(motionEvent);
// sign change! Fingers have crossed ;-)
if(oldDist > 0 && newDist < 0 || oldDist < 0 && newDist > 0) {
return;
}
mDistX = newDist;
float scale = (oldDist / mDistX);
// sanity check
if(Float.isInfinite(scale) || Float.isNaN(scale) || scale > -0.001 && scale < 0.001) {
return;
}
PointF newX = new PointF();
if(mZoomHorizontally) {
calculateZoom(scale, newX, true);
mCalledBySelf = true;
super.setDomainBoundaries(newX.x, newX.y, BoundaryMode.FIXED);
lastMinX = newX.x;
lastMaxX = newX.y;
}
if(mZoomVertically) {
calculateZoom(scale, newX, false);
mCalledBySelf = true;
super.setRangeBoundaries(newX.x, newX.y, BoundaryMode.FIXED);
lastMinY = newX.x;
lastMaxY = newX.y;
}
redraw();
}
private void calculateZoom(float scale, PointF newX, final boolean horizontal) {
final float calcMax;
final float span;
if(horizontal) {
calcMax = getLastMaxX();
span = calcMax - getLastMinX();
} else {
calcMax = getLastMaxY();
span = calcMax - getLastMinY();
}
final float midPoint = calcMax - (span / 2.0f);
final float offset = span * scale / 2.0f;
newX.x = midPoint - offset;
newX.y = midPoint + offset;
if(horizontal) {
if(newX.x < getMinXLimit()) {
newX.x = getMinXLimit();
}
if(newX.y > getMaxXLimit()) {
newX.y = getMaxXLimit();
}
} else {
if(newX.x < getMinYLimit()) {
newX.x = getMinYLimit();
}
if(newX.y > getMaxYLimit()) {
newX.y = getMaxYLimit();
}
}
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYRegionFormatter.java 0000664 0000000 0000000 00000003624 12711435674 0031756 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.content.Context;
import android.graphics.Paint;
import com.androidplot.util.Configurator;
/**
* Base class of all XYRegionFormatters.
*/
public class XYRegionFormatter {
private Paint paint = new Paint();
{
paint.setStyle(Paint.Style.FILL);
paint.setAntiAlias(true);
}
/**
* Provided as a convenience to users; allows instantiation and xml configuration
* to take place in a single line
*
* @param ctx
* @param xmlCfgId Id of the xml config file within /res/xml
*/
public XYRegionFormatter(Context ctx, int xmlCfgId) {
// prevent configuration of classes derived from this one:
if (getClass().equals(XYRegionFormatter.class)) {
Configurator.configure(ctx, this, xmlCfgId);
}
}
public XYRegionFormatter(int color) {
paint.setColor(color);
}
public int getColor() {
return paint.getColor();
}
public void setColor(int color) {
paint.setColor(color);
}
/**
* Advanced users can use this method to access the Paint instance to add transparency etc.
* @return
*/
public Paint getPaint() {
return paint;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYSeries.java 0000664 0000000 0000000 00000003251 12711435674 0030075 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import com.androidplot.Series;
/**
* Represents a two dimensional series of data represented as xy values.
*/
public interface XYSeries extends Series {
/**
* @return Number of elements in this Series.
*/
int size();
/**
* Returns the x-value for an index within a series.
*
* @param index the index index (in the range 0 to
* size()-1).
*
* @return The x-value.
*/
Number getX(int index);
/**
* Returns the y-value for an index within a series.
*
* @param index the index index (in the range 0 to
* size()-1).
*
* @return The y-value.
*/
Number getY(int index);
// /**
// * Optional method to optimize min/max value calculation. Implementations that do not wish to provide the
// * optimization should simply return null.
// * @return An instance of {@link XYBounds} containing xy min/max values.
// * @since 0.9.7
// */
// XYBounds getBounds();
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesFormatter.java 0000664 0000000 0000000 00000003177 12711435674 0031770 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import com.androidplot.ui.Formatter;
import com.androidplot.util.ZHash;
import com.androidplot.util.ZIndexable;
public abstract class XYSeriesFormatter extends Formatter {
ZHash regions;
{
regions = new ZHash();
}
public void addRegion(RectRegion region, XYRegionFormatterType regionFormatter) {
regions.addToBottom(region, regionFormatter);
}
public void removeRegion(RectRegion region) {
regions.remove(region);
}
/**
* Can be used to access z-index manipulation methods of ZIndexable.
* @return
*/
public ZIndexable getRegions() {
return regions;
}
/**
* @param region
* @return
*/
public XYRegionFormatterType getRegionFormatter(RectRegion region) {
return regions.get(region);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesRenderer.java 0000664 0000000 0000000 00000003625 12711435674 0031571 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import com.androidplot.ui.SeriesAndFormatter;
import com.androidplot.ui.SeriesRenderer;
import com.androidplot.util.ZIndexable;
import java.util.Hashtable;
/**
* Base class for all Renderers that render XYSeries data.
* @param
*/
public abstract class XYSeriesRenderer
extends SeriesRenderer {
public XYSeriesRenderer(XYPlot plot) {
super(plot);
}
/**
* TODO: get rid of this method!
* @return Map of all unique XYRegionFormatters to region labels.
*/
public Hashtable getUniqueRegionFormatters() {
Hashtable found = new Hashtable<>();
for(SeriesAndFormatter sfPair : getSeriesAndFormatterList()) {
ZIndexable regionIndexer = sfPair.getFormatter().getRegions();
for (RectRegion region : regionIndexer.elements()) {
XYRegionFormatter f = sfPair.getFormatter().getRegionFormatter(region);
found.put(f, region.getLabel());
}
}
return found;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYStep.java 0000664 0000000 0000000 00000003135 12711435674 0027557 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
/**
* An immutable object generated by XYStepCalculator representing
* a stepping model to be used by an XYPlot.
*/
public class XYStep {
private final float stepCount;
private final float stepPix;
private final double stepVal;
//public XYStep() {}
public XYStep(float stepCount, float stepPix, double stepVal) {
this.stepCount = stepCount;
this.stepPix = stepPix;
this.stepVal = stepVal;
}
public double getStepCount() {
return stepCount;
}
/*public void setStepCount(double stepCount) {
this.stepCount = stepCount;
}*/
public float getStepPix() {
return stepPix;
}
/*public void setStepPix(float stepPix) {
this.stepPix = stepPix;
}*/
public double getStepVal() {
return stepVal;
}
/*public void setStepVal(double stepVal) {
this.stepVal = stepVal;
}*/
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYStepCalculator.java 0000664 0000000 0000000 00000005525 12711435674 0031576 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.RectF;
import com.androidplot.util.ValPixConverter;
/**
* Calculates "stepping" values for a plot. These values are most commonly used for
* drawing grid lines on a graph.
*/
public class XYStepCalculator {
/**
* Convenience method - wraps other form of getStep().
* @param plot
* @param axisType
* @param rect
* @param minVal
* @param maxVal
* @return
*/
public static XYStep getStep(XYPlot plot, XYAxisType axisType, RectF rect, Number minVal, Number maxVal) {
XYStep step = null;
switch(axisType) {
case DOMAIN:
step = getStep(plot.getDomainStepMode(), rect.width(), plot.getDomainStepValue(), minVal, maxVal);
break;
case RANGE:
step = getStep(plot.getRangeStepMode(), rect.height(), plot.getRangeStepValue(), minVal, maxVal);
break;
}
return step;
}
public static XYStep getStep(XYStepMode typeXY, float plotPixelSize, double stepValue, Number minVal, Number maxVal) {
//XYStep step = new XYStep();
double stepVal = 0;
float stepPix = 0;
float stepCount = 0;
switch(typeXY) {
case INCREMENT_BY_VAL:
stepVal = stepValue;
stepPix = (float)(stepValue/ ValPixConverter.valPerPix(minVal.doubleValue(), maxVal.doubleValue(), plotPixelSize));
stepCount = plotPixelSize /stepPix;
break;
case INCREMENT_BY_PIXELS:
stepPix = new Double(stepValue).floatValue();
stepCount = plotPixelSize /stepPix;
stepVal = ValPixConverter.valPerPix(minVal.doubleValue(), maxVal.doubleValue(), plotPixelSize)*stepPix;
break;
case SUBDIVIDE:
stepCount = new Double(stepValue).floatValue();
stepPix = (plotPixelSize /(stepCount-1));
stepVal = ValPixConverter.valPerPix(minVal.doubleValue(), maxVal.doubleValue(), plotPixelSize)*stepPix;
break;
}
return new XYStep(stepCount, stepPix, stepVal);
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYStepMode.java 0000664 0000000 0000000 00000001706 12711435674 0030366 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
/**
* INCREMENTAL_VALUE - (default) draw a tick every n values.
* INCREMENTAL_PIXEL - draw a tick every n pixels.
* SUBDIVIDE - draw n number of evenly spaced ticks.
*/
public enum XYStepMode {
SUBDIVIDE, // default
INCREMENT_BY_VAL,
INCREMENT_BY_PIXELS
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/XYStepModel.java 0000664 0000000 0000000 00000002256 12711435674 0030543 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
/**
* Encapsulates a set of stepping parameters for a single axis.
*/
public class XYStepModel {
public XYStepModel(XYStepMode mode, double value) {
setMode(mode);
setValue(value);
}
private XYStepMode mode;
private double value;
public XYStepMode getMode() {
return mode;
}
public void setMode(XYStepMode mode) {
this.mode = mode;
}
public double getValue() {
return value;
}
public void setValue(double value) {
this.value = value;
}
}
androidplot-0.9.7/androidplot-core/src/main/java/com/androidplot/xy/YValueMarker.java 0000664 0000000 0000000 00000003562 12711435674 0030736 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Paint;
import com.androidplot.ui.XLayoutStyle;
import com.androidplot.ui.XPositionMetric;
public class YValueMarker extends ValueMarker {
/**
*
* @param value
* @param text Set to null to use the plot's default getFormatter.
*/
public YValueMarker(Number value, String text) {
super(value, text, new XPositionMetric(3, XLayoutStyle.ABSOLUTE_FROM_LEFT));
}
/**
*
* @param value
* @param text Set to null to use the plot's default getFormatter.
* @param textPosition
* @param linePaint
* @param textPaint
*/
public YValueMarker(Number value, String text, XPositionMetric textPosition, Paint linePaint, Paint textPaint) {
super(value, text, textPosition, linePaint, textPaint);
}
/**
*
* @param value
* @param text Set to null to use the plot's default getFormatter.
* @param textPosition
* @param linePaint
* @param textPaint
*/
public YValueMarker(Number value, String text, XPositionMetric textPosition, int linePaint, int textPaint) {
super(value, text, textPosition, linePaint, textPaint);
}
}
androidplot-0.9.7/androidplot-core/src/main/res/ 0000775 0000000 0000000 00000000000 12711435674 0021631 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/main/res/values/ 0000775 0000000 0000000 00000000000 12711435674 0023130 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/main/res/values/attrs.xml 0000664 0000000 0000000 00000034023 12711435674 0025011 0 ustar 00root root 0000000 0000000
androidplot-0.9.7/androidplot-core/src/test/ 0000775 0000000 0000000 00000000000 12711435674 0021073 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/ 0000775 0000000 0000000 00000000000 12711435674 0022014 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/android/ 0000775 0000000 0000000 00000000000 12711435674 0023434 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/android/net/ 0000775 0000000 0000000 00000000000 12711435674 0024222 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/android/net/http/ 0000775 0000000 0000000 00000000000 12711435674 0025201 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/android/net/http/AndroidHttpClient.java 0000664 0000000 0000000 00000001546 12711435674 0031431 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.net.http;
/**
* Workaround for Robolectric bug:
* https://github.com/robolectric/robolectric/issues/1862
* we can and should remove this package/class once Robolectric 3.1 is available.
*/
public class AndroidHttpClient {} androidplot-0.9.7/androidplot-core/src/test/java/com/ 0000775 0000000 0000000 00000000000 12711435674 0022572 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/ 0000775 0000000 0000000 00000000000 12711435674 0025111 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/LineRegionTest.java 0000664 0000000 0000000 00000004513 12711435674 0030652 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class LineRegionTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void testConstructor() throws Exception {
LineRegion lr = new LineRegion(0d, 0d);
assertEquals(0d, lr.getMinVal());
assertEquals(0d, lr.getMaxVal());
lr = new LineRegion(1.5d, -2d);
assertEquals(-2d, lr.getMinVal());
assertEquals(1.5d, lr.getMaxVal());
lr = new LineRegion(10d, 20d);
assertEquals(10d, lr.getMinVal());
assertEquals(20d, lr.getMaxVal());
}
@Test
public void testContains() throws Exception {
}
@Test
public void testIntersects() throws Exception {
LineRegion line1 = new LineRegion(1, 10);
LineRegion line2 = new LineRegion(11, 20);
assertFalse(line1.intersects(line2));
line1.setMaxVal(15);
assertTrue(line1.intersects(line2));
//l1end = 30;
line1.setMaxVal(30);
assertTrue(line1.intersects(line2));
//l1start = 21;
line1.setMinVal(21);
assertFalse(line1.intersects(line2));
}
@Test
public void testLength() throws Exception {
LineRegion lr = new LineRegion(0, 10);
assertEquals(10d, lr.length().doubleValue(), 0);
lr = new LineRegion(-5, 5);
assertEquals(10d, lr.length().doubleValue(), 0);
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/PlotTest.java 0000664 0000000 0000000 00000027726 12711435674 0027550 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot;
import android.content.res.TypedArray;
import android.graphics.*;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.RenderStack;
import com.androidplot.ui.SeriesAndFormatter;
import com.androidplot.ui.SeriesRenderer;
import com.androidplot.ui.Formatter;
import com.androidplot.util.Configurator;
import mockit.*;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertNotSame;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@RunWith(RobolectricTestRunner.class)
public class PlotTest {
static class MockPlotListener implements PlotListener {
public void onBeforeDraw(Plot source, Canvas canvas) {}
public void onAfterDraw(Plot source, Canvas canvas) {}
}
static class MockSeries implements Series {
public String getTitle() {
return null;
}
}
static class MockSeries2 implements Series {
public String getTitle() {
return null;
}
}
static class MockSeries3 implements Series {
public String getTitle() {
return null;
}
}
static class MockRenderer1 extends SeriesRenderer {
public MockRenderer1(Plot plot) {
super(plot);
}
@Override
public void onRender(Canvas canvas, RectF plotArea, Series series, Formatter formatter, RenderStack stack) throws PlotRenderException {
}
@Override
public void doDrawLegendIcon(Canvas canvas, RectF rect, Formatter formatter) {
}
}
static class MockRenderer2 extends SeriesRenderer {
public MockRenderer2(Plot plot) {
super(plot);
}
@Override
public void onRender(Canvas canvas, RectF plotArea, Series series, Formatter formatter, RenderStack stack) throws PlotRenderException {
}
@Override
public void doDrawLegendIcon(Canvas canvas, RectF rect, Formatter formatter) {
}
}
static class MockFormatter1 extends Formatter {
@Override
public Class getRendererClass() {
return MockRenderer1.class;
}
@Override
public SeriesRenderer getRendererInstance(MockPlot plot) {
return new MockRenderer1(plot);
}
}
static class MockFormatter2 extends Formatter {
@Override
public Class getRendererClass() {
return MockRenderer2.class;
}
@Override
public SeriesRenderer getRendererInstance(MockPlot plot) {
return new MockRenderer2(plot);
}
}
//@MockClass(realClass = Plot.class)
public static class MockPlot extends Plot {
public MockPlot(String title) {
super(RuntimeEnvironment.application, title);
}
@Override
protected void onPreInit() {
}
@Override
protected void processAttrs(TypedArray attrs) {
}
/*@Override
protected SeriesRenderer doGetRendererInstance(Class clazz) {
if(clazz == MockRenderer1.class) {
return new MockRenderer1(this);
} else if(clazz == MockRenderer2.class) {
return new MockRenderer2(this);
} else {
return null;
}
}*/
}
/*@Before
public void setUp() throws Exception {
Mockit.setUpMocks(MockPaint.class,MockContext.class);
}*/
@After
public void tearDown() throws Exception {
}
@Test
public void testAddSeries() throws Exception {
Plot plot = new MockPlot("MockPlot");
MockSeries m1 = new MockSeries();
Class cl = MockRenderer1.class;
plot.addSeries(m1, new MockFormatter1());
assertEquals(1, plot.getSeriesRegistry().size());
// duplicate Renderer added, registry size should not grow:
plot.addSeries(m1, new MockFormatter1());
assertEquals(1, plot.getRenderers().size());
assertEquals(1, plot.getRenderer(cl).getSeriesList().size());
MockSeries m2 = new MockSeries();
plot.addSeries(m2, new MockFormatter1());
// still should only be one renderer type:
assertEquals(1, plot.getRendererList().size());
// we added a new instance of cl to the renderer so there should be 2 in the subregistry:
assertEquals(2, plot.getRenderer(cl).getSeriesList().size());
// lets add another renderer:
plot.addSeries(m1, new MockFormatter2());
assertEquals(2, plot.getRendererList().size());
}
@Test
public void testRemoveSeries() throws Exception {
Plot plot = new MockPlot("MockPlot");
MockSeries m1 = new MockSeries();
MockSeries m2 = new MockSeries();
MockSeries m3 = new MockSeries();
plot.addSeries(m1, new MockFormatter1());
plot.addSeries(m2, new MockFormatter1());
plot.addSeries(m3, new MockFormatter1());
plot.addSeries(m1, new MockFormatter2());
plot.addSeries(m2, new MockFormatter2());
plot.addSeries(m3, new MockFormatter2());
// a quick sanity check:
assertEquals(2, plot.getRendererList().size());
assertEquals(3, plot.getRenderer(MockRenderer1.class).getSeriesList().size());
assertEquals(3, plot.getRenderer(MockRenderer2.class).getSeriesList().size());
plot.removeSeries(m1, MockRenderer1.class);
assertEquals(2, plot.getRenderer(MockRenderer1.class).getSeriesList().size());
plot.removeSeries(m2, MockRenderer1.class);
assertEquals(1, plot.getRenderer(MockRenderer1.class).getSeriesList().size());
plot.removeSeries(m2, MockRenderer1.class);
assertEquals(1, plot.getRenderer(MockRenderer1.class).getSeriesList().size());
plot.removeSeries(m3, MockRenderer1.class);
// add em all back
plot.addSeries(m1, new MockFormatter1());
plot.addSeries(m2, new MockFormatter1());
plot.addSeries(m3, new MockFormatter1());
plot.addSeries(m1, new MockFormatter1());
plot.addSeries(m2, new MockFormatter1());
plot.addSeries(m3, new MockFormatter1());
// a quick sanity check:
assertEquals(2, plot.getRendererList().size());
assertEquals(3, plot.getRenderer(MockRenderer1.class).getSeriesList().size());
assertEquals(3, plot.getRenderer(MockRenderer2.class).getSeriesList().size());
// now lets try removing a series from all renderers:
plot.removeSeries(m1);
assertEquals(2, plot.getRenderer(MockRenderer1.class).getSeriesList().size());
assertEquals(2, plot.getRenderer(MockRenderer2.class).getSeriesList().size());
// and now lets remove the remaining series:
plot.removeSeries(m2);
plot.removeSeries(m3);
}
@Test
public void testGetFormatter() throws Exception {
Plot plot = new MockPlot("MockPlot");
MockSeries m1 = new MockSeries();
MockSeries m2 = new MockSeries();
MockSeries m3 = new MockSeries();
MockFormatter1 f1 = new MockFormatter1();
MockFormatter1 f2 = new MockFormatter1();
MockFormatter2 f3 = new MockFormatter2();
plot.addSeries(m1, f1);
plot.addSeries(m2, f2);
plot.addSeries(m3, new MockFormatter1());
plot.addSeries(m1, new MockFormatter1());
plot.addSeries(m2, f3);
plot.addSeries(m3, new MockFormatter1());
assertEquals(plot.getRenderer(MockRenderer1.class).getFormatter(m1), f1);
assertEquals(plot.getRenderer(MockRenderer1.class).getFormatter(m2), f2);
assertEquals(plot.getRenderer(MockRenderer2.class).getFormatter(m2), f3);
assertNotSame(plot.getRenderer(MockRenderer2.class).getFormatter(m2), f1);
}
@Test
public void testGetRendererList() throws Exception {
Plot plot = new MockPlot("MockPlot");
MockSeries m1 = new MockSeries();
MockSeries m2 = new MockSeries();
MockSeries m3 = new MockSeries();
plot.addSeries(m1, new MockFormatter1());
plot.addSeries(m2, new MockFormatter1());
plot.addSeries(m3, new MockFormatter1());
plot.addSeries(m1, new MockFormatter2());
plot.addSeries(m2, new MockFormatter2());
plot.addSeries(m3, new MockFormatter2());
List rList = plot.getRendererList();
assertEquals(2, rList.size());
}
@Test
public void testAddListener() throws Exception {
Plot plot = new MockPlot("MockPlot");
ArrayList listeners = Deencapsulation.getField(plot, "listeners");
assertEquals(0, listeners.size());
MockPlotListener pl1 = new MockPlotListener();
MockPlotListener pl2 = new MockPlotListener();
plot.addListener(pl1);
assertEquals(1, listeners.size());
// should return false on a double entry attempt
assertFalse(plot.addListener(pl1));
// make sure the listener wasnt added anyway:
assertEquals(1, listeners.size());
plot.addListener(pl2);
assertEquals(2, listeners.size());
}
@Test
public void testRemoveListener() throws Exception {
Plot plot = new MockPlot("MockPlot");
ArrayList listeners = Deencapsulation.getField(plot, "listeners");
assertEquals(0, listeners.size());
MockPlotListener pl1 = new MockPlotListener();
MockPlotListener pl2 = new MockPlotListener();
MockPlotListener pl3 = new MockPlotListener();
plot.addListener(pl1);
plot.addListener(pl2);
assertEquals(2, listeners.size());
assertFalse(plot.removeListener(pl3));
assertTrue(plot.removeListener(pl1));
assertEquals(1, listeners.size());
assertFalse(plot.removeListener(pl1));
assertEquals(1, listeners.size());
assertTrue(plot.removeListener(pl2));
assertEquals(0, listeners.size());
}
@Test
public void testConfigure() throws Exception {
Plot plot = new MockPlot("MockPlot");
HashMap params = new HashMap();
String param1 = "this is a test.";
String param2 = "use_background_thread";
String param3 = "#FF0000";
params.put("title", param1);
params.put("renderMode", param2);
params.put("backgroundPaint.color", param3);
Configurator.configure(RuntimeEnvironment.application, plot, params);
assertEquals(param1, plot.getTitle());
assertEquals(Plot.RenderMode.USE_BACKGROUND_THREAD, plot.getRenderMode());
assertEquals(Color.parseColor(param3), plot.getBackgroundPaint().getColor());
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/RegionTest.java 0000664 0000000 0000000 00000003000 12711435674 0030030 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class RegionTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void testContains() throws Exception {
}
@Test
public void testIntersects() throws Exception {
LineRegion line1 = new LineRegion(1, 10);
LineRegion line2 = new LineRegion(11, 20);
assertFalse(line1.intersects(line2));
line1.setMaxVal(15);
assertTrue(line1.intersects(line2));
line1.setMaxVal(30);
assertTrue(line1.intersects(line2));
line1.setMinVal(21);
assertFalse(line1.intersects(line2));
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/test/ 0000775 0000000 0000000 00000000000 12711435674 0026070 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/test/AndroidplotTest.java 0000664 0000000 0000000 00000002255 12711435674 0032056 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.test;
import android.content.Context;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
/**
* Base class for all Androidplot tests that make use of Android platform classes.
*/
@RunWith(RobolectricTestRunner.class)
public abstract class AndroidplotTest {
/**
* Convience method - to access the application context.
* @return
*/
protected Context getContext() {
return RuntimeEnvironment.application;
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/ui/ 0000775 0000000 0000000 00000000000 12711435674 0025526 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/ui/DynamicTableModelTest.java 0000664 0000000 0000000 00000017753 12711435674 0032563 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import android.graphics.RectF;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import java.util.Iterator;
import static junit.framework.Assert.assertEquals;
@RunWith(RobolectricTestRunner.class)
public class DynamicTableModelTest {
@Test
public void testConstructor() throws Exception {
TableModel model = new DynamicTableModel(5, 5, TableOrder.COLUMN_MAJOR);
// TODO
}
@Test
public void testGetCellRect() throws Exception {
// square table, both rows and columns defined:
DynamicTableModel model = new DynamicTableModel(5, 5);
RectF tableRect = new RectF(0, 0, 1000, 2000);
RectF cellRect = model.getCellRect(tableRect, 10);
assertEquals(200f, cellRect.width());
// only rows defined:
model = new DynamicTableModel(5, 0);
cellRect = model.getCellRect(tableRect, 10);
assertEquals(200f, cellRect.width());
// only columns defined:
model = new DynamicTableModel(0, 5);
cellRect = model.getCellRect(tableRect, 10);
assertEquals(400f, cellRect.height());
}
@Test public void testIterator() throws Exception {
TableModel model = new DynamicTableModel(2, 2);
RectF tableRect = new RectF(0, 0, 1000, 2000);
// should stop at 4 iterations since the table can only hold that many:
Iterator it = model.getIterator(tableRect, 10);
int iterations = 0;
while(it.hasNext()) {
it.next();
iterations++;
}
assertEquals(4, iterations);
// now set a dynamic number of columns. iterations should equal however
// many elements we throw at it:
model = new DynamicTableModel(2, 0);
it = model.getIterator(tableRect, 10);
iterations = 0;
while(it.hasNext()) {
it.next();
iterations++;
}
assertEquals(10, iterations);
}
@Test
public void testRowMajorIteration() throws Exception {
// square table, both rows and columns defined:
TableModel model = new DynamicTableModel(2, 2);
RectF tableRect = new RectF(0, 0, 1000, 2000);
int createdCells = 4;
Iterator it = model.getIterator(tableRect, createdCells);
// 2x2:
// cell 0 (top-left
RectF cellRect = it.next();
assertEquals(500f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(0f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(500f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
// cell 1 (top-right)
cellRect = it.next();
assertEquals(500f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(500f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(1000f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
// cell 2 (bottom-left)
cellRect = it.next();
assertEquals(500f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(0f, cellRect.left);
assertEquals(1000f, cellRect.top);
assertEquals(500f, cellRect.right);
assertEquals(2000f, cellRect.bottom);
// cell 3 (bottom-right)
cellRect = it.next();
assertEquals(500f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(500f, cellRect.left);
assertEquals(1000f, cellRect.top);
assertEquals(1000f, cellRect.right);
assertEquals(2000f, cellRect.bottom);
// 2xN:
/*model = new DynamicTableModel(2, 0);
tableRect = new RectF(0, 0, 1000, 2000);
createdCells = 4;
it = model.getIterator(tableRect, createdCells);*/
}
@Test
public void testColumnMajorIteration() throws Exception {
// square table, both rows and columns defined:
TableModel model = new DynamicTableModel(2, 2, TableOrder.COLUMN_MAJOR);
RectF tableRect = new RectF(0, 0, 1000, 2000);
int createdCells = 4;
Iterator it = model.getIterator(tableRect, createdCells);
// 2x2 fixed:
// cell 0 (top-left
RectF cellRect = it.next();
assertEquals(500f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(0f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(500f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
// cell 1 (bottom-left)
cellRect = it.next();
assertEquals(500f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(0f, cellRect.left);
assertEquals(1000f, cellRect.top);
assertEquals(500f, cellRect.right);
assertEquals(2000f, cellRect.bottom);
// cell 2 (bottom-left)
cellRect = it.next();
assertEquals(500f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(500f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(1000f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
// cell 3 (bottom-right)
cellRect = it.next();
assertEquals(500f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(500f, cellRect.left);
assertEquals(1000f, cellRect.top);
assertEquals(1000f, cellRect.right);
assertEquals(2000f, cellRect.bottom);
}
@Test
public void testSingleRowIteration() throws Exception {
// square table, both rows and columns defined:
TableModel model = new DynamicTableModel(0, 1);
RectF tableRect = new RectF(0, 0, 1000, 1000);
int createdCells = 4;
Iterator it = model.getIterator(tableRect, createdCells);
// 2x2 fixed:
// cell 0 (top-left
RectF cellRect = it.next();
assertEquals(250f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(0f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(250f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
// cell 1
cellRect = it.next();
assertEquals(250f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(250f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(500f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
// cell 2
cellRect = it.next();
assertEquals(250f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(500f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(750f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
// cell 3
cellRect = it.next();
assertEquals(250f, cellRect.width());
assertEquals(1000f, cellRect.height());
assertEquals(750f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(1000f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/ui/FixedTableModelTest.java 0000664 0000000 0000000 00000020016 12711435674 0032220 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
import android.graphics.RectF;
import com.androidplot.test.AndroidplotTest;
import org.junit.Test;
import java.util.Iterator;
import static junit.framework.Assert.*;
public class FixedTableModelTest extends AndroidplotTest {
@Test
public void testConstructor() throws Exception {
FixedTableModel model = new FixedTableModel(100, 100, null);
// TODO
}
@Test
public void testIterator() throws Exception {
FixedTableModel model = new FixedTableModel(100, 100, TableOrder.COLUMN_MAJOR);
RectF tableRect = new RectF(0, 0, 1000, 2000);
Iterator it = model.getIterator(tableRect, 5);
assertTrue(it.hasNext());
RectF cellRect = it.next();
assertTrue(it.hasNext());
cellRect = it.next();
assertTrue(it.hasNext());
cellRect = it.next();
assertTrue(it.hasNext());
cellRect = it.next();
assertTrue(it.hasNext());
cellRect = it.next();
assertFalse(it.hasNext());
try {
cellRect = it.next();
fail("Expected IndexOutOfBoundsException");
} catch(IndexOutOfBoundsException ex) {
// this was expected
}
}
@Test
public void testColumnMajor() throws Exception {
FixedTableModel model = new FixedTableModel(300, 500, TableOrder.COLUMN_MAJOR);
RectF tableRect = new RectF(0, 0, 1000, 2000);
// test the numElement limit:
Iterator it = model.getIterator(tableRect, 5);
assertTrue(it.hasNext());
RectF cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(300f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(600f, cellRect.right);
assertEquals(500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(600f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(900f, cellRect.right);
assertEquals(500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(500f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(300f, cellRect.left);
assertEquals(500f, cellRect.top);
assertEquals(600f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
assertFalse(it.hasNext());
// test border limit:
it = model.getIterator(tableRect, 25);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(300f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(600f, cellRect.right);
assertEquals(500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(600f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(900f, cellRect.right);
assertEquals(500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(500f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(300f, cellRect.left);
assertEquals(500f, cellRect.top);
assertEquals(600f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(600f, cellRect.left);
assertEquals(500f, cellRect.top);
assertEquals(900f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(1000f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(1500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(300f, cellRect.left);
assertEquals(1000f, cellRect.top);
assertEquals(600f, cellRect.right);
assertEquals(1500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(600f, cellRect.left);
assertEquals(1000f, cellRect.top);
assertEquals(900f, cellRect.right);
assertEquals(1500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(1500f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(2000f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(300f, cellRect.left);
assertEquals(1500f, cellRect.top);
assertEquals(600f, cellRect.right);
assertEquals(2000f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(600f, cellRect.left);
assertEquals(1500f, cellRect.top);
assertEquals(900f, cellRect.right);
assertEquals(2000f, cellRect.bottom);
//we've reached the limit
assertFalse(it.hasNext());
}
@Test
public void testRowMajor() throws Exception {
FixedTableModel model = new FixedTableModel(300, 500, TableOrder.ROW_MAJOR);
RectF tableRect = new RectF(0, 0, 1000, 2000);
// test the numElement limit:
Iterator it = model.getIterator(tableRect, 5);
assertTrue(it.hasNext());
RectF cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(500f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(1000f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(1000f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(1500f, cellRect.bottom);
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(0f, cellRect.left);
assertEquals(1500f, cellRect.top);
assertEquals(300f, cellRect.right);
assertEquals(2000f, cellRect.bottom);
// next column over
assertTrue(it.hasNext());
cellRect = it.next();
assertEquals(300f, cellRect.left);
assertEquals(0f, cellRect.top);
assertEquals(600f, cellRect.right);
assertEquals(500f, cellRect.bottom);
}
} androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/util/ 0000775 0000000 0000000 00000000000 12711435674 0026066 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/util/ConfiguratorTest.java 0000664 0000000 0000000 00000004315 12711435674 0032236 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import java.lang.reflect.Method;
import static junit.framework.Assert.assertEquals;
@RunWith(RobolectricTestRunner.class)
public class ConfiguratorTest {
class A {
int d = 0;
public int getD() {
return d;
}
public void setD(int d) {
this.d = d;
}
}
class B {
A a = new A();
public A getA() {
return a;
}
public void setA(A a) {
this.a = a;
}
}
class C {
B b = new B();
public B getB() {
return b;
}
public void setB(B a) {
this.b = b;
}
}
@org.junit.Before
public void setUp() throws Exception {
}
@org.junit.After
public void tearDown() throws Exception {
}
@Test
public void testGetFieldAt() throws Exception {
C c = new C();
assertEquals(c, Configurator.getObjectContaining(c, "b"));
assertEquals(c.getB(), Configurator.getObjectContaining(c, "b.a"));
assertEquals(c.getB().getA(), Configurator.getObjectContaining(c, "b.a.d"));
}
@Test
public void testGetSetter() throws Exception {
C c = new C();
Method m = Configurator.getSetter(c.getClass(), "b");
assertEquals(1, m.getParameterTypes().length);
assertEquals(B.class, m.getParameterTypes()[0]);
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/util/ListOrganizerTest.java 0000664 0000000 0000000 00000004114 12711435674 0032365 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.LinkedList;
import static junit.framework.Assert.assertEquals;
public class ListOrganizerTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void testMoveToTop() throws Exception {
}
@Test
public void testMoveAbove() throws Exception {
}
@Test
public void testMoveBeneath() throws Exception {
}
@Test
public void testMoveToBottom() throws Exception {
Object obj1 = new Object();
Object obj2 = new Object();
Object obj3 = new Object();
LinkedList list = new LinkedList();
list.add(obj1);
list.add(obj2);
list.add(obj3);
assertEquals(obj1, list.getFirst());
assertEquals(obj3, list.getLast());
ListOrganizer organizer = new ListOrganizer(list);
organizer.moveToBottom(obj3);
assertEquals(obj2, list.getLast());
assertEquals(obj3, list.getFirst());
}
@Test
public void testMoveUp() throws Exception {
}
@Test
public void testMoveDown() throws Exception {
}
@Test
public void testAddFirst() throws Exception {
}
@Test
public void testAddLast() throws Exception {
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/util/PixelUtilsTest.java 0000664 0000000 0000000 00000002325 12711435674 0031675 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import org.junit.Test;
import java.util.regex.Pattern;
import static junit.framework.Assert.assertTrue;
public class PixelUtilsTest {
@org.junit.After
public void tearDown() throws Exception {
}
@Test
public void testDimensionPattern() {
Pattern DIMENSION_PATTERN = Pattern.compile(PixelUtils.DIMENSION_REGEX);
assertTrue("Dimension failed dimension pattern match", DIMENSION_PATTERN.matcher("20dp").matches());
assertTrue("Negative dimension failed dimension pattern match", DIMENSION_PATTERN.matcher("-20dp").matches());
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/util/SeriesUtilsTest.java 0000664 0000000 0000000 00000011475 12711435674 0032054 0 ustar 00root root 0000000 0000000 /*
* Copyright 2016 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import com.androidplot.Bounds;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.xy.XYBounds;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static junit.framework.Assert.assertEquals;
public class SeriesUtilsTest {
// 8 element lists:
final List LINEAR = Arrays.asList(new Number[]{ 1, 2, 3, 4 ,5 , 6, 7, 8});
final List LINEAR_INVERSE = Arrays.asList(new Number[]{ 8, 7, 6, 5, 4, 3, 2, 1});
final List ZIG_ZAG = Arrays.asList(new Number[]{1, 10, 1, 10, 1, 10, 1, 10});
final List NULLS = Arrays.asList(new Number[]{null, 2, null, 4, null, 0, -1, null});
// single element lists:
final List SINGLE_VALUE = Arrays.asList(new Number[]{3});
final List SINGLE_VALUE_NULL = Arrays.asList(new Number[]{null});
// empty list:
final List EMPTY = new ArrayList<>();
@org.junit.After
public void tearDown() throws Exception {
}
@Test
public void testSeriesMinMax() {
SimpleXYSeries series = new SimpleXYSeries(LINEAR, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, null);
XYBounds minMax = SeriesUtils.minMax(series);
assertEquals(0, minMax.getMinX());
assertEquals(7, minMax.getMaxX());
assertEquals(1, minMax.getMinY());
assertEquals(8, minMax.getMaxY());
series = new SimpleXYSeries(LINEAR_INVERSE, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, null);
minMax = SeriesUtils.minMax(series);
assertEquals(0, minMax.getMinX());
assertEquals(7, minMax.getMaxX());
assertEquals(1, minMax.getMinY());
assertEquals(8, minMax.getMaxY());
series = new SimpleXYSeries(ZIG_ZAG, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, null);
minMax = SeriesUtils.minMax(series);
assertEquals(0, minMax.getMinX());
assertEquals(7, minMax.getMaxX());
assertEquals(1, minMax.getMinY());
assertEquals(10, minMax.getMaxY());
series = new SimpleXYSeries(NULLS, NULLS, null);
minMax = SeriesUtils.minMax(series);
assertEquals(-1, minMax.getMinX());
assertEquals(4, minMax.getMaxX());
assertEquals(-1, minMax.getMinY());
assertEquals(4, minMax.getMaxY());
series = new SimpleXYSeries(SINGLE_VALUE, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, null);
minMax = SeriesUtils.minMax(series);
assertEquals(0, minMax.getMinX());
assertEquals(0, minMax.getMaxX());
assertEquals(3, minMax.getMinY());
assertEquals(3, minMax.getMaxY());
series = new SimpleXYSeries(SINGLE_VALUE_NULL, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, null);
minMax = SeriesUtils.minMax(series);
assertEquals(0, minMax.getMinX());
assertEquals(0, minMax.getMaxX());
assertEquals(null, minMax.getMinY());
assertEquals(null, minMax.getMaxY());
series = new SimpleXYSeries(EMPTY, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, null);
minMax = SeriesUtils.minMax(series);
assertEquals(null, minMax.getMinX());
assertEquals(null, minMax.getMaxX());
assertEquals(null, minMax.getMinY());
assertEquals(null, minMax.getMaxY());
}
@Test
public void testListMinMax() {
Bounds minMax = SeriesUtils.minMax(LINEAR);
assertEquals(1, minMax.getMin());
assertEquals(8, minMax.getMax());
minMax = SeriesUtils.minMax(LINEAR_INVERSE);
assertEquals(1, minMax.getMin());
assertEquals(8, minMax.getMax());
minMax = SeriesUtils.minMax(ZIG_ZAG);
assertEquals(1, minMax.getMin());
assertEquals(10, minMax.getMax());
minMax = SeriesUtils.minMax(NULLS);
assertEquals(-1, minMax.getMin());
assertEquals(4, minMax.getMax());
minMax = SeriesUtils.minMax(SINGLE_VALUE);
assertEquals(3, minMax.getMin());
assertEquals(3, minMax.getMax());
minMax = SeriesUtils.minMax(SINGLE_VALUE_NULL);
assertEquals(null, minMax.getMin());
assertEquals(null, minMax.getMax());
minMax = SeriesUtils.minMax(EMPTY);
assertEquals(null, minMax.getMin());
assertEquals(null, minMax.getMax());
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/util/ValPixConverterTest.java 0000664 0000000 0000000 00000010332 12711435674 0032663 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import org.junit.Test;
import static junit.framework.Assert.assertEquals;
import static org.junit.Assert.fail;
public class ValPixConverterTest {
@org.junit.Before
public void setUp() throws Exception {
}
@org.junit.After
public void tearDown() throws Exception {
}
@org.junit.Test
public void testValToPix() throws Exception {
int sizeInPix = 100;
int min = 0;
int max = 100;
int value = 50;
assertEquals(50.0f, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be closer to the top:
// (remember that 0,0 is the top left pixel)
value = 75;
assertEquals(25.0f, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be at the very top:
value = 100;
assertEquals(0.0f, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be at the very top:
value = 0;
assertEquals(100.0f, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be smack in the middle:
min = -100;
value = 0;
assertEquals(50.0f, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be at the very bottom:
value = 100;
assertEquals(0.0f, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be in the middle:
value = 0;
assertEquals(50.0f, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
min = -100;
max = 100;
sizeInPix = 200;
assertEquals(0f, ValPixConverter.valToPix(-100, min, max, sizeInPix, false));
assertEquals(200f, ValPixConverter.valToPix(100, min, max, sizeInPix, false));
}
@org.junit.Test
public void testpixToVal() throws Exception {
int sizeInPix = 100;
int min = 0;
int max = 100;
double value = 50;
float pixel = ValPixConverter.valToPix(value, min, max, sizeInPix, true);
assertEquals(value, ValPixConverter.pixToVal(pixel, min, max, sizeInPix, true));
value = 75;
pixel = ValPixConverter.valToPix(value, min, max, sizeInPix, true);
assertEquals(value, ValPixConverter.pixToVal(pixel, min, max, sizeInPix, true));
min = -100;
value = 50;
pixel = ValPixConverter.valToPix(value, min, max, sizeInPix, true);
assertEquals(value, ValPixConverter.pixToVal(pixel, min, max, sizeInPix, true));
min = -100;
value = 60;
pixel = ValPixConverter.valToPix(value, min, max, sizeInPix, true);
assertEquals(value, ValPixConverter.pixToVal(pixel, min, max, sizeInPix, true));
min = 20;
value = 50;
pixel = ValPixConverter.valToPix(value, min, max, sizeInPix, true);
assertEquals(value, ValPixConverter.pixToVal(pixel, min, max, sizeInPix, true));
try {
ValPixConverter.pixToVal(-5, 0, 0, 0, true);
fail("IllegalArgumentException expected.");
} catch(IllegalArgumentException ex) {}
}
@Test
public void testValPerPix() {
assertEquals(1.0, ValPixConverter.valPerPix(0, 100, 100));
double expected = 200d/100;
assertEquals(expected, ValPixConverter.valPerPix(100, 300, 100));
expected = 50d/100;
assertEquals(expected, ValPixConverter.valPerPix(0, 50, 100));
expected = 200d/100;
assertEquals(expected, ValPixConverter.valPerPix(-100, 100, 100));
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/xy/ 0000775 0000000 0000000 00000000000 12711435674 0025551 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/xy/RectRegionTest.java 0000664 0000000 0000000 00000004325 12711435674 0031321 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import com.androidplot.test.AndroidplotTest;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class RectRegionTest extends AndroidplotTest{
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void testContainsPoint() throws Exception {
}
@Test
public void testContainsValue() throws Exception {
}
@Test
public void testContainsDomainValue() throws Exception {
}
@Test
public void testContainsRangeValue() throws Exception {
}
@Test
public void testIsWithin() throws Exception {
RectRegion region1 = new RectRegion(0, 100, 0, 100, "");
RectRegion region2 = new RectRegion(5, 10, 5, 10, "");
assertTrue(region1.intersects(region2));
assertTrue(region2.intersects(region1));
RectRegion region3 = new RectRegion(101, 200, 101, 200, "");
assertFalse(region1.intersects(region3));
assertFalse(region3.intersects(region1));
RectRegion region4 = new RectRegion(99, 109, 99, 109, "");
assertTrue(region1.intersects(region4));
assertTrue(region4.intersects(region1));
// negative numbers:
RectRegion region5 = new RectRegion(-100, 1, -100, 1, "");
assertTrue(region1.intersects(region5));
assertTrue(region5.intersects(region1));
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/xy/SimpleXYSeriesTest.java 0000664 0000000 0000000 00000010574 12711435674 0032150 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import org.junit.Test;
import java.util.Arrays;
import static junit.framework.Assert.assertEquals;
public class SimpleXYSeriesTest {
@Test
public void testYValsOnlyConstructor() throws Exception {
Number[] yVals = {5, 6, 7, 8, 9};
SimpleXYSeries series = new SimpleXYSeries(Arrays.asList(yVals), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "test");
assertEquals(yVals[0], series.getY(0));
assertEquals(yVals[1], series.getY(1));
assertEquals(yVals[2], series.getY(2));
assertEquals(yVals[3], series.getY(3));
assertEquals(yVals[4], series.getY(4));
assertEquals(0, series.getX(0));
assertEquals(1, series.getX(1));
assertEquals(2, series.getX(2));
assertEquals(3, series.getX(3));
assertEquals(4, series.getX(4));
}
@Test
public void testXYInterleavedConstructor() throws Exception {
Number[] yVals = {55, 5, 66, 6, 77, 7, 88, 8, 99, 9};
SimpleXYSeries series = new SimpleXYSeries(Arrays.asList(yVals), SimpleXYSeries.ArrayFormat.XY_VALS_INTERLEAVED, "test");
assertEquals(5, series.getY(0));
assertEquals(6, series.getY(1));
assertEquals(7, series.getY(2));
assertEquals(8, series.getY(3));
assertEquals(9, series.getY(4));
assertEquals(55, series.getX(0));
assertEquals(66, series.getX(1));
assertEquals(77, series.getX(2));
assertEquals(88, series.getX(3));
assertEquals(99, series.getX(4));
}
@Test
public void testTwoListConstructor() throws Exception {
Number[] yVals = {5, 6, 7, 8, 9};
Number[] xVals = {1, 2, 3, 4, 5};
SimpleXYSeries series = new SimpleXYSeries(Arrays.asList(xVals), Arrays.asList(yVals), "test");
assertEquals(5, series.getY(0));
assertEquals(6, series.getY(1));
assertEquals(7, series.getY(2));
assertEquals(8, series.getY(3));
assertEquals(9, series.getY(4));
assertEquals(1, series.getX(0));
assertEquals(2, series.getX(1));
assertEquals(3, series.getX(2));
assertEquals(4, series.getX(3));
assertEquals(5, series.getX(4));
}
@Test
public void testPushPopStuff() throws Exception {
Number[] yVals = {5, 6, 7, 8, 9};
Number[] xVals = {1, 2, 3, 4, 5};
SimpleXYSeries series = new SimpleXYSeries(Arrays.asList(xVals), Arrays.asList(yVals), "test");
// chop off the tail:
series.removeLast();
assertEquals(8, series.getY(series.size()-1));
assertEquals(4, series.getX(series.size()-1));
// chop off the head:
series.removeFirst();
assertEquals(6, series.getY(0));
assertEquals(2, series.getX(0));
// add to the tail:
series.addLast(22, 33);
assertEquals(33, series.getY(series.size()-1));
assertEquals(22, series.getX(series.size()-1));
// add to the head:
series.addFirst(55, 66);
assertEquals(66, series.getY(0));
assertEquals(55, series.getX(0));
}
@Test
public void testSet() throws Exception {
Number[] yVals = {5, 6, 7, 8, 9};
Number[] xVals = {1, 2, 3, 4, 5};
SimpleXYSeries series = new SimpleXYSeries(Arrays.asList(xVals), Arrays.asList(yVals), "test");
int size = series.size();
series.setX(22, 2);
assertEquals(22, series.getX(2));
// make sure size has not changed:
assertEquals(size, series.size());
series.setY(23, 2);
assertEquals(23, series.getY(2));
// make sure size has not changed:
assertEquals(size, series.size());
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/xy/XYLegendWidgetTest.java 0000664 0000000 0000000 00000004245 12711435674 0032104 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.*;
import com.androidplot.Plot;
import com.androidplot.test.AndroidplotTest;
import mockit.*;
import org.junit.After;
import org.junit.Test;
import org.robolectric.RuntimeEnvironment;
import java.util.Arrays;
import static junit.framework.Assert.assertEquals;
public class XYLegendWidgetTest extends AndroidplotTest {
@After
public void tearDown() throws Exception {}
@Test
public void testDoOnDraw() throws Exception {
XYPlot plot = new XYPlot(RuntimeEnvironment.application, "Test",
Plot.RenderMode.USE_MAIN_THREAD);
SimpleXYSeries s1 = new SimpleXYSeries((Arrays.asList(1, 2, 3)),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "s1");
plot.addSeries(s1, new LineAndPointFormatter(
Color.RED, Color.GREEN, Color.BLUE, null));
assertEquals(1, plot.getSeriesRegistry().size());
Deencapsulation.invoke(plot, "onSizeChanged", 100, 100, 100, 100);
plot.redraw();
// have to manually invoke this because the invalidate()
// invoked by redraw() is a stub and will not result in onDraw being called.
Deencapsulation.invoke(plot, "onDraw", new Canvas());
plot.removeSeries(s1);
assertEquals(0, plot.getSeriesRegistry().size());
plot.addSeries(s1, new BarFormatter(Color.RED, Color.GREEN));
plot.redraw();
// throws NullPointerException before fix
// for ANDROIDPLOT-166 was applied.
Deencapsulation.invoke(plot, "onDraw", new Canvas());
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/xy/XYPlotTest.java 0000664 0000000 0000000 00000036067 12711435674 0030467 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.*;
import com.androidplot.Plot;
import com.androidplot.test.AndroidplotTest;
import com.androidplot.util.Configurator;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.robolectric.RuntimeEnvironment;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import static junit.framework.Assert.assertEquals;
public class XYPlotTest extends AndroidplotTest {
XYPlot plot; // testing
List numList1;
List numList2;
SimpleXYSeries series1;
@Before
public void setUp() throws Exception {
plot = new XYPlot(getContext(), "test");
numList1 = Arrays.asList(0, 1, 3, 5, 10, 15, 25, 50, 75, 100); // 10 elements
numList2 = Arrays.asList(-100, 0, 1, 3, 5, 10, 15, 25, 50, 75, 100, 200); // 12 elements
series1 = new SimpleXYSeries(numList1, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "");
}
@After
public void tearDown() throws Exception {
}
@Test
public void testOriginFixedMode() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.centerOnDomainOrigin(5, 2, BoundaryMode.FIXED);
plot.calculateMinMaxVals();
assertEquals(3.0, plot.getCalculatedMinX());
assertEquals(7.0, plot.getCalculatedMaxX());
}
@Test
public void testOriginAutoMode() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.centerOnDomainOrigin(5);
plot.calculateMinMaxVals();
assertEquals(10.0, plot.getCalculatedMaxX()); // symmetry is @ 10, not 9
assertEquals(0.0, plot.getCalculatedMinX());
plot.centerOnRangeOrigin(50);
plot.calculateMinMaxVals();
assertEquals(100.0, plot.getCalculatedMaxY());
assertEquals(0.0, plot.getCalculatedMinY());
}
@Test
public void testOriginGrowMode() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.centerOnDomainOrigin(5, null, BoundaryMode.GROW);
plot.calculateMinMaxVals();
assertEquals(0.0, plot.getCalculatedMinX());
assertEquals(10.0, plot.getCalculatedMaxX());
// introduce a larger domain set. boundaries should change
series1.setModel(numList2, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
assertEquals(-1.0, plot.getCalculatedMinX());
assertEquals(11.0, plot.getCalculatedMaxX());
// revert series model back to the previous set. boundaries should remain the same
series1.setModel(numList1, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
assertEquals(-1.0, plot.getCalculatedMinX());
assertEquals(11.0, plot.getCalculatedMaxX());
}
@Test
public void testOriginShrinkMode() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.centerOnDomainOrigin(5, null, BoundaryMode.SHRINK);
plot.calculateMinMaxVals();
assertEquals(0.0, plot.getCalculatedMinX());
assertEquals(10.0, plot.getCalculatedMaxX());
// update with more extreme values...nothing should change in shrink mode:
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
assertEquals(0.0, plot.getCalculatedMinX());
assertEquals(10.0, plot.getCalculatedMaxX());
}
// Ifor not sure about filling in test stubs just going to do my own stuff instead.
@Test
public void testsetDomainBoundaries() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.calculateMinMaxVals();
// default to auto so check them
assertEquals(0, plot.getCalculatedMinX());
assertEquals(9, plot.getCalculatedMaxX());
plot.setDomainBoundaries(2, BoundaryMode.FIXED, 8, BoundaryMode.FIXED);
plot.calculateMinMaxVals();
// fixed
assertEquals(2, plot.getCalculatedMinX());
assertEquals(8, plot.getCalculatedMaxX());
// back to auto
plot.setDomainBoundaries(2, BoundaryMode.AUTO, 8, BoundaryMode.AUTO);
plot.calculateMinMaxVals();
// check again
assertEquals(0, plot.getCalculatedMinX());
assertEquals(9, plot.getCalculatedMaxX());
// we are not testing MinY well with this dataset.
// try grow
plot.setDomainBoundaries(2, BoundaryMode.GROW, 8, BoundaryMode.GROW);
plot.calculateMinMaxVals();
// check inital
assertEquals(0, plot.getCalculatedMinX());
assertEquals(9, plot.getCalculatedMaxX());
// update with more extreme values...
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// after growing
assertEquals(0, plot.getCalculatedMinX());
assertEquals(11, plot.getCalculatedMaxX());
// back to previous
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// should not of changed.
assertEquals(0, plot.getCalculatedMinX());
assertEquals(11, plot.getCalculatedMaxX());
// back to big
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.setDomainBoundaries(2, BoundaryMode.SHRINK, 8, BoundaryMode.SHRINK);
plot.calculateMinMaxVals();
// check inital
assertEquals(0, plot.getCalculatedMinX());
assertEquals(11, plot.getCalculatedMaxX());
// now small
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// after shrinking
assertEquals(0, plot.getCalculatedMinX());
assertEquals(9, plot.getCalculatedMaxX());
// back to previous
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// should not of changed.
assertEquals(0, plot.getCalculatedMinX());
assertEquals(9, plot.getCalculatedMaxX());
// back to auto
plot.setDomainBoundaries(2, BoundaryMode.AUTO, 8, BoundaryMode.AUTO);
plot.calculateMinMaxVals();
// should of changed.
assertEquals(0, plot.getCalculatedMinX());
assertEquals(11, plot.getCalculatedMaxX());
}
@Test
public void testsetRangeBoundaries() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.calculateMinMaxVals();
// default to auto so check them
assertEquals(0, plot.getCalculatedMinY());
assertEquals(100, plot.getCalculatedMaxY());
plot.setRangeBoundaries(5, BoundaryMode.FIXED, 80, BoundaryMode.FIXED);
plot.calculateMinMaxVals();
// fixed
assertEquals(5, plot.getCalculatedMinY());
assertEquals(80, plot.getCalculatedMaxY());
// back to auto
plot.setRangeBoundaries(2, BoundaryMode.AUTO, 8, BoundaryMode.AUTO);
plot.calculateMinMaxVals();
// check again
assertEquals(0, plot.getCalculatedMinY());
assertEquals(100, plot.getCalculatedMaxY());
// try grow
plot.setRangeBoundaries(2, BoundaryMode.GROW, 8, BoundaryMode.GROW);
plot.calculateMinMaxVals();
// check inital
assertEquals(0, plot.getCalculatedMinY());
assertEquals(100, plot.getCalculatedMaxY());
// update with more extreme values...
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// after growing
assertEquals(-100, plot.getCalculatedMinY());
assertEquals(200, plot.getCalculatedMaxY());
// back to previous
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// should not of changed.
assertEquals(-100, plot.getCalculatedMinY());
assertEquals(200, plot.getCalculatedMaxY());
// back to big
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.setRangeBoundaries(2, BoundaryMode.SHRINK, 8, BoundaryMode.SHRINK);
plot.calculateMinMaxVals();
// check inital
assertEquals(-100, plot.getCalculatedMinY());
assertEquals(200, plot.getCalculatedMaxY());
// now small
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// after shrinking
assertEquals(0, plot.getCalculatedMinY());
assertEquals(100, plot.getCalculatedMaxY());
// back to previous
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// should not of changed.
assertEquals(0, plot.getCalculatedMinY());
assertEquals(100, plot.getCalculatedMaxY());
// back to auto
plot.setRangeBoundaries(2, BoundaryMode.AUTO, 8, BoundaryMode.AUTO);
plot.calculateMinMaxVals();
// should of changed.
assertEquals(-100, plot.getCalculatedMinY());
assertEquals(200, plot.getCalculatedMaxY());
}
@Test
public void testSetDomainRightMinMax() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.calculateMinMaxVals();
// default to auto so check them
assertEquals(0, plot.getCalculatedMinX());
assertEquals(9, plot.getCalculatedMaxX());
plot.setDomainRightMax(10);
plot.calculateMinMaxVals();
// same values.
assertEquals(0, plot.getCalculatedMinX());
assertEquals(9, plot.getCalculatedMaxX());
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// on RightMax
assertEquals(0, plot.getCalculatedMinX());
assertEquals(10, plot.getCalculatedMaxX());
plot.setDomainRightMax(null);
plot.calculateMinMaxVals();
// back to full
assertEquals(0, plot.getCalculatedMinX());
assertEquals(11, plot.getCalculatedMaxX());
// now the RightMin
plot.setDomainRightMin(10);
plot.calculateMinMaxVals();
// still to full
assertEquals(0, plot.getCalculatedMinX());
assertEquals(11, plot.getCalculatedMaxX());
// small list
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// on RightMin
assertEquals(0, plot.getCalculatedMinX());
assertEquals(10, plot.getCalculatedMaxX());
// now off again
plot.setDomainRightMin(null);
plot.calculateMinMaxVals();
// small values.
assertEquals(0, plot.getCalculatedMinX());
assertEquals(9, plot.getCalculatedMaxX());
}
@Test
public void testSetRangeTopBottomMinMax() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.calculateMinMaxVals();
// default to auto so check them
assertEquals(0, plot.getCalculatedMinY());
assertEquals(100, plot.getCalculatedMaxY());
plot.setRangeTopMax(110);
plot.setRangeBottomMin(-50);
plot.calculateMinMaxVals();
// same values.
assertEquals(0, plot.getCalculatedMinY());
assertEquals(100, plot.getCalculatedMaxY());
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// on Limits
assertEquals(-50, plot.getCalculatedMinY());
assertEquals(110, plot.getCalculatedMaxY());
plot.setRangeTopMax(null);
plot.setRangeBottomMin(null);
plot.calculateMinMaxVals();
// back to full
assertEquals(-100, plot.getCalculatedMinY());
assertEquals(200, plot.getCalculatedMaxY());
// now the Min
plot.setRangeTopMin(150);
plot.setRangeBottomMax(-60);
plot.calculateMinMaxVals();
// still to full
assertEquals(-100, plot.getCalculatedMinY());
assertEquals(200, plot.getCalculatedMaxY());
// small list
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// on Limits
assertEquals(-60, plot.getCalculatedMinY());
assertEquals(150, plot.getCalculatedMaxY());
// now off again
plot.setRangeTopMin(null);
plot.setRangeBottomMax(null);
plot.calculateMinMaxVals();
// small values.
assertEquals(0, plot.getCalculatedMinY());
assertEquals(100, plot.getCalculatedMaxY());
}
@Test
public void testSetDomainUpperBoundary() throws Exception {
}
@Test
public void testSetDomainLowerBoundary() throws Exception {
}
@Test
public void testSetRangeUpperBoundary() throws Exception {
}
@Test
public void testSetRangeLowerBoundary() throws Exception {
}
@Test
public void testSetDomainOrigin() throws Exception {
}
@Test
public void testSetRangeOrigin() throws Exception {
}
@Test
public void testConfigure() throws Exception {
HashMap params = new HashMap();
String param1 = "this is a test.";
String param2 = Plot.RenderMode.USE_BACKGROUND_THREAD.toString();
String param3 = "#FF0000";
params.put("title", param1);
params.put("renderMode", param2);
params.put("backgroundPaint.color", param3);
params.put("graphWidget.domainTickLabelPaint.color", param3);
Configurator.configure(RuntimeEnvironment.application, plot, params);
assertEquals(param1, plot.getTitle());
assertEquals(Plot.RenderMode.USE_BACKGROUND_THREAD, plot.getRenderMode());
assertEquals(Color.parseColor(param3), plot.getBackgroundPaint().getColor());
assertEquals(Color.parseColor(param3), plot.getGraphWidget().getDomainTickLabelPaint().getColor());
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/xy/XYSeriesRendererTest.java 0000664 0000000 0000000 00000004336 12711435674 0032464 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.*;
import com.androidplot.test.AndroidplotTest;
import com.androidplot.util.ValPixConverter;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.robolectric.RuntimeEnvironment;
import static junit.framework.Assert.assertEquals;
public class XYSeriesRendererTest extends AndroidplotTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void testDataToGridCorrelation() throws Exception {
RectF gridRect = new RectF(5, 5, 105, 105);
XYPlot plot = new XYPlot(RuntimeEnvironment.application, "Test");
plot.setDomainStepMode(XYStepMode.SUBDIVIDE);
plot.setDomainStepValue(10);
plot.setDomainBoundaries(0, 100, BoundaryMode.FIXED);
plot.setRangeBoundaries(0, 100, BoundaryMode.FIXED);
plot.calculateMinMaxVals();
XYStep domainStep = XYStepCalculator.getStep(plot, XYAxisType.DOMAIN, gridRect, plot.getCalculatedMinX().doubleValue(), plot.getCalculatedMaxX().doubleValue());
int x = 0;
float val = ValPixConverter.valToPix(x, 0, 9, gridRect.width(), false);
assertEquals(val, domainStep.getStepPix()*x);
x = 1;
val = ValPixConverter.valToPix(x, 0, 9, gridRect.width(), false);
assertEquals(val, domainStep.getStepPix()*x);
x = 9;
val = ValPixConverter.valToPix(x, 0, 9, gridRect.width(), false);
assertEquals(val, domainStep.getStepPix()*x);
}
}
androidplot-0.9.7/androidplot-core/src/test/java/com/androidplot/xy/XYStepCalculatorTest.java 0000664 0000000 0000000 00000003527 12711435674 0032471 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static junit.framework.Assert.assertEquals;
public class XYStepCalculatorTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void testGetStep() throws Exception {
}
@Test
public void testSubdivide() throws Exception {
int numSegments = 10;
float plotSize = 100;
double minVal = 0;
double maxVal = 100;
XYStep step = XYStepCalculator.getStep(XYStepMode.SUBDIVIDE, plotSize, numSegments, minVal, maxVal);
assertEquals(plotSize/(numSegments-1), step.getStepPix());
// make sure large values dont break anything:
minVal = 1000000000;
maxVal = 2000000000;
step = XYStepCalculator.getStep(XYStepMode.SUBDIVIDE, plotSize, numSegments, minVal, maxVal);
assertEquals(plotSize/(numSegments-1), step.getStepPix());
}
@Test
public void testIncrementByVal() throws Exception {
}
@Test
public void testIncrementByPixels() throws Exception {
}
}
androidplot-0.9.7/build.gradle 0000664 0000000 0000000 00000003161 12711435674 0016340 0 ustar 00root root 0000000 0000000 apply plugin: 'java'
repositories {
mavenCentral()
jcenter()
}
ext {
theBuildToolsVersion = '21.1.2'
theCompileSdkVersion = 23
theTargetSdkVersion = 23
theMinSdkVersion = 4
theVersionName = '0.9.7'
theVersionCode = 13
}
buildscript {
repositories {
mavenCentral()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:1.2.3'
classpath 'com.jakewharton.sdkmanager:gradle-plugin:0.12.+'
classpath 'com.github.dcendents:android-maven-gradle-plugin:1.3'
classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.4'
}
}
allprojects {
repositories {
mavenCentral()
}
}
/*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*subprojects {
// for now can't do this one here because it has to
// be loaded *before* any other plugin in each submodule
// and unless its listed at the top of the submodule plugin list,
// that doesnt seem to happen.
apply plugin: 'android-sdk-manager'
}*/
task wrapper(type: Wrapper) {
gradleVersion = '2.9'
} androidplot-0.9.7/demoapp-wearable/ 0000775 0000000 0000000 00000000000 12711435674 0017265 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/.gitignore 0000664 0000000 0000000 00000000007 12711435674 0021252 0 ustar 00root root 0000000 0000000 /build
androidplot-0.9.7/demoapp-wearable/build.gradle 0000664 0000000 0000000 00000003163 12711435674 0021547 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:1.2.3'
}
}
apply plugin: 'com.android.application'
repositories {
jcenter()
}
android {
compileSdkVersion theCompileSdkVersion
buildToolsVersion theBuildToolsVersion
defaultConfig {
applicationId "com.androidplot.demo.wearable"
minSdkVersion 20
targetSdkVersion theTargetSdkVersion
versionCode theVersionCode
versionName theVersionName
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_6
targetCompatibility JavaVersion.VERSION_1_6
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
compile project(':androidplot-core')
compile 'com.google.android.support:wearable:1.3.0'
compile 'com.google.android.gms:play-services-wearable:8.3.0'
}
androidplot-0.9.7/demoapp-wearable/proguard-rules.pro 0000664 0000000 0000000 00000001215 12711435674 0022761 0 ustar 00root root 0000000 0000000 # Add project specific ProGuard rules here.
# By default, the flags in this file are appended to flags specified
# in /usr/local/android_sdk/tools/proguard/proguard-android.txt
# You can edit the include path and order by changing the proguardFiles
# directive in build.gradle.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html
# Add any project specific keep options here:
# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}
androidplot-0.9.7/demoapp-wearable/src/ 0000775 0000000 0000000 00000000000 12711435674 0020054 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/ 0000775 0000000 0000000 00000000000 12711435674 0021000 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/AndroidManifest.xml 0000664 0000000 0000000 00000002617 12711435674 0024577 0 ustar 00root root 0000000 0000000
androidplot-0.9.7/demoapp-wearable/src/main/java/ 0000775 0000000 0000000 00000000000 12711435674 0021721 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/java/com/ 0000775 0000000 0000000 00000000000 12711435674 0022477 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/java/com/androidplot/ 0000775 0000000 0000000 00000000000 12711435674 0025016 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/java/com/androidplot/demo/ 0000775 0000000 0000000 00000000000 12711435674 0025742 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/java/com/androidplot/demo/wearable/ 0000775 0000000 0000000 00000000000 12711435674 0027524 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/java/com/androidplot/demo/wearable/MainActivity.java 0000664 0000000 0000000 00000007117 12711435674 0032776 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demo.wearable;
import android.app.Activity;
import android.graphics.DashPathEffect;
import android.os.Bundle;
import com.androidplot.util.PixelUtils;
import com.androidplot.xy.*;
import java.util.Arrays;
/**
* A simple XY Plot styled for wearables.
*/
public class MainActivity extends Activity {
private XYPlot plot;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// initialize our XYPlot reference:
plot = (XYPlot) findViewById(R.id.plot);
// create a couple arrays of y-values to plot:
Number[] series1Numbers = {1, 4, 2, 8, 4, 16, 8, 32, 16, 64};
Number[] series2Numbers = {5, 2, 10, 5, 20, 10, 40, 20, 80, 40};
// turn the above arrays into XYSeries':
// (Y_VALS_ONLY means use the element index as the x value)
XYSeries series1 = new SimpleXYSeries(Arrays.asList(series1Numbers),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Series1");
XYSeries series2 = new SimpleXYSeries(Arrays.asList(series2Numbers),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Series2");
// create formatters to use for drawing a series using LineAndPointRenderer
// and configure them from xml:
LineAndPointFormatter series1Format = new LineAndPointFormatter();
series1Format.setPointLabelFormatter(new PointLabelFormatter());
series1Format.configure(getApplicationContext(),
R.xml.line_point_formatter_with_labels);
LineAndPointFormatter series2Format = new LineAndPointFormatter();
series2Format.setPointLabelFormatter(new PointLabelFormatter());
series2Format.configure(getApplicationContext(),
R.xml.line_point_formatter_with_labels_2);
// add an "dash" effect to the series2 line:
series2Format.getLinePaint().setPathEffect(
new DashPathEffect(new float[] {
// always use DP when specifying pixel sizes, to keep things consistent across devices:
PixelUtils.dpToPix(20),
PixelUtils.dpToPix(15)}, 0));
// just for fun, add some smoothing to the lines:
// see: http://androidplot.com/smooth-curves-and-androidplot/
series1Format.setInterpolationParams(
new CatmullRomInterpolator.Params(10, CatmullRomInterpolator.Type.Centripetal));
series2Format.setInterpolationParams(
new CatmullRomInterpolator.Params(10, CatmullRomInterpolator.Type.Centripetal));
// add a new series' to the xyplot:
plot.addSeries(series1, series1Format);
plot.addSeries(series2, series2Format);
// reduce the number of range labels
plot.setTicksPerRangeLabel(3);
// rotate domain labels 45 degrees to make them more compact horizontally:
plot.getGraphWidget().setDomainLabelOrientation(-45);
}
}
androidplot-0.9.7/demoapp-wearable/src/main/res/ 0000775 0000000 0000000 00000000000 12711435674 0021571 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/res/layout/ 0000775 0000000 0000000 00000000000 12711435674 0023106 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/res/layout/activity_main.xml 0000664 0000000 0000000 00000005544 12711435674 0026500 0 ustar 00root root 0000000 0000000
androidplot-0.9.7/demoapp-wearable/src/main/res/xml/ 0000775 0000000 0000000 00000000000 12711435674 0022371 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp-wearable/src/main/res/xml/line_point_formatter_with_labels.xml 0000664 0000000 0000000 00000001607 12711435674 0031717 0 ustar 00root root 0000000 0000000
androidplot-0.9.7/demoapp-wearable/src/main/res/xml/line_point_formatter_with_labels_2.xml 0000664 0000000 0000000 00000001607 12711435674 0032140 0 ustar 00root root 0000000 0000000
androidplot-0.9.7/demoapp/ 0000775 0000000 0000000 00000000000 12711435674 0015505 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/build.gradle 0000664 0000000 0000000 00000002336 12711435674 0017770 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
apply plugin: 'android-sdk-manager'
apply plugin: 'android'
dependencies {
compile project(':androidplot-core')
compile 'com.crittercism:crittercism-android-agent:5.4.0'
}
android {
compileSdkVersion theCompileSdkVersion
buildToolsVersion theBuildToolsVersion
defaultConfig {
versionCode theVersionCode
versionName theVersionName
minSdkVersion 11
targetSdkVersion theTargetSdkVersion
applicationId "com.androidplot.demos"
}
/**
* TODO: uncomment this and address all the lint issues.
*/
lintOptions {
abortOnError false
}
}
androidplot-0.9.7/demoapp/proguard-project.txt 0000664 0000000 0000000 00000001657 12711435674 0021546 0 ustar 00root root 0000000 0000000 # To enable ProGuard in your project, edit project.properties
# to define the proguard.config property as described in that file.
#
# Add project specific ProGuard rules here.
# By default, the flags in this file are appended to flags specified
# in ${sdk.dir}/tools/proguard/proguard-android.txt
# You can edit the include path and order by changing the ProGuard
# include property in project.properties.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html
# Add any project specific keep options here:
# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}
# remove all debug and verbose level logging statements:
-assumenosideeffects class android.util.Log {
public static *** d(...);
public static *** v(...);
}
androidplot-0.9.7/demoapp/project.properties 0000664 0000000 0000000 00000004425 12711435674 0021276 0 ustar 00root root 0000000 0000000 #
# Copyright (c) 2012 AndroidPlot.com. All rights reserved.
#
# Redistribution and use of source without modification and derived binaries with or without modification,
# are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this list of
# conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice, this list
# of conditions and the following disclaimer in the documentation and/or other materials
# provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY ANDROIDPLOT.COM ``AS IS'' AND ANY EXPRESS OR IMPLIED
# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
# FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ANDROIDPLOT.COM OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# The views and conclusions contained in the software and documentation are those of the
# authors and should not be interpreted as representing official policies, either expressed
# or implied, of AndroidPlot.com.
#
# This file is automatically generated by Android Tools.
# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
#
# This file must be checked in Version Control Systems.
#
# To customize properties used by the Ant build system edit
# "ant.properties", and override values to adapt the script to your
# project structure.
#
# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
#proguard.config=${sdk.dir}\tools\proguard\proguard-android.txt:proguard-project.txt
# using config with optimization enabled so that things like log statement removal will work:
proguard.config=${sdk.dir}/tools/proguard/proguard-android-optimize.txt:proguard-project.txt
# Project target.
target=android-16
androidplot-0.9.7/demoapp/src/ 0000775 0000000 0000000 00000000000 12711435674 0016274 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/ 0000775 0000000 0000000 00000000000 12711435674 0017220 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/AndroidManifest.xml 0000664 0000000 0000000 00000012143 12711435674 0023012 0 ustar 00root root 0000000 0000000
androidplot-0.9.7/demoapp/src/main/java/ 0000775 0000000 0000000 00000000000 12711435674 0020141 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/java/com/ 0000775 0000000 0000000 00000000000 12711435674 0020717 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/java/com/androidplot/ 0000775 0000000 0000000 00000000000 12711435674 0023236 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/ 0000775 0000000 0000000 00000000000 12711435674 0024345 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/BarPlotExampleActivity.java 0000664 0000000 0000000 00000040066 12711435674 0031612 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import java.text.DateFormatSymbols;
import java.text.FieldPosition;
import java.text.NumberFormat;
import java.text.ParsePosition;
import java.util.Arrays;
import android.app.Activity;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PointF;
import android.os.Bundle;
import android.util.Pair;
import android.view.MotionEvent;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.ArrayAdapter;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.SeekBar;
import android.widget.Spinner;
import com.androidplot.LineRegion;
import com.androidplot.ui.*;
import com.androidplot.ui.widget.TextLabelWidget;
import com.androidplot.util.PixelUtils;
import com.androidplot.xy.*;
/**
* The simplest possible example of using AndroidPlot to plot some data.
*/
public class BarPlotExampleActivity extends Activity
{
private static final String NO_SELECTION_TXT = "Touch bar to select.";
private XYPlot plot;
private CheckBox series1CheckBox;
private CheckBox series2CheckBox;
private Spinner spRenderStyle, spWidthStyle, spSeriesSize;
private SeekBar sbFixedWidth, sbVariableWidth;
private XYSeries series1;
private XYSeries series2;
private enum SeriesSize {
TEN,
TWENTY,
SIXTY
}
// Create a couple arrays of y-values to plot:
Number[] series1Numbers10 = {2, null, 5, 2, 7, 4, 3, 7, 4, 5};
Number[] series2Numbers10 = {4, 6, 3, null, 2, 0, 7, 4, 5, 4};
Number[] series1Numbers20 = {2, null, 5, 2, 7, 4, 3, 7, 4, 5, 7, 4, 5, 8, 5, 3, 6, 3, 9, 3};
Number[] series2Numbers20 = {4, 6, 3, null, 2, 0, 7, 4, 5, 4, 9, 6, 2, 8, 4, 0, 7, 4, 7, 9};
Number[] series1Numbers60 = {2, null, 5, 2, 7, 4, 3, 7, 4, 5, 7, 4, 5, 8, 5, 3, 6, 3, 9, 3, 2, null, 5, 2, 7, 4, 3, 7, 4, 5, 7, 4, 5, 8, 5, 3, 6, 3, 9, 3, 2, null, 5, 2, 7, 4, 3, 7, 4, 5, 7, 4, 5, 8, 5, 3, 6, 3, 9, 3};
Number[] series2Numbers60 = {4, 6, 3, null, 2, 0, 7, 4, 5, 4, 9, 6, 2, 8, 4, 0, 7, 4, 7, 9, 4, 6, 3, null, 2, 0, 7, 4, 5, 4, 9, 6, 2, 8, 4, 0, 7, 4, 7, 9, 4, 6, 3, null, 2, 0, 7, 4, 5, 4, 9, 6, 2, 8, 4, 0, 7, 4, 7, 9};
Number[] series1Numbers = series1Numbers10;
Number[] series2Numbers = series2Numbers10;
private MyBarFormatter formatter1;
private MyBarFormatter formatter2;
private MyBarFormatter selectionFormatter;
private TextLabelWidget selectionWidget;
private Pair selection;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.bar_plot_example);
// initialize our XYPlot reference:
plot = (XYPlot) findViewById(R.id.plot);
formatter1 = new MyBarFormatter(Color.argb(200, 100, 150, 100), Color.LTGRAY);
formatter2 = new MyBarFormatter(Color.argb(200, 100, 100, 150), Color.LTGRAY);
selectionFormatter = new MyBarFormatter(Color.YELLOW, Color.WHITE);
selectionWidget = new TextLabelWidget(plot.getLayoutManager(), NO_SELECTION_TXT,
new Size(
PixelUtils.dpToPix(100), SizeLayoutType.ABSOLUTE,
PixelUtils.dpToPix(100), SizeLayoutType.ABSOLUTE),
TextOrientationType.HORIZONTAL);
selectionWidget.getLabelPaint().setTextSize(PixelUtils.dpToPix(16));
// add a dark, semi-transparent background to the selection label widget:
Paint p = new Paint();
p.setARGB(100, 0, 0, 0);
selectionWidget.setBackgroundPaint(p);
selectionWidget.position(
0, XLayoutStyle.RELATIVE_TO_CENTER,
PixelUtils.dpToPix(45), YLayoutStyle.ABSOLUTE_FROM_TOP,
AnchorPosition.TOP_MIDDLE);
selectionWidget.pack();
// reduce the number of range labels
plot.setTicksPerRangeLabel(3);
plot.setRangeLowerBoundary(0, BoundaryMode.FIXED);
plot.getGraphWidget().getGridBox().setPadding(30, 10, 30, 0);
plot.setTicksPerDomainLabel(2);
// setup checkbox listers:
series1CheckBox = (CheckBox) findViewById(R.id.s1CheckBox);
series1CheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
onS1CheckBoxClicked(b);
}
});
series2CheckBox = (CheckBox) findViewById(R.id.s2CheckBox);
series2CheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {onS2CheckBoxClicked(b);
}
});
plot.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View view, MotionEvent motionEvent) {
if(motionEvent.getAction() == MotionEvent.ACTION_DOWN) {
onPlotClicked(new PointF(motionEvent.getX(), motionEvent.getY()));
}
return true;
}
});
spRenderStyle = (Spinner) findViewById(R.id.spRenderStyle);
ArrayAdapter adapter = new ArrayAdapter (this, android.R.layout.simple_spinner_item, BarRenderer.BarRenderStyle.values() );
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spRenderStyle.setAdapter(adapter);
spRenderStyle.setSelection(BarRenderer.BarRenderStyle.OVERLAID.ordinal());
spRenderStyle.setOnItemSelectedListener(new OnItemSelectedListener() {
public void onItemSelected(AdapterView arg0, View arg1,int arg2, long arg3) {
updatePlot();
}
@Override
public void onNothingSelected(AdapterView arg0) {
}
});
spWidthStyle = (Spinner) findViewById(R.id.spWidthStyle);
ArrayAdapter adapter1 = new ArrayAdapter (this, android.R.layout.simple_spinner_item, BarRenderer.BarWidthStyle.values() );
adapter1.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spWidthStyle.setAdapter(adapter1);
spWidthStyle.setSelection(BarRenderer.BarWidthStyle.FIXED_WIDTH.ordinal());
spWidthStyle.setOnItemSelectedListener(new OnItemSelectedListener() {
public void onItemSelected(AdapterView arg0, View arg1,int arg2, long arg3) {
if (BarRenderer.BarWidthStyle.FIXED_WIDTH.equals(spWidthStyle.getSelectedItem())) {
sbFixedWidth.setVisibility(View.VISIBLE);
sbVariableWidth.setVisibility(View.INVISIBLE);
} else {
sbFixedWidth.setVisibility(View.INVISIBLE);
sbVariableWidth.setVisibility(View.VISIBLE);
}
updatePlot();
}
@Override
public void onNothingSelected(AdapterView arg0) {
}
});
spSeriesSize = (Spinner) findViewById(R.id.spSeriesSize);
ArrayAdapter adapter11 = new ArrayAdapter (this, android.R.layout.simple_spinner_item, SeriesSize.values() );
adapter11.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spSeriesSize.setAdapter(adapter11);
spSeriesSize.setSelection(SeriesSize.TEN.ordinal());
spSeriesSize.setOnItemSelectedListener(new OnItemSelectedListener() {
public void onItemSelected(AdapterView arg0, View arg1,int arg2, long arg3) {
switch ((SeriesSize)arg0.getSelectedItem()) {
case TEN:
series1Numbers = series1Numbers10;
series2Numbers = series2Numbers10;
break;
case TWENTY:
series1Numbers = series1Numbers20;
series2Numbers = series2Numbers20;
break;
case SIXTY:
series1Numbers = series1Numbers60;
series2Numbers = series2Numbers60;
break;
default:
break;
}
updatePlot();
}
@Override
public void onNothingSelected(AdapterView arg0) {
}
});
sbFixedWidth = (SeekBar) findViewById(R.id.sbFixed);
sbFixedWidth.setProgress(50);
sbFixedWidth.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
@Override
public void onProgressChanged(SeekBar seekBar, int i, boolean b) {updatePlot();}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {}
@Override
public void onStopTrackingTouch(SeekBar seekBar) {}
});
sbVariableWidth = (SeekBar) findViewById(R.id.sbVariable);
sbVariableWidth.setProgress(1);
sbVariableWidth.setVisibility(View.INVISIBLE);
sbVariableWidth.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
@Override
public void onProgressChanged(SeekBar seekBar, int i, boolean b) {updatePlot();}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {}
@Override
public void onStopTrackingTouch(SeekBar seekBar) {}
});
plot.setDomainValueFormat(new NumberFormat() {
@Override
public StringBuffer format(double value, StringBuffer buffer, FieldPosition field) {
int year = (int) (value + 0.5d) / 12;
int month = (int) ((value + 0.5d) % 12);
return new StringBuffer(DateFormatSymbols.getInstance().getShortMonths()[month] + " '0" + year);
}
@Override
public StringBuffer format(long value, StringBuffer buffer, FieldPosition field) {
throw new UnsupportedOperationException("Not yet implemented.");
}
@Override
public Number parse(String string, ParsePosition position) {
throw new UnsupportedOperationException("Not yet implemented.");
}
});
updatePlot();
}
private void updatePlot() {
// Remove all current series from each plot
plot.clear();
// Setup our Series with the selected number of elements
series1 = new SimpleXYSeries(Arrays.asList(series1Numbers), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Us");
series2 = new SimpleXYSeries(Arrays.asList(series2Numbers), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Them");
// add a new series' to the xyplot:
if (series1CheckBox.isChecked()) plot.addSeries(series1, formatter1);
if (series2CheckBox.isChecked()) plot.addSeries(series2, formatter2);
// Setup the BarRenderer with our selected options
MyBarRenderer renderer = ((MyBarRenderer)plot.getRenderer(MyBarRenderer.class));
renderer.setBarRenderStyle((BarRenderer.BarRenderStyle)spRenderStyle.getSelectedItem());
renderer.setBarWidthStyle((BarRenderer.BarWidthStyle)spWidthStyle.getSelectedItem());
renderer.setBarWidth(sbFixedWidth.getProgress());
renderer.setBarGap(sbVariableWidth.getProgress());
if (BarRenderer.BarRenderStyle.STACKED.equals(spRenderStyle.getSelectedItem())) {
plot.setRangeTopMin(15);
} else {
plot.setRangeTopMin(0);
}
plot.redraw();
}
private void onPlotClicked(PointF point) {
// make sure the point lies within the graph area. we use gridrect
// because it accounts for margins and padding as well.
if (plot.getGraphWidget().getGridDimensions().marginatedRect.contains(point.x, point.y)) {
Number x = plot.getXVal(point);
Number y = plot.getYVal(point);
selection = null;
double xDistance = 0;
double yDistance = 0;
// find the closest value to the selection:
for (SeriesAndFormatter sfPair : plot.getSeriesRegistry()) {
XYSeries series = sfPair.getSeries();
for (int i = 0; i < series.size(); i++) {
Number thisX = series.getX(i);
Number thisY = series.getY(i);
if (thisX != null && thisY != null) {
double thisXDistance =
LineRegion.measure(x, thisX).doubleValue();
double thisYDistance =
LineRegion.measure(y, thisY).doubleValue();
if (selection == null) {
selection = new Pair<>(i, series);
xDistance = thisXDistance;
yDistance = thisYDistance;
} else if (thisXDistance < xDistance) {
selection = new Pair<>(i, series);
xDistance = thisXDistance;
yDistance = thisYDistance;
} else if (thisXDistance == xDistance &&
thisYDistance < yDistance &&
thisY.doubleValue() >= y.doubleValue()) {
selection = new Pair<>(i, series);
xDistance = thisXDistance;
yDistance = thisYDistance;
}
}
}
}
} else {
// if the press was outside the graph area, deselect:
selection = null;
}
if(selection == null) {
selectionWidget.setText(NO_SELECTION_TXT);
} else {
selectionWidget.setText("Selected: " + selection.second.getTitle() +
" Value: " + selection.second.getY(selection.first));
}
plot.redraw();
}
private void onS1CheckBoxClicked(boolean checked) {
if (checked) {
plot.addSeries(series1, formatter1);
} else {
plot.removeSeries(series1);
}
plot.redraw();
}
private void onS2CheckBoxClicked(boolean checked) {
if (checked) {
plot.addSeries(series2, formatter2);
} else {
plot.removeSeries(series2);
}
plot.redraw();
}
class MyBarFormatter extends BarFormatter {
public MyBarFormatter(int fillColor, int borderColor) {
super(fillColor, borderColor);
}
@Override
public Class getRendererClass() {
return MyBarRenderer.class;
}
@Override
public SeriesRenderer getRendererInstance(XYPlot plot) {
return new MyBarRenderer(plot);
}
}
class MyBarRenderer extends BarRenderer {
public MyBarRenderer(XYPlot plot) {
super(plot);
}
/**
* Implementing this method to allow us to inject our
* special selection getFormatter.
* @param index index of the point being rendered.
* @param series XYSeries to which the point being rendered belongs.
* @return
*/
@Override
public MyBarFormatter getFormatter(int index, XYSeries series) {
if(selection != null &&
selection.second == series &&
selection.first == index) {
return selectionFormatter;
} else {
return getFormatter(series);
}
}
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/CandlestickChartActivity.java 0000664 0000000 0000000 00000011166 12711435674 0032140 0 ustar 00root root 0000000 0000000 /*
* Copyright 2016 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.graphics.Color;
import android.graphics.DashPathEffect;
import android.os.Bundle;
import com.androidplot.candlestick.CandlestickFormatter;
import com.androidplot.candlestick.CandlestickMaker;
import com.androidplot.util.PixelUtils;
import com.androidplot.xy.*;
import java.text.DecimalFormat;
import java.text.FieldPosition;
import java.text.Format;
import java.text.ParsePosition;
import java.util.Arrays;
import java.util.List;
/**
* A simple example of a candlestick chart rendered on an {@link XYPlot}.
*/
public class CandlestickChartActivity extends Activity
{
private XYPlot plot;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.candlestick_example);
// initialize our XYPlot reference:
plot = (XYPlot) findViewById(R.id.plot);
// create our min, max, high and low values:
List xVals = Arrays.asList(new Number[]{1, 2, 3, 4, 5});
XYSeries highVals = new SimpleXYSeries(xVals,
Arrays.asList(12, 10, 15, 8, 7), "high");
XYSeries lowVals = new SimpleXYSeries(xVals,
Arrays.asList(3, 1, 5, 0, 2), "low");
XYSeries openVals = new SimpleXYSeries(xVals,
Arrays.asList(5, 2, 7, 5, 3), "open");
XYSeries closeVals = new SimpleXYSeries(xVals,
Arrays.asList(7, 9, 6, 0, 4), "close");
// draw a simple line plot of the close vals:
LineAndPointFormatter lpf = new LineAndPointFormatter(Color.WHITE, Color.WHITE, null, null);
lpf.getLinePaint().setPathEffect(
new DashPathEffect(
new float[]{PixelUtils.dpToPix(5), PixelUtils.dpToPix(5)}, 0));
lpf.setInterpolationParams(
new CatmullRomInterpolator.Params(20, CatmullRomInterpolator.Type.Centripetal));
plot.addSeries(closeVals, lpf);
CandlestickFormatter formatter = new CandlestickFormatter();
// draw candlestick bodies as triangles instead of squares:
// triangles will point up for items that closed higher than they opened
// and down for those that closed lower:
formatter.setBodyStyle(CandlestickFormatter.BodyStyle.Triangle);
// add the candlestick series data to the plot:
CandlestickMaker.make(plot, formatter,
openVals, closeVals, highVals, lowVals);
// setup the range label formatting, etc:
plot.setRangeLabel("Amount");
plot.setTicksPerRangeLabel(3);
plot.setRangeValueFormat(new DecimalFormat("$0.00"));
// setup the domain label formatting, etc:
plot.setDomainBoundaries(0, 6, BoundaryMode.FIXED);
plot.setDomainLabel("Day");
plot.setDomainStep(XYStepMode.INCREMENT_BY_VAL, 1);
plot.setDomainValueFormat(new Format() {
@Override
public StringBuffer format(Object object, StringBuffer buffer, FieldPosition field) {
switch(((Number) object).intValue()) {
case 1:
buffer.append("Mon");
break;
case 2:
buffer.append("Tues");
break;
case 3:
buffer.append("Wed");
break;
case 4:
buffer.append("Thurs");
break;
case 5:
buffer.append("Fri");
break;
default:
// show nothing
}
return buffer;
}
@Override
public Object parseObject(String string, ParsePosition position) {
return null;
}
});
// rotate domain labels 45 degrees to make them more compact horizontally:
plot.getGraphWidget().setDomainLabelOrientation(-45);
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/DualScaleXYPlotExampleActivity.java 0000664 0000000 0000000 00000022763 12711435674 0033230 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import java.util.Arrays;
import android.app.Activity;
import android.graphics.Color;
import android.graphics.Paint.Align;
import android.os.Build;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import com.androidplot.ui.AnchorPosition;
import com.androidplot.ui.DynamicTableModel;
import com.androidplot.ui.SizeLayoutType;
import com.androidplot.ui.Size;
import com.androidplot.xy.LineAndPointFormatter;
import com.androidplot.xy.PointLabelFormatter;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.ui.XLayoutStyle;
import com.androidplot.xy.XYGraphWidget;
import com.androidplot.xy.XYLegendWidget;
import com.androidplot.xy.XYPlot;
import com.androidplot.xy.XYSeries;
import com.androidplot.ui.YLayoutStyle;
import com.androidplot.util.PixelUtils;
/**
* The simplest possible example of using AndroidPlot to plot some data.
*/
public class DualScaleXYPlotExampleActivity extends Activity implements OnClickListener {
private XYPlot plot1, plot2;
private Boolean series2_onRight = true;
private LineAndPointFormatter series1Format, series2Format;
private Button button;
// Declare and enable buttons to toggle whether the 2nd series is on left or right.
// Create a couple arrays of y-values to plot:
private Number[] series1Numbers = {1, 8, 5, 2, 7, 4};
private Number[] series2Numbers = {444, 613, 353, 876, 924, 1004};
XYSeries series1, series2;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.dual_scale_xy_plot_example);
final float f26 = PixelUtils.dpToPix(26);
final float f10 = PixelUtils.dpToPix(10);
final Size sm = new Size(0, SizeLayoutType.FILL, 0, SizeLayoutType.FILL);
plot1 = (XYPlot) findViewById(R.id.mySimpleXYPlot_L);
plot2 = (XYPlot) findViewById(R.id.mySimpleXYPlot_R);
// Disable Hardware Acceleration on the xyPlot view object.
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
plot1.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
plot2.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
}
/*
* Setup the Plots
*/
plot1.setPlotMargins(0, 0, 0, 0);
plot2.setPlotMargins(0, 0, 0, 0);
plot1.setPlotPadding(0, 0, 0, 0);
plot2.setPlotPadding(0, 0, 0, 0);
plot2.getDomainLabelWidget().setVisible(false);
plot2.getRangeLabelWidget().setVisible(false);
plot2.getTitleWidget().setVisible(false);
plot2.setBorderPaint(null);
plot2.setBackgroundPaint(null);
/*
* Setup the Graph Widgets
*/
XYGraphWidget graphWidget_L = plot1.getGraphWidget();
XYGraphWidget graphWidget_R = plot2.getGraphWidget();
graphWidget_L.setSize(sm);
graphWidget_R.setSize(sm);
graphWidget_L.setMargins(0, 0, 0, 0);
graphWidget_R.setMargins(0, 0, 0, 0);
graphWidget_L.setPadding(f26, f10, f26, f26);
graphWidget_R.setPadding(f26, f10, f26, f26);
graphWidget_L.setRangeAxisPosition(true, false, 4, "10");
graphWidget_R.setRangeAxisPosition(false, false, 4, "10");
graphWidget_L.setRangeTickLabelVerticalOffset(-3);
graphWidget_R.setRangeTickLabelVerticalOffset(-3);
graphWidget_L.setRangeOriginTickLabelPaint(null);
graphWidget_R.setRangeOriginTickLabelPaint(null);
graphWidget_L.setRangeTickLabelWidth(0);
graphWidget_R.setRangeTickLabelWidth(0);
graphWidget_L.setDomainTickLabelWidth(0);
graphWidget_R.setDomainTickLabelWidth(0);
graphWidget_R.setBackgroundPaint(null);
graphWidget_R.setDomainTickLabelPaint(null);
graphWidget_R.setGridBackgroundPaint(null);
graphWidget_R.setDomainOriginTickLabelPaint(null);
graphWidget_R.setRangeOriginLinePaint(null);
graphWidget_R.setDomainGridLinePaint(null);
graphWidget_R.setRangeGridLinePaint(null);
graphWidget_L.getRangeTickLabelPaint().setTextSize(PixelUtils.dpToPix(8));
graphWidget_R.getRangeTickLabelPaint().setTextSize(PixelUtils.dpToPix(8));
graphWidget_L.getDomainOriginTickLabelPaint().setTextSize(PixelUtils.dpToPix(8));
graphWidget_L.getDomainTickLabelPaint().setTextSize(PixelUtils.dpToPix(8));
float textSize = graphWidget_L.getRangeTickLabelPaint().getTextSize();
graphWidget_L.setRangeTickLabelVerticalOffset((textSize / 2) * -1);
graphWidget_R.setRangeTickLabelVerticalOffset(graphWidget_L.getRangeTickLabelVerticalOffset());
/*
* Position the Graph Widgets in the Centre
*/
graphWidget_L.position(0, XLayoutStyle.ABSOLUTE_FROM_CENTER, 0, YLayoutStyle.ABSOLUTE_FROM_CENTER, AnchorPosition.CENTER);
graphWidget_R.position(0, XLayoutStyle.ABSOLUTE_FROM_CENTER, 0, YLayoutStyle.ABSOLUTE_FROM_CENTER, AnchorPosition.CENTER);
/*
* Position the Label Widgets
*/
plot1.getDomainLabelWidget().setWidth(100);
plot1.getRangeLabelWidget().setWidth(100);
plot1.getDomainLabelWidget().position(0, XLayoutStyle.RELATIVE_TO_CENTER, 1, YLayoutStyle.ABSOLUTE_FROM_BOTTOM, AnchorPosition.BOTTOM_MIDDLE);
plot1.getRangeLabelWidget().position(1, XLayoutStyle.ABSOLUTE_FROM_LEFT, -20, YLayoutStyle.ABSOLUTE_FROM_CENTER, AnchorPosition.LEFT_BOTTOM);
/*
* Setup and Position the LEFT Legend
*/
XYLegendWidget legendWidget_LEFT = plot1.getLegendWidget();
legendWidget_LEFT.setSize(new Size(100, SizeLayoutType.ABSOLUTE, 200, SizeLayoutType.ABSOLUTE));
legendWidget_LEFT.setPadding(1, 1, 1, 1);
legendWidget_LEFT.setTableModel(new DynamicTableModel(1, 3));
legendWidget_LEFT.setIconSize(new Size(PixelUtils.dpToPix(10), SizeLayoutType.ABSOLUTE, PixelUtils.dpToPix(10), SizeLayoutType.ABSOLUTE));
legendWidget_LEFT.getTextPaint().setTextSize(PixelUtils.dpToPix(9));
legendWidget_LEFT.position(PixelUtils.dpToPix(30), XLayoutStyle.ABSOLUTE_FROM_LEFT, f10 + 2, YLayoutStyle.ABSOLUTE_FROM_TOP, AnchorPosition.LEFT_TOP);
/*
* Setup and Position the RIGHT Legend
*/
XYLegendWidget legendWidget_RIGHT = plot2.getLegendWidget();
legendWidget_RIGHT.setSize(new Size(100, SizeLayoutType.ABSOLUTE, 200, SizeLayoutType.ABSOLUTE));
legendWidget_RIGHT.setPadding(1, 1, 1, 1);
legendWidget_RIGHT.setTableModel(new DynamicTableModel(1, 3));
legendWidget_RIGHT.setIconSize(new Size(PixelUtils.dpToPix(10), SizeLayoutType.ABSOLUTE, PixelUtils.dpToPix(10), SizeLayoutType.ABSOLUTE));
legendWidget_RIGHT.getTextPaint().setTextSize(PixelUtils.dpToPix(9));
legendWidget_RIGHT.getTextPaint().setTextAlign(Align.RIGHT);
legendWidget_RIGHT.setMarginLeft(185);
legendWidget_RIGHT.position(PixelUtils.dpToPix(30), XLayoutStyle.ABSOLUTE_FROM_RIGHT, f10 + 2, YLayoutStyle.ABSOLUTE_FROM_TOP, AnchorPosition.RIGHT_TOP);
// Setup the Series
series1 = new SimpleXYSeries(Arrays.asList(series1Numbers), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Series1");
series2 = new SimpleXYSeries(Arrays.asList(series2Numbers), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Series2");
// Setup the formatters
series1Format = new LineAndPointFormatter(Color.rgb(0, 200, 0), Color.rgb(0, 100, 0), null, new PointLabelFormatter(Color.WHITE));
series2Format = new LineAndPointFormatter(Color.rgb(0, 0, 200), Color.rgb(0, 0, 100), null, new PointLabelFormatter(Color.WHITE));
// Setup the Button
button = (Button) findViewById(R.id.toggleSeries2);
button.setOnClickListener(this);
}
@Override
protected void onResume() {
super.onResume();
updateView();
}
private void updateView() {
// Remove all current series from each plot
plot1.clear();
plot2.clear();
// Add series to each plot as needed.
plot1.addSeries(series1, series1Format);
if (series2_onRight) {
plot2.addSeries(series2, series2Format);
} else {
plot1.addSeries(series2, series2Format);
}
// Finalise each Plot based on whether they have any series or not.
if (!plot2.getSeriesRegistry().isEmpty()) {
plot2.setVisibility(XYPlot.VISIBLE);
plot2.redraw();
} else {
plot2.setVisibility(XYPlot.INVISIBLE);
}
if (!plot1.getSeriesRegistry().isEmpty()) {
plot1.setVisibility(XYPlot.VISIBLE);
plot1.redraw();
} else {
plot1.setVisibility(XYPlot.INVISIBLE);
}
}
@Override
public void onClick(View v) {
if (series2_onRight) {
series2_onRight = false;
} else {
series2_onRight = true;
}
updateView();
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/DynamicXYPlotActivity.java 0000664 0000000 0000000 00000017637 12711435674 0031447 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.graphics.Color;
import android.graphics.DashPathEffect;
import android.graphics.Paint;
import android.os.Bundle;
import com.androidplot.Plot;
import com.androidplot.util.PixelUtils;
import com.androidplot.xy.XYSeries;
import com.androidplot.xy.*;
import java.text.DecimalFormat;
import java.util.Observable;
import java.util.Observer;
public class DynamicXYPlotActivity extends Activity {
// redraws a plot whenever an update is received:
private class MyPlotUpdater implements Observer {
Plot plot;
public MyPlotUpdater(Plot plot) {
this.plot = plot;
}
@Override
public void update(Observable o, Object arg) {
plot.redraw();
}
}
private XYPlot dynamicPlot;
private MyPlotUpdater plotUpdater;
SampleDynamicXYDatasource data;
private Thread myThread;
@Override
public void onCreate(Bundle savedInstanceState) {
// android boilerplate stuff
super.onCreate(savedInstanceState);
setContentView(R.layout.dynamicxyplot_example);
// get handles to our View defined in layout.xml:
dynamicPlot = (XYPlot) findViewById(R.id.dynamicXYPlot);
plotUpdater = new MyPlotUpdater(dynamicPlot);
// only display whole numbers in domain labels
dynamicPlot.getGraphWidget().setDomainValueFormat(new DecimalFormat("0"));
// getInstance and position datasets:
data = new SampleDynamicXYDatasource();
SampleDynamicSeries sine1Series = new SampleDynamicSeries(data, 0, "Sine 1");
SampleDynamicSeries sine2Series = new SampleDynamicSeries(data, 1, "Sine 2");
LineAndPointFormatter formatter1 = new LineAndPointFormatter(
Color.rgb(0, 0, 0), null, null, null);
formatter1.getLinePaint().setStrokeJoin(Paint.Join.ROUND);
formatter1.getLinePaint().setStrokeWidth(10);
dynamicPlot.addSeries(sine1Series,
formatter1);
LineAndPointFormatter formatter2 =
new LineAndPointFormatter(Color.rgb(0, 0, 200), null, null, null);
formatter2.getLinePaint().setStrokeWidth(10);
formatter2.getLinePaint().setStrokeJoin(Paint.Join.ROUND);
//formatter2.getFillPaint().setAlpha(220);
dynamicPlot.addSeries(sine2Series, formatter2);
// hook up the plotUpdater to the data model:
data.addObserver(plotUpdater);
// thin out domain tick labels so they dont overlap each other:
dynamicPlot.setDomainStepMode(XYStepMode.INCREMENT_BY_VAL);
dynamicPlot.setDomainStepValue(5);
dynamicPlot.setRangeStepMode(XYStepMode.INCREMENT_BY_VAL);
dynamicPlot.setRangeStepValue(10);
dynamicPlot.setRangeValueFormat(new DecimalFormat("###.#"));
// uncomment this line to freeze the range boundaries:
dynamicPlot.setRangeBoundaries(-100, 100, BoundaryMode.FIXED);
// create a dash effect for domain and range grid lines:
DashPathEffect dashFx = new DashPathEffect(
new float[] {PixelUtils.dpToPix(3), PixelUtils.dpToPix(3)}, 0);
dynamicPlot.getGraphWidget().getDomainGridLinePaint().setPathEffect(dashFx);
dynamicPlot.getGraphWidget().getRangeGridLinePaint().setPathEffect(dashFx);
}
@Override
public void onResume() {
// kick off the data generating thread:
myThread = new Thread(data);
myThread.start();
super.onResume();
}
@Override
public void onPause() {
data.stopThread();
super.onPause();
}
class SampleDynamicXYDatasource implements Runnable {
// encapsulates management of the observers watching this datasource for update events:
class MyObservable extends Observable {
@Override
public void notifyObservers() {
setChanged();
super.notifyObservers();
}
}
private static final double FREQUENCY = 5; // larger is lower frequency
private static final int MAX_AMP_SEED = 100;
private static final int MIN_AMP_SEED = 10;
private static final int AMP_STEP = 1;
public static final int SINE1 = 0;
public static final int SINE2 = 1;
private static final int SAMPLE_SIZE = 30;
private int phase = 0;
private int sinAmp = 1;
private MyObservable notifier;
private boolean keepRunning = false;
{
notifier = new MyObservable();
}
public void stopThread() {
keepRunning = false;
}
//@Override
public void run() {
try {
keepRunning = true;
boolean isRising = true;
while (keepRunning) {
Thread.sleep(10); // decrease or remove to speed up the refresh rate.
phase++;
if (sinAmp >= MAX_AMP_SEED) {
isRising = false;
} else if (sinAmp <= MIN_AMP_SEED) {
isRising = true;
}
if (isRising) {
sinAmp += AMP_STEP;
} else {
sinAmp -= AMP_STEP;
}
notifier.notifyObservers();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public int getItemCount(int series) {
return SAMPLE_SIZE;
}
public Number getX(int series, int index) {
if (index >= SAMPLE_SIZE) {
throw new IllegalArgumentException();
}
return index;
}
public Number getY(int series, int index) {
if (index >= SAMPLE_SIZE) {
throw new IllegalArgumentException();
}
double angle = (index + (phase))/FREQUENCY;
double amp = sinAmp * Math.sin(angle);
switch (series) {
case SINE1:
return amp;
case SINE2:
return -amp;
default:
throw new IllegalArgumentException();
}
}
public void addObserver(Observer observer) {
notifier.addObserver(observer);
}
public void removeObserver(Observer observer) {
notifier.deleteObserver(observer);
}
}
class SampleDynamicSeries implements XYSeries {
private SampleDynamicXYDatasource datasource;
private int seriesIndex;
private String title;
public SampleDynamicSeries(SampleDynamicXYDatasource datasource, int seriesIndex, String title) {
this.datasource = datasource;
this.seriesIndex = seriesIndex;
this.title = title;
}
@Override
public String getTitle() {
return title;
}
@Override
public int size() {
return datasource.getItemCount(seriesIndex);
}
@Override
public Number getX(int index) {
return datasource.getX(seriesIndex, index);
}
@Override
public Number getY(int index) {
return datasource.getY(seriesIndex, index);
}
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/ListViewActivity.java 0000664 0000000 0000000 00000011207 12711435674 0030474 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.content.Context;
import android.graphics.Color;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import com.androidplot.Plot;
import com.androidplot.Series;
import com.androidplot.ui.SeriesAndFormatter;
import com.androidplot.util.PixelUtils;
import com.androidplot.xy.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class ListViewActivity extends Activity {
private static final int NUM_PLOTS = 10;
private static final int NUM_POINTS_PER_SERIES = 10;
private static final int NUM_SERIES_PER_PLOT = 5;
private ListView lv;
private List>> seriesData = new ArrayList<>(NUM_PLOTS);
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.listview_example);
PixelUtils.init(this);
generateData();
lv = (ListView) findViewById(R.id.listView1);
lv.setAdapter(new MyViewAdapter(getApplicationContext(), R.layout.listview_example_item, null));
}
protected void generateData() {
Random generator = new Random();
for(int i = 0; i < NUM_PLOTS; i++) {
List> seriesList
= new ArrayList<>(NUM_SERIES_PER_PLOT);
for (int k = 0; k < NUM_SERIES_PER_PLOT; k++) {
ArrayList nums = new ArrayList<>();
for (int j = 0; j < NUM_POINTS_PER_SERIES; j++) {
nums.add(generator.nextFloat());
}
double rl = Math.random();
double gl = Math.random();
double bl = Math.random();
double rp = Math.random();
double gp = Math.random();
double bp = Math.random();
LineAndPointFormatter lpf = new LineAndPointFormatter(
Color.rgb(new Double(rl * 255).intValue(),
new Double(gl * 255).intValue(), new Double(bl * 255).intValue()),
Color.rgb(new Double(rp * 255).intValue(),
new Double(gp * 255).intValue(), new Double(bp * 255).intValue()),
null, null);
// for fun, configure interpolation on the formatter:
lpf.setInterpolationParams(
new CatmullRomInterpolator.Params(20, CatmullRomInterpolator.Type.Centripetal));
seriesList.add(new SeriesAndFormatter(
new SimpleXYSeries(nums, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "S" + k),
lpf));
}
seriesData.add(seriesList);
}
}
class MyViewAdapter extends ArrayAdapter {
public MyViewAdapter(Context context, int resId, List views) {
super(context, resId, views);
}
@Override
public int getCount() {
return NUM_PLOTS;
}
@Override
public View getView(int pos, View convertView, ViewGroup parent) {
LayoutInflater inf = (LayoutInflater) getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View v = convertView;
if (v == null) {
v = inf.inflate(R.layout.listview_example_item, parent, false);
}
Plot p = (XYPlot) v.findViewById(R.id.xyplot);
p.clear();
p.setTitle("plot" + pos);
List> thisSeriesList = seriesData.get(pos);
for(SeriesAndFormatter sf : thisSeriesList) {
p.addSeries(sf.getSeries(), sf.getFormatter());
}
p.redraw();
return v;
}
}
} androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/MainActivity.java 0000664 0000000 0000000 00000014574 12711435674 0027624 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import com.crittercism.app.Crittercism;
public class MainActivity extends Activity {
private static final String TAG = MainActivity.class.getName();
// DO *NOT* CHANGE THIS LINE! (CI-MATCH-POPULATE)
private static final String CRITTERCISM_APP_ID = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if(CRITTERCISM_APP_ID != null) {
Log.d(TAG, "Crittercism initialized.");
Crittercism.initialize(getApplicationContext(), CRITTERCISM_APP_ID);
}
setContentView(R.layout.main);
Button startScatterPlotExButton = (Button) findViewById(R.id.startScatterExButton);
startScatterPlotExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, ScatterPlotActivity.class));
}
});
Button startSimplePieExButton = (Button) findViewById(R.id.startSimplePieExButton);
startSimplePieExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, SimplePieChartActivity.class));
}
});
Button startDynamicXYExButton = (Button)findViewById(R.id.startDynamicXYExButton);
startDynamicXYExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, DynamicXYPlotActivity.class));
}
});
Button startCandlestickExButton = (Button) findViewById(R.id.startCandlestickExButton);
startCandlestickExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, CandlestickChartActivity.class));
}
});
Button startSimpleXYExButton = (Button) findViewById(R.id.startSimpleXYExButton);
startSimpleXYExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, SimpleXYPlotActivity.class));
}
});
Button startBarPlotExButton = (Button) findViewById(R.id.startBarPlotExButton);
startBarPlotExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, BarPlotExampleActivity.class));
}
});
Button startOrSensorExButton = (Button) findViewById(R.id.startOrSensorExButton);
startOrSensorExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, OrientationSensorExampleActivity.class));
}
});
Button startTimeSeriesExButon = (Button)findViewById(R.id.startTimeSeriesExButton);
startTimeSeriesExButon.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, TimeSeriesActivity.class));
}
});
Button startStepChartExButton = (Button)findViewById(R.id.startStepChartExButton);
startStepChartExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, StepChartExampleActivity.class));
}
});
Button startScrollZoomExButton = (Button)findViewById(R.id.startScrollZoomButton);
startScrollZoomExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, TouchZoomExampleActivity.class));
}
});
Button startXyRegionExampleButton = (Button)findViewById(R.id.startXyRegionExampleButton);
startXyRegionExampleButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, XYRegionExampleActivity.class));
}
});
Button listViewExButton = (Button)findViewById(R.id.startXyListViewExButton);
listViewExButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, ListViewActivity.class));
}
});
Button startDualScaleExampleButton = (Button)findViewById(R.id.startDualScaleExampleButton);
startDualScaleExampleButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, DualScaleXYPlotExampleActivity.class));
}
});
Button startXYPlotWithBgImgExampleButton = (Button)findViewById(R.id.startXYPlotWithBgImgExample);
startXYPlotWithBgImgExampleButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, XYPlotWithBgImgActivity.class));
}
});
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/OrientationSensorExampleActivity.java 0000664 0000000 0000000 00000023362 12711435674 0033734 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.content.Context;
import android.graphics.Color;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.view.View;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import com.androidplot.Plot;
import com.androidplot.util.PlotStatistics;
import com.androidplot.util.Redrawer;
import com.androidplot.xy.*;
import java.text.DecimalFormat;
import java.util.Arrays;
// Monitor the phone's orientation sensor and plot the resulting azimuth pitch and roll values.
// See: http://developer.android.com/reference/android/hardware/SensorEvent.html
public class OrientationSensorExampleActivity extends Activity implements SensorEventListener
{
private static final int HISTORY_SIZE = 300; // number of points to plot in history
private SensorManager sensorMgr = null;
private Sensor orSensor = null;
private XYPlot aprLevelsPlot = null;
private XYPlot aprHistoryPlot = null;
private CheckBox hwAcceleratedCb;
private CheckBox showFpsCb;
//private SimpleXYSeries aprLevelsSeries = null;
private SimpleXYSeries aLvlSeries;
private SimpleXYSeries pLvlSeries;
private SimpleXYSeries rLvlSeries;
private SimpleXYSeries azimuthHistorySeries = null;
private SimpleXYSeries pitchHistorySeries = null;
private SimpleXYSeries rollHistorySeries = null;
private Redrawer redrawer;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.orientation_sensor_example);
// setup the APR Levels plot:
aprLevelsPlot = (XYPlot) findViewById(R.id.aprLevelsPlot);
aprLevelsPlot.setDomainBoundaries(-1, 1, BoundaryMode.FIXED);
aprLevelsPlot.getGraphWidget().getDomainTickLabelPaint().setColor(Color.TRANSPARENT);
aLvlSeries = new SimpleXYSeries("A");
pLvlSeries = new SimpleXYSeries("P");
rLvlSeries = new SimpleXYSeries("R");
aprLevelsPlot.addSeries(aLvlSeries,
new BarFormatter(Color.rgb(0, 200, 0), Color.rgb(0, 80, 0)));
aprLevelsPlot.addSeries(pLvlSeries,
new BarFormatter(Color.rgb(200, 0, 0), Color.rgb(0, 80, 0)));
aprLevelsPlot.addSeries(rLvlSeries,
new BarFormatter(Color.rgb(0, 0, 200), Color.rgb(0, 80, 0)));
aprLevelsPlot.setDomainStepValue(3);
aprLevelsPlot.setTicksPerRangeLabel(3);
// per the android documentation, the minimum and maximum readings we can get from
// any of the orientation sensors is -180 and 359 respectively so we will fix our plot's
// boundaries to those values. If we did not do this, the plot would auto-range which
// can be visually confusing in the case of dynamic plots.
aprLevelsPlot.setRangeBoundaries(-180, 359, BoundaryMode.FIXED);
// update our domain and range axis labels:
aprLevelsPlot.setDomainLabel("");
aprLevelsPlot.getDomainLabelWidget().pack();
aprLevelsPlot.setRangeLabel("Angle (Degs)");
aprLevelsPlot.getRangeLabelWidget().pack();
aprLevelsPlot.setGridPadding(15, 0, 15, 0);
aprLevelsPlot.setRangeValueFormat(new DecimalFormat("#"));
// setup the APR History plot:
aprHistoryPlot = (XYPlot) findViewById(R.id.aprHistoryPlot);
azimuthHistorySeries = new SimpleXYSeries("Az.");
azimuthHistorySeries.useImplicitXVals();
pitchHistorySeries = new SimpleXYSeries("Pitch");
pitchHistorySeries.useImplicitXVals();
rollHistorySeries = new SimpleXYSeries("Roll");
rollHistorySeries.useImplicitXVals();
aprHistoryPlot.setRangeBoundaries(-180, 359, BoundaryMode.FIXED);
aprHistoryPlot.setDomainBoundaries(0, HISTORY_SIZE, BoundaryMode.FIXED);
aprHistoryPlot.addSeries(azimuthHistorySeries,
new LineAndPointFormatter(
Color.rgb(100, 100, 200), null, null, null));
aprHistoryPlot.addSeries(pitchHistorySeries,
new LineAndPointFormatter(
Color.rgb(100, 200, 100), null, null, null));
aprHistoryPlot.addSeries(rollHistorySeries,
new LineAndPointFormatter(
Color.rgb(200, 100, 100), null, null, null));
aprHistoryPlot.setDomainStepMode(XYStepMode.INCREMENT_BY_VAL);
aprHistoryPlot.setDomainStepValue(HISTORY_SIZE/10);
aprHistoryPlot.setTicksPerRangeLabel(3);
aprHistoryPlot.setDomainLabel("Sample Index");
aprHistoryPlot.getDomainLabelWidget().pack();
aprHistoryPlot.setRangeLabel("Angle (Degs)");
aprHistoryPlot.getRangeLabelWidget().pack();
aprHistoryPlot.setRangeValueFormat(new DecimalFormat("#"));
aprHistoryPlot.setDomainValueFormat(new DecimalFormat("#"));
// setup checkboxes:
hwAcceleratedCb = (CheckBox) findViewById(R.id.hwAccelerationCb);
final PlotStatistics levelStats = new PlotStatistics(1000, false);
final PlotStatistics histStats = new PlotStatistics(1000, false);
aprLevelsPlot.addListener(levelStats);
aprHistoryPlot.addListener(histStats);
hwAcceleratedCb.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
if(b) {
aprLevelsPlot.setLayerType(View.LAYER_TYPE_NONE, null);
aprHistoryPlot.setLayerType(View.LAYER_TYPE_NONE, null);
} else {
aprLevelsPlot.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
aprHistoryPlot.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
}
}
});
showFpsCb = (CheckBox) findViewById(R.id.showFpsCb);
showFpsCb.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
levelStats.setAnnotatePlotEnabled(b);
histStats.setAnnotatePlotEnabled(b);
}
});
// get a ref to the BarRenderer so we can make some changes to it:
BarRenderer barRenderer = (BarRenderer) aprLevelsPlot.getRenderer(BarRenderer.class);
if(barRenderer != null) {
// make our bars a little thicker than the default so they can be seen better:
barRenderer.setBarWidth(25);
}
// register for orientation sensor events:
sensorMgr = (SensorManager) getApplicationContext().getSystemService(Context.SENSOR_SERVICE);
for (Sensor sensor : sensorMgr.getSensorList(Sensor.TYPE_ORIENTATION)) {
if (sensor.getType() == Sensor.TYPE_ORIENTATION) {
orSensor = sensor;
}
}
// if we can't access the orientation sensor then exit:
if (orSensor == null) {
System.out.println("Failed to attach to orSensor.");
cleanup();
}
sensorMgr.registerListener(this, orSensor, SensorManager.SENSOR_DELAY_UI);
redrawer = new Redrawer(
Arrays.asList(new Plot[]{aprHistoryPlot, aprLevelsPlot}),
100, false);
}
@Override
public void onResume() {
super.onResume();
redrawer.start();
}
@Override
public void onPause() {
redrawer.pause();
super.onPause();
}
@Override
public void onDestroy() {
redrawer.finish();
super.onDestroy();
}
private void cleanup() {
// aunregister with the orientation sensor before exiting:
sensorMgr.unregisterListener(this);
finish();
}
// Called whenever a new orSensor reading is taken.
@Override
public synchronized void onSensorChanged(SensorEvent sensorEvent) {
// update level data:
aLvlSeries.setModel(Arrays.asList(
new Number[]{sensorEvent.values[0]}),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
pLvlSeries.setModel(Arrays.asList(
new Number[]{sensorEvent.values[1]}),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
rLvlSeries.setModel(Arrays.asList(
new Number[]{sensorEvent.values[2]}),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
// get rid the oldest sample in history:
if (rollHistorySeries.size() > HISTORY_SIZE) {
rollHistorySeries.removeFirst();
pitchHistorySeries.removeFirst();
azimuthHistorySeries.removeFirst();
}
// add the latest history sample:
azimuthHistorySeries.addLast(null, sensorEvent.values[0]);
pitchHistorySeries.addLast(null, sensorEvent.values[1]);
rollHistorySeries.addLast(null, sensorEvent.values[2]);
}
@Override
public void onAccuracyChanged(Sensor sensor, int i) {
// Not interested in this event
}
} androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/ScatterPlotActivity.java 0000664 0000000 0000000 00000005545 12711435674 0031202 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.os.Bundle;
import com.androidplot.xy.*;
/**
* A scatter plot
*/
public class ScatterPlotActivity extends Activity
{
private XYPlot plot;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.scatter_plot_example);
// initialize our XYPlot reference:
plot = (XYPlot) findViewById(R.id.plot);
XYSeries series1 = generateScatter("series1", 80, new RectRegion(10, 50, 10, 50));
XYSeries series2 = generateScatter("series2", 80, new RectRegion(30, 70, 30, 70));
plot.setDomainBoundaries(0, 80, BoundaryMode.FIXED);
plot.setRangeBoundaries(0, 80, BoundaryMode.FIXED);
// create formatters to use for drawing a series using LineAndPointRenderer
// and configure them from xml:
LineAndPointFormatter series1Format = new LineAndPointFormatter();
series1Format.configure(getApplicationContext(),
R.xml.point_formatter);
LineAndPointFormatter series2Format = new LineAndPointFormatter();
series2Format.configure(getApplicationContext(),
R.xml.point_formatter_2);
// add each series to the xyplot:
plot.addSeries(series1, series1Format);
plot.addSeries(series2, series2Format);
// reduce the number of range labels
plot.setTicksPerRangeLabel(3);
// rotate domain labels 45 degrees to make them more compact horizontally:
plot.getGraphWidget().setDomainLabelOrientation(-45);
}
/**
* Generate a XYSeries of random points within a specified region
* @param title
* @param numPoints
* @param region
* @return
*/
private XYSeries generateScatter(String title, int numPoints, RectRegion region) {
SimpleXYSeries series = new SimpleXYSeries(title);
for(int i = 0; i < numPoints; i++) {
series.addLast(
region.getMinX().doubleValue() + (Math.random() * region.getWidth().doubleValue()),
region.getMinY().doubleValue() + (Math.random() * region.getHeight().doubleValue())
);
}
return series;
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/SimplePieChartActivity.java 0000664 0000000 0000000 00000010747 12711435674 0031607 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.graphics.*;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.widget.SeekBar;
import android.widget.TextView;
import com.androidplot.pie.PieChart;
import com.androidplot.pie.PieRenderer;
import com.androidplot.pie.Segment;
import com.androidplot.pie.SegmentFormatter;
/**
* The simplest possible example of using AndroidPlot to plot some data.
*/
public class SimplePieChartActivity extends Activity
{
private TextView donutSizeTextView;
private SeekBar donutSizeSeekBar;
private PieChart pie;
private Segment s1;
private Segment s2;
private Segment s3;
private Segment s4;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.pie_chart);
// initialize our XYPlot reference:
pie = (PieChart) findViewById(R.id.mySimplePieChart);
// detect segment clicks:
pie.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View view, MotionEvent motionEvent) {
PointF click = new PointF(motionEvent.getX(), motionEvent.getY());
if(pie.getPieWidget().containsPoint(click)) {
Segment segment = pie.getRenderer(PieRenderer.class).getContainingSegment(click);
if(segment != null) {
// handle the segment click...for now, just print
// the clicked segment's title to the console:
System.out.println("Clicked Segment: " + segment.getTitle());
}
}
return false;
}
});
donutSizeSeekBar = (SeekBar) findViewById(R.id.donutSizeSeekBar);
donutSizeSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
@Override
public void onProgressChanged(SeekBar seekBar, int i, boolean b) {}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {}
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
pie.getRenderer(PieRenderer.class).setDonutSize(seekBar.getProgress()/100f,
PieRenderer.DonutMode.PERCENT);
pie.redraw();
updateDonutText();
}
});
donutSizeTextView = (TextView) findViewById(R.id.donutSizeTextView);
updateDonutText();
s1 = new Segment("s1", 10);
s2 = new Segment("s2", 1);
s3 = new Segment("s3", 10);
s4 = new Segment("s4", 10);
EmbossMaskFilter emf = new EmbossMaskFilter(
new float[]{1, 1, 1}, 0.4f, 10, 8.2f);
SegmentFormatter sf1 = new SegmentFormatter();
sf1.configure(getApplicationContext(), R.xml.pie_segment_formatter1);
sf1.getFillPaint().setMaskFilter(emf);
SegmentFormatter sf2 = new SegmentFormatter();
sf2.configure(getApplicationContext(), R.xml.pie_segment_formatter2);
sf2.getFillPaint().setMaskFilter(emf);
SegmentFormatter sf3 = new SegmentFormatter();
sf3.configure(getApplicationContext(), R.xml.pie_segment_formatter3);
sf3.getFillPaint().setMaskFilter(emf);
SegmentFormatter sf4 = new SegmentFormatter();
sf4.configure(getApplicationContext(), R.xml.pie_segment_formatter4);
sf4.getFillPaint().setMaskFilter(emf);
pie.addSeries(s1, sf1);
pie.addSeries(s2, sf2);
pie.addSeries(s3, sf3);
pie.addSeries(s4, sf4);
pie.getBorderPaint().setColor(Color.TRANSPARENT);
pie.getBackgroundPaint().setColor(Color.TRANSPARENT);
}
protected void updateDonutText() {
donutSizeTextView.setText(donutSizeSeekBar.getProgress() + "%");
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/SimpleXYPlotActivity.java 0000664 0000000 0000000 00000007407 12711435674 0031306 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.graphics.DashPathEffect;
import android.os.Bundle;
import com.androidplot.util.PixelUtils;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.xy.XYSeries;
import com.androidplot.xy.*;
import java.text.FieldPosition;
import java.text.Format;
import java.text.NumberFormat;
import java.text.ParsePosition;
import java.util.Arrays;
/**
* A simple XYPlot
*/
public class SimpleXYPlotActivity extends Activity
{
private XYPlot plot;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.simple_xy_plot_example);
// initialize our XYPlot reference:
plot = (XYPlot) findViewById(R.id.plot);
// create a couple arrays of y-values to plot:
Number[] series1Numbers = {1, 4, 2, 8, 4, 16, 8, 32, 16, 64};
Number[] series2Numbers = {5, 2, 10, 5, 20, 10, 40, 20, 80, 40};
// turn the above arrays into XYSeries':
// (Y_VALS_ONLY means use the element index as the x value)
XYSeries series1 = new SimpleXYSeries(Arrays.asList(series1Numbers),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Series1");
XYSeries series2 = new SimpleXYSeries(Arrays.asList(series2Numbers),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Series2");
// create formatters to use for drawing a series using LineAndPointRenderer
// and configure them from xml:
LineAndPointFormatter series1Format = new LineAndPointFormatter();
series1Format.setPointLabelFormatter(new PointLabelFormatter());
series1Format.configure(getApplicationContext(),
R.xml.line_point_formatter_with_labels);
LineAndPointFormatter series2Format = new LineAndPointFormatter();
series2Format.setPointLabelFormatter(new PointLabelFormatter());
series2Format.configure(getApplicationContext(),
R.xml.line_point_formatter_with_labels_2);
// add an "dash" effect to the series2 line:
series2Format.getLinePaint().setPathEffect(
new DashPathEffect(new float[] {
// always use DP when specifying pixel sizes, to keep things consistent across devices:
PixelUtils.dpToPix(20),
PixelUtils.dpToPix(15)}, 0));
// just for fun, add some smoothing to the lines:
// see: http://androidplot.com/smooth-curves-and-androidplot/
series1Format.setInterpolationParams(
new CatmullRomInterpolator.Params(10, CatmullRomInterpolator.Type.Centripetal));
series2Format.setInterpolationParams(
new CatmullRomInterpolator.Params(10, CatmullRomInterpolator.Type.Centripetal));
// add a new series' to the xyplot:
plot.addSeries(series1, series1Format);
plot.addSeries(series2, series2Format);
// reduce the number of range labels
plot.setTicksPerRangeLabel(3);
// rotate domain labels 45 degrees to make them more compact horizontally:
plot.getGraphWidget().setDomainLabelOrientation(-45);
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/StepChartExampleActivity.java 0000664 0000000 0000000 00000010277 12711435674 0032145 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.graphics.*;
import android.os.Bundle;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.xy.XYSeries;
import com.androidplot.xy.*;
import java.text.DecimalFormat;
import java.text.FieldPosition;
import java.text.Format;
import java.text.ParsePosition;
import java.util.Arrays;
public class StepChartExampleActivity extends Activity
{
private XYPlot mySimpleXYPlot;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.step_chart_example);
// initialize our XYPlot reference:
mySimpleXYPlot = (XYPlot) findViewById(R.id.stepChartExamplePlot);
// y-vals to plot:
Number[] series1Numbers = {1, 2, 3, 4, 2, 3, 4, 2, 2, 2, 3, 4, 2, 3, 2, 2};
// create our series from our array of nums:
XYSeries series2 = new SimpleXYSeries(
Arrays.asList(series1Numbers),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY,
"Thread #1");
// Create a getFormatter to use for drawing a series using LineAndPointRenderer:
LineAndPointFormatter series1Format = new LineAndPointFormatter(
Color.rgb(0, 100, 0), // line color
Color.rgb(0, 100, 0), // point color
Color.rgb(100, 200, 0), null); // fill color
// setup our line fill paint to be a slightly transparent gradient:
Paint lineFill = new Paint();
lineFill.setAlpha(200);
lineFill.setShader(new LinearGradient(0, 0, 0, 250, Color.WHITE, Color.BLUE, Shader.TileMode.MIRROR));
StepFormatter stepFormatter = new StepFormatter(Color.rgb(0, 0,0), Color.BLUE);
stepFormatter.getLinePaint().setStrokeWidth(1);
stepFormatter.getLinePaint().setAntiAlias(false);
stepFormatter.setFillPaint(lineFill);
mySimpleXYPlot.addSeries(series2, stepFormatter);
// adjust the domain/range ticks to make more sense; label per tick for range and label per 5 ticks domain:
mySimpleXYPlot.setRangeStep(XYStepMode.INCREMENT_BY_VAL, 1);
mySimpleXYPlot.setDomainStep(XYStepMode.INCREMENT_BY_VAL, 1);
mySimpleXYPlot.setTicksPerRangeLabel(1);
mySimpleXYPlot.setTicksPerDomainLabel(5);
// get rid of decimal points in our domain labels:
mySimpleXYPlot.setDomainValueFormat(new DecimalFormat("0"));
// create a custom getFormatter to draw our state names as range tick labels:
mySimpleXYPlot.setRangeValueFormat(new Format() {
@Override
public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
Number num = (Number) obj;
switch(num.intValue()) {
case 1:
toAppendTo.append("Init");
break;
case 2:
toAppendTo.append("Idle");
break;
case 3:
toAppendTo.append("Recv");
break;
case 4:
toAppendTo.append("Send");
break;
default:
toAppendTo.append("Unknown");
break;
}
return toAppendTo;
}
@Override
public Object parseObject(String source, ParsePosition pos) {
return null;
}
});
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/TimeSeriesActivity.java 0000664 0000000 0000000 00000012117 12711435674 0031000 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.graphics.*;
import android.os.Bundle;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.xy.XYSeries;
import com.androidplot.xy.*;
import java.text.*;
import java.util.Arrays;
import java.util.Date;
public class TimeSeriesActivity extends Activity
{
private XYPlot plot1;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.time_series_example);
plot1 = (XYPlot) findViewById(R.id.plot1);
Number[] numSightings = {5, 8, 9, 2, 5};
// an array of years in milliseconds:
Number[] years = {
978307200, // 2001
1009843200, // 2002
1041379200, // 2003
1072915200, // 2004
1104537600 // 2005
};
// create our series from our array of nums:
XYSeries series2 = new SimpleXYSeries(
Arrays.asList(years),
Arrays.asList(numSightings),
"Sightings in USA");
plot1.getGraphWidget().getGridBackgroundPaint().setColor(Color.WHITE);
plot1.getGraphWidget().getDomainGridLinePaint().setColor(Color.BLACK);
plot1.getGraphWidget().getDomainGridLinePaint().
setPathEffect(new DashPathEffect(new float[]{1, 1}, 1));
plot1.getGraphWidget().getRangeGridLinePaint().setColor(Color.BLACK);
plot1.getGraphWidget().getRangeGridLinePaint().
setPathEffect(new DashPathEffect(new float[]{1, 1}, 1));
plot1.getGraphWidget().getDomainOriginLinePaint().setColor(Color.BLACK);
plot1.getGraphWidget().getRangeOriginLinePaint().setColor(Color.BLACK);
// Create a getFormatter to use for drawing a series using LineAndPointRenderer:
LineAndPointFormatter series1Format = new LineAndPointFormatter(
Color.rgb(0, 100, 0), // line color
Color.rgb(0, 100, 0), // point color
Color.rgb(100, 200, 0), null); // fill color
// setup our line fill paint to be a slightly transparent gradient:
Paint lineFill = new Paint();
lineFill.setAlpha(200);
// ugly usage of LinearGradient. unfortunately there's no way to determine the actual size of
// a View from within onCreate. one alternative is to specify a dimension in resources
// and use that accordingly. at least then the values can be customized for the device type and orientation.
lineFill.setShader(new LinearGradient(0, 0, 200, 200, Color.WHITE, Color.GREEN, Shader.TileMode.CLAMP));
LineAndPointFormatter formatter =
new LineAndPointFormatter(Color.rgb(0, 0,0), Color.BLUE, Color.RED, null);
formatter.setFillPaint(lineFill);
plot1.getGraphWidget().setPaddingRight(2);
plot1.addSeries(series2, formatter);
// draw a domain tick for each year:
plot1.setDomainStep(XYStepMode.SUBDIVIDE, years.length);
// customize our domain/range labels
plot1.setDomainLabel("Year");
plot1.setRangeLabel("# of Sightings");
// get rid of decimal points in our range labels:
plot1.setRangeValueFormat(new DecimalFormat("0"));
plot1.setDomainValueFormat(new Format() {
// create a simple date format that draws on the year portion of our timestamp.
// see http://download.oracle.com/javase/1.4.2/docs/api/java/text/SimpleDateFormat.html
// for a full description of SimpleDateFormat.
private SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");
@Override
public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
// because our timestamps are in seconds and SimpleDateFormat expects milliseconds
// we multiply our timestamp by 1000:
long timestamp = ((Number) obj).longValue() * 1000;
Date date = new Date(timestamp);
return dateFormat.format(date, toAppendTo, pos);
}
@Override
public Object parseObject(String source, ParsePosition pos) {
return null;
}
});
// by default, AndroidPlot displays developer guides to aid in laying out your plot.
// To get rid of them call disableAllMarkup():
//plot1.disableAllMarkup();
}
} androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/TouchZoomExampleActivity.java 0000664 0000000 0000000 00000020063 12711435674 0032171 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import java.text.DecimalFormat;
import java.util.Random;
import android.app.Activity;
import android.graphics.Color;
import android.graphics.PointF;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.Button;
import com.androidplot.Plot;
import com.androidplot.xy.BoundaryMode;
import com.androidplot.xy.LineAndPointFormatter;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.xy.XYPlot;
/***********************************
* @author David Buezas (david.buezas at gmail.com)
* Feel free to copy, modify and use the source as it fits you.
* 09/27/2012 nfellows - updated for 0.5.1 and made a few simplifications
*/
public class TouchZoomExampleActivity extends Activity implements OnTouchListener {
private static final int SERIES_SIZE = 200;
private XYPlot mySimpleXYPlot;
private Button resetButton;
private SimpleXYSeries[] series = null;
private PointF minXY;
private PointF maxXY;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.touch_zoom_example);
resetButton = (Button) findViewById(R.id.resetButton);
resetButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
minXY.x = series[0].getX(0).floatValue();
maxXY.x = series[3].getX(series[3].size() - 1).floatValue();
mySimpleXYPlot.setDomainBoundaries(minXY.x, maxXY.x, BoundaryMode.FIXED);
// pre 0.5.1 users should use postRedraw() instead.
mySimpleXYPlot.redraw();
}
});
mySimpleXYPlot = (XYPlot) findViewById(R.id.plot);
mySimpleXYPlot.setOnTouchListener(this);
mySimpleXYPlot.getGraphWidget().setTicksPerRangeLabel(2);
mySimpleXYPlot.getGraphWidget().setTicksPerDomainLabel(2);
mySimpleXYPlot.getGraphWidget().getBackgroundPaint().setColor(Color.TRANSPARENT);
mySimpleXYPlot.getGraphWidget().setRangeValueFormat(
new DecimalFormat("#####"));
mySimpleXYPlot.getGraphWidget().setDomainValueFormat(
new DecimalFormat("#####.#"));
mySimpleXYPlot.getGraphWidget().setRangeTickLabelWidth(25);
mySimpleXYPlot.setRangeLabel("");
mySimpleXYPlot.setDomainLabel("");
mySimpleXYPlot.setBorderStyle(Plot.BorderStyle.NONE, null, null);
//mySimpleXYPlot.disableAllMarkup();
series = new SimpleXYSeries[4];
int scale = 1;
for (int i = 0; i < 4; i++, scale *= 5) {
series[i] = new SimpleXYSeries("S" + i);
populateSeries(series[i], scale);
}
mySimpleXYPlot.addSeries(series[3],
new LineAndPointFormatter(Color.rgb(50, 0, 0), null,
Color.rgb(100, 0, 0), null));
mySimpleXYPlot.addSeries(series[2],
new LineAndPointFormatter(Color.rgb(50, 50, 0), null,
Color.rgb(100, 100, 0), null));
mySimpleXYPlot.addSeries(series[1],
new LineAndPointFormatter(Color.rgb(0, 50, 0), null,
Color.rgb(0, 100, 0), null));
mySimpleXYPlot.addSeries(series[0],
new LineAndPointFormatter(Color.rgb(0, 0, 0), null,
Color.rgb(0, 0, 150), null));
mySimpleXYPlot.redraw();
mySimpleXYPlot.calculateMinMaxVals();
minXY = new PointF(mySimpleXYPlot.getCalculatedMinX().floatValue(),
mySimpleXYPlot.getCalculatedMinY().floatValue());
maxXY = new PointF(mySimpleXYPlot.getCalculatedMaxX().floatValue(),
mySimpleXYPlot.getCalculatedMaxY().floatValue());
}
private void populateSeries(SimpleXYSeries series, int max) {
Random r = new Random();
for(int i = 0; i < SERIES_SIZE; i++) {
series.addLast(i, r.nextInt(max));
}
}
// Definition of the touch states
static final int NONE = 0;
static final int ONE_FINGER_DRAG = 1;
static final int TWO_FINGERS_DRAG = 2;
int mode = NONE;
PointF firstFinger;
float distBetweenFingers;
boolean stopThread = false;
@Override
public boolean onTouch(View arg0, MotionEvent event) {
switch (event.getAction() & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: // Start gesture
firstFinger = new PointF(event.getX(), event.getY());
mode = ONE_FINGER_DRAG;
stopThread = true;
break;
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_POINTER_UP:
mode = NONE;
break;
case MotionEvent.ACTION_POINTER_DOWN: // second finger
distBetweenFingers = spacing(event);
// the distance check is done to avoid false alarms
if (distBetweenFingers > 5f) {
mode = TWO_FINGERS_DRAG;
}
break;
case MotionEvent.ACTION_MOVE:
if (mode == ONE_FINGER_DRAG) {
PointF oldFirstFinger = firstFinger;
firstFinger = new PointF(event.getX(), event.getY());
scroll(oldFirstFinger.x - firstFinger.x);
mySimpleXYPlot.setDomainBoundaries(minXY.x, maxXY.x,
BoundaryMode.FIXED);
mySimpleXYPlot.redraw();
} else if (mode == TWO_FINGERS_DRAG) {
float oldDist = distBetweenFingers;
distBetweenFingers = spacing(event);
zoom(oldDist / distBetweenFingers);
mySimpleXYPlot.setDomainBoundaries(minXY.x, maxXY.x,
BoundaryMode.FIXED);
mySimpleXYPlot.redraw();
}
break;
}
return true;
}
private void zoom(float scale) {
float domainSpan = maxXY.x - minXY.x;
float domainMidPoint = maxXY.x - domainSpan / 2.0f;
float offset = domainSpan * scale / 2.0f;
minXY.x = domainMidPoint - offset;
maxXY.x = domainMidPoint + offset;
minXY.x = Math.min(minXY.x, series[3].getX(series[3].size() - 3)
.floatValue());
maxXY.x = Math.max(maxXY.x, series[0].getX(1).floatValue());
clampToDomainBounds(domainSpan);
}
private void scroll(float pan) {
float domainSpan = maxXY.x - minXY.x;
float step = domainSpan / mySimpleXYPlot.getWidth();
float offset = pan * step;
minXY.x = minXY.x + offset;
maxXY.x = maxXY.x + offset;
clampToDomainBounds(domainSpan);
}
private void clampToDomainBounds(float domainSpan) {
float leftBoundary = series[0].getX(0).floatValue();
float rightBoundary = series[3].getX(series[3].size() - 1).floatValue();
// enforce left scroll boundary:
if (minXY.x < leftBoundary) {
minXY.x = leftBoundary;
maxXY.x = leftBoundary + domainSpan;
} else if (maxXY.x > series[3].getX(series[3].size() - 1).floatValue()) {
maxXY.x = rightBoundary;
minXY.x = rightBoundary - domainSpan;
}
}
private float spacing(MotionEvent event) {
float x = event.getX(0) - event.getX(1);
float y = event.getY(0) - event.getY(1);
return (float) Math.hypot(x, y);
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/XYPlotWithBgImgActivity.java 0000664 0000000 0000000 00000012116 12711435674 0031667 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.graphics.*;
import android.os.Bundle;
import android.view.View;
import android.widget.ToggleButton;
import com.androidplot.xy.*;
import java.text.DecimalFormat;
import java.util.Arrays;
public class XYPlotWithBgImgActivity extends Activity {
private static final String TAG = XYPlotWithBgImgActivity.class.getName();
private int SERIES_LEN = 50;
private Shader WHITE_SHADER = new LinearGradient(1, 1, 1, 1, Color.WHITE, Color.WHITE, Shader.TileMode.REPEAT);
private XYPlot plot;
private SimpleXYSeries series;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.xy_plot_with_bq_img_example);
plot = (XYPlot) findViewById(R.id.graph_metrics);
//For debugging.
//plot.setMarkupEnabled(true);
// Format Graph
plot.getGraphWidget().getBackgroundPaint().setColor(Color.TRANSPARENT);
plot.getGraphWidget().getGridBackgroundPaint().setShader(WHITE_SHADER);
plot.getGraphWidget().getDomainGridLinePaint().setColor(Color.BLACK);
plot.getGraphWidget().getDomainGridLinePaint().setPathEffect(new DashPathEffect(new float[]{3, 3}, 1));
plot.getGraphWidget().getRangeGridLinePaint().setColor(Color.BLACK);
plot.getGraphWidget().getRangeGridLinePaint().setPathEffect(new DashPathEffect(new float[]{3, 3}, 1));
plot.getGraphWidget().getDomainOriginLinePaint().setColor(Color.BLACK);
plot.getGraphWidget().getRangeOriginLinePaint().setColor(Color.BLACK);
//plot.getGraphWidget().setMarginTop(10);
// Customize domain and range labels.
plot.setDomainLabel("x-vals");
plot.setRangeLabel("y-vals");
plot.setRangeValueFormat(new DecimalFormat("0"));
// Make the domain and range step correctly
plot.setRangeBoundaries(40, 160, BoundaryMode.FIXED);
plot.setRangeStep(XYStepMode.INCREMENT_BY_VAL, 20);
plot.setDomainStep(XYStepMode.INCREMENT_BY_VAL, 60);
plot.setTicksPerDomainLabel(2);
series = (SimpleXYSeries) getSeries();
LineAndPointFormatter lpFormat = new LineAndPointFormatter(
Color.BLACK,
Color.BLACK,
null, // No fill
new PointLabelFormatter(Color.TRANSPARENT) // Don't show text at points
);
plot.addSeries(series, lpFormat);
plot.redraw();
}
private SimpleXYSeries getSeries() {
Integer[] xVals = new Integer[SERIES_LEN];
Integer[] yVals = new Integer[SERIES_LEN];
xVals[0] = 0;
yVals[0] = 0;
for (int i = 1; i < SERIES_LEN; i += 1){
xVals[i] = xVals[i-1] + (int)(Math.random() * i);
yVals[i] = (int)(Math.random() * 140);
}
return new SimpleXYSeries(
Arrays.asList(xVals),
Arrays.asList(yVals),
"Sample Series");
}
public void onGraphStyleToggle(View v) {
boolean styleOn = ((ToggleButton) v).isChecked();
/*RectF graphRect = plot.getGraphWidget().getGridRect();
float segmentSize = 1.0f/6.0f;
LinearGradient lg = new LinearGradient(
0,
graphRect.top,
0,
graphRect.bottom,
new int[]{
Color.RED,
Color.YELLOW,
Color.GREEN,
Color.WHITE},
new float[]{
0,
segmentSize*2,
segmentSize*3,
segmentSize*5
},
Shader.TileMode.REPEAT
);
plot.getGraphWidget().getGridBackgroundPaint().setShader(lg);*/
RectF rect = plot.getGraphWidget().getGridDimensions().marginatedRect;
BitmapShader myShader = new BitmapShader(
Bitmap.createScaledBitmap(
BitmapFactory.decodeResource(
getResources(),
R.drawable.graph_background),
1,
(int) rect.height(),
false),
Shader.TileMode.REPEAT,
Shader.TileMode.REPEAT);
Matrix m = new Matrix();
m.setTranslate(rect.left, rect.top);
myShader.setLocalMatrix(m);
if (styleOn)
plot.getGraphWidget().getGridBackgroundPaint().setShader(
myShader);
else
plot.getGraphWidget().getGridBackgroundPaint().setShader(WHITE_SHADER);
plot.redraw();
}
}
androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/XYRegionExampleActivity.java 0000664 0000000 0000000 00000041177 12711435674 0031757 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos;
import android.app.Activity;
import android.graphics.Color;
import android.graphics.DashPathEffect;
import android.graphics.Paint;
import android.os.Bundle;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import com.androidplot.util.PixelUtils;
import com.androidplot.xy.XYSeries;
import com.androidplot.ui.*;
import com.androidplot.xy.*;
import java.text.DecimalFormat;
import java.text.FieldPosition;
import java.text.NumberFormat;
import java.text.ParsePosition;
import java.util.Arrays;
/**
* Demonstration of the usage of Marker and RectRegion.
*/
public class XYRegionExampleActivity extends Activity {
private static final float HOME_RUN_DIST = 325;
private static final int LINE_THICKNESS_DP = 2;
private static final int POINT_SIZE_DP = 6;
private XYPlot plot;
private final Number[] timHits = {105, 252, 220, 350, 12, 250, 353};
private final Number[] nickHits = {110, 191, 61, 371, 289, 101, 10};
private final Number[] joeHits = {25, 375, 364, 128, 178, 289, 346};
private final Number[] jamesHits = {250, 285, 295, 211, 311, 365, 241};
private LineAndPointFormatter timFormatter;
private LineAndPointFormatter nickFormatter;
private LineAndPointFormatter joeFormatter;
private LineAndPointFormatter jamesFormatter;
private XYSeries timSeries;
private XYSeries nickSeries;
private XYSeries joeSeries;
private XYSeries jamesSeries;
private RectRegion shortRegion;
private RectRegion warmupRegion;
private RectRegion homeRunRegion;
//private XYRegionFormatter rf1;
private XYRegionFormatter shortRegionFormatter;
private XYRegionFormatter warmupRegionFormatter;
private XYRegionFormatter homeRunRegionFormatter;
//private XYRegionFormatter rf5;
private CheckBox timCB;
private CheckBox nickCB;
private CheckBox joeCB;
private CheckBox jamesCB;
private CheckBox r2CheckBox;
private CheckBox r3CheckBox;
private CheckBox r4CheckBox;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.xyregion_example);
plot = (XYPlot) findViewById(R.id.xyRegionExamplePlot);
timCB = (CheckBox) findViewById(R.id.s1CheckBox);
timCB.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
onS1CheckBoxClicked();
}
});
nickCB = (CheckBox) findViewById(R.id.s2CheckBox);
nickCB.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
onS2CheckBoxClicked();
}
});
joeCB = (CheckBox) findViewById(R.id.s3CheckBox);
joeCB.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
onS3CheckBoxClicked();
}
});
jamesCB = (CheckBox) findViewById(R.id.s4CheckBox);
jamesCB.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
onS4CheckBoxClicked();
}
});
r2CheckBox = (CheckBox) findViewById(R.id.r2CheckBox);
r2CheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
onCheckBoxClicked(r2CheckBox, timFormatter, shortRegionFormatter, shortRegion);
}
});
r3CheckBox = (CheckBox) findViewById(R.id.r3CheckBox);
r3CheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
onCheckBoxClicked(r3CheckBox, nickFormatter, warmupRegionFormatter, warmupRegion);
}
});
r4CheckBox = (CheckBox) findViewById(R.id.r4CheckBox);
r4CheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
onCheckBoxClicked(r4CheckBox, nickFormatter, homeRunRegionFormatter, homeRunRegion);
}
});
seriesSetup();
markerSetup();
axisLabelSetup();
regionSetup();
makePlotPretty();
}
private void onS1CheckBoxClicked() {
if(timCB.isChecked()) {
plot.addSeries(timSeries, timFormatter);
r2CheckBox.setEnabled(true);
} else {
plot.removeSeries(timSeries);
r2CheckBox.setEnabled(false);
}
plot.redraw();
}
private void onS2CheckBoxClicked() {
if(nickCB.isChecked()) {
plot.addSeries(nickSeries, nickFormatter);
r3CheckBox.setEnabled(true);
r4CheckBox.setEnabled(true);
} else {
plot.removeSeries(nickSeries);
r3CheckBox.setEnabled(false);
r4CheckBox.setEnabled(false);
}
plot.redraw();
}
private void onS3CheckBoxClicked() {
if(joeCB.isChecked()) {
plot.addSeries(joeSeries, joeFormatter);
} else {
plot.removeSeries(joeSeries);
}
plot.redraw();
}
private void onS4CheckBoxClicked() {
if(jamesCB.isChecked()) {
plot.addSeries(jamesSeries, jamesFormatter);
} else {
plot.removeSeries(jamesSeries);
}
plot.redraw();
}
/**
* Processes a check box event
* @param cb The checkbox event origin
* @param lpf LineAndPointFormatter with which rr and rf are to be added/removed
* @param rf The XYRegionFormatter with which rr should be rendered
* @param rr The RectRegion to add/remove
*/
private void onCheckBoxClicked(CheckBox cb, LineAndPointFormatter lpf,
XYRegionFormatter rf, RectRegion rr) {
if(cb.isChecked()) {
lpf.removeRegion(rr);
} else {
lpf.addRegion(rr, rf);
}
}
/**
* Cleans up the plot's general layout and color scheme
*/
private void makePlotPretty() {
// use a 2x5 grid with room for 10 items:
plot.getLegendWidget().setTableModel(new DynamicTableModel(4, 2));
// add a semi-transparent black background to the legend
// so it's easier to see overlaid on top of our plot:
Paint bgPaint = new Paint();
bgPaint.setColor(Color.BLACK);
bgPaint.setStyle(Paint.Style.FILL);
bgPaint.setAlpha(40);
plot.getLegendWidget().setBackgroundPaint(bgPaint);
// adjust the padding of the legend widget to look a little nicer:
plot.getLegendWidget().setPadding(5, 5, 5, 5);
plot.setRangeValueFormat(new NumberFormat() {
@Override
public StringBuffer format(double value, StringBuffer buffer, FieldPosition field) {
return new StringBuffer(value + "'");
}
@Override
public StringBuffer format(long value, StringBuffer buffer, FieldPosition field) {
throw new UnsupportedOperationException("Not yet implemented.");
}
@Override
public Number parse(String string, ParsePosition position) {
throw new UnsupportedOperationException("Not yet implemented.");
}
});
plot.setDomainValueFormat(new DecimalFormat("#"));
plot.getLegendWidget().setWidth(PixelUtils.dpToPix(100), SizeLayoutType.FILL);
// adjust the legend size so there is enough room
// to draw the new legend grid:
//plot.getLegendWidget().getHeight().setLayoutType(SizeLayoutType.ABSOLUTE);
//plot.getLegendWidget().getWidth().setLayoutType(SizeLayoutType.ABSOLUTE);
//plot.getLegendWidget().setSize(
// new SizeMetrics(70, SizeLayoutType.ABSOLUTE, 80, SizeLayoutType.ABSOLUTE));
// reposition the grid so that it rests above the bottom-left
// edge of the graph widget:
plot.getLegendWidget().position(
125,
XLayoutStyle.ABSOLUTE_FROM_LEFT,
65,
YLayoutStyle.ABSOLUTE_FROM_TOP,
AnchorPosition.LEFT_TOP);
plot.getGraphWidget().setRangeTickLabelHorizontalOffset(-1);
// add enough space to ensure range value labels arent cut off on the left/right:
plot.getGraphWidget().setRangeTickLabelWidth(25);
// add enough space to make sure domain value labels arent cut off on the bottom:
plot.getGraphWidget().setDomainTickLabelWidth(15);
plot.getGraphWidget().setDomainTickLabelVerticalOffset(-6);
plot.setRangeBoundaries(0, BoundaryMode.FIXED, 500, BoundaryMode.FIXED);
}
/**
* Create 4 XYSeries from the values defined above add add them to the plot.
* Also add some arbitrary regions.
*/
private void seriesSetup() {
// TIM
timFormatter = new LineAndPointFormatter(
Color.rgb(100, 25, 20),
Color.rgb(100, 25, 20),
null, null);
timFormatter.getLinePaint().setStrokeWidth(PixelUtils.dpToPix(LINE_THICKNESS_DP));
timFormatter.getVertexPaint().setStrokeWidth(PixelUtils.dpToPix(POINT_SIZE_DP));
timSeries = new SimpleXYSeries(Arrays.asList(timHits),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Tim");
plot.addSeries(timSeries, timFormatter);
// SERIES #2:
nickFormatter = new LineAndPointFormatter(
Color.rgb(100, 25, 200),
Color.rgb(100, 25, 200),
null, null);
nickFormatter.getLinePaint().setStrokeWidth(PixelUtils.dpToPix(LINE_THICKNESS_DP));
nickFormatter.getVertexPaint().setStrokeWidth(PixelUtils.dpToPix(POINT_SIZE_DP));
nickSeries = new SimpleXYSeries(Arrays.asList(nickHits),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Nick");
plot.addSeries(nickSeries, nickFormatter);
// SERIES #3:
joeFormatter = new LineAndPointFormatter(
Color.rgb(200, 25, 200),
Color.rgb(200, 25, 200),
null, null);
joeFormatter.getLinePaint().setStrokeWidth(PixelUtils.dpToPix(LINE_THICKNESS_DP));
joeFormatter.getVertexPaint().setStrokeWidth(PixelUtils.dpToPix(POINT_SIZE_DP));
joeSeries = new SimpleXYSeries(Arrays.asList(joeHits),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Joe");
plot.addSeries(joeSeries, joeFormatter);
// SERIES #4:
jamesFormatter = new LineAndPointFormatter(
Color.rgb(220, 25, 20),
Color.rgb(220, 25, 20),
null, null);
jamesFormatter.getLinePaint().setStrokeWidth(PixelUtils.dpToPix(LINE_THICKNESS_DP));
jamesFormatter.getVertexPaint().setStrokeWidth(PixelUtils.dpToPix(POINT_SIZE_DP));
jamesSeries = new SimpleXYSeries(Arrays.asList(jamesHits),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY,"James");
plot.addSeries(jamesSeries, jamesFormatter);
plot.setRangeStep(XYStepMode.INCREMENT_BY_VAL, 100);
//plot.setTicksPerRangeLabel(1);
plot.setDomainStep(XYStepMode.INCREMENT_BY_VAL, 1);
}
/**
* Add some color coded regions to our axis labels.
*/
private void axisLabelSetup() {
// DOMAIN
plot.getGraphWidget().addDomainAxisValueLabelRegion(
Double.NEGATIVE_INFINITY, 2, new AxisValueLabelFormatter(Color.GRAY));
plot.getGraphWidget().addDomainAxisValueLabelRegion(
2, Double.POSITIVE_INFINITY, new AxisValueLabelFormatter(Color.WHITE));
// RANGE
plot.getGraphWidget().addRangeAxisValueLabelRegion(
Double.NEGATIVE_INFINITY, HOME_RUN_DIST, new AxisValueLabelFormatter(Color.RED));
plot.getGraphWidget().addRangeAxisValueLabelRegion(
HOME_RUN_DIST, Double.POSITIVE_INFINITY, new AxisValueLabelFormatter(Color.GREEN));
}
/**
* Add some markers to our plot.
*/
private void markerSetup() {
YValueMarker fenwayLfMarker = new YValueMarker(
380, // y-val to mark
"Fenway Park LF Wall", // marker label
new XPositionMetric( // object instance to set text positioning on the marker
PixelUtils.dpToPix(5), // 5dp offset
XLayoutStyle.ABSOLUTE_FROM_RIGHT), // offset origin
Color.BLUE, // line paint color
Color.BLUE); // text paint color
YValueMarker attRfMarker = new YValueMarker(
309, // y-val to mark
"ATT Park RF Wall", // marker label
new XPositionMetric( // object instance to set text positioning on the marker
PixelUtils.dpToPix(5), // 5dp offset
XLayoutStyle.ABSOLUTE_FROM_RIGHT), // offset origin
Color.CYAN, // line paint color
Color.CYAN); // text paint color
fenwayLfMarker.getTextPaint().setTextSize(PixelUtils.dpToPix(14));
attRfMarker.getTextPaint().setTextSize(PixelUtils.dpToPix(14));
DashPathEffect dpe = new DashPathEffect(
new float[]{PixelUtils.dpToPix(2), PixelUtils.dpToPix(2)}, 0);
fenwayLfMarker.getLinePaint().setPathEffect(dpe);
attRfMarker.getLinePaint().setPathEffect(dpe);
plot.addMarker(fenwayLfMarker);
plot.addMarker(attRfMarker);
}
/**
* Add some fill regions to our series data
*/
private void regionSetup() {
// and another region:
shortRegionFormatter = new XYRegionFormatter(Color.RED);
shortRegionFormatter.getPaint().setAlpha(75);
shortRegion = new RectRegion(2, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, HOME_RUN_DIST, "Short");
timFormatter.addRegion(shortRegion, shortRegionFormatter);
nickFormatter.addRegion(shortRegion, shortRegionFormatter);
joeFormatter.addRegion(shortRegion, shortRegionFormatter);
jamesFormatter.addRegion(shortRegion, shortRegionFormatter);
// the next three regions are horizontal regions with minY/maxY
// set to negative and positive infinity respectively.
warmupRegionFormatter = new XYRegionFormatter(Color.WHITE);
warmupRegionFormatter.getPaint().setAlpha(75);
warmupRegion = new RectRegion(0, 2, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, "Warmup");
timFormatter.addRegion(warmupRegion, warmupRegionFormatter);
nickFormatter.addRegion(warmupRegion, warmupRegionFormatter);
joeFormatter.addRegion(warmupRegion, warmupRegionFormatter);
jamesFormatter.addRegion(warmupRegion, warmupRegionFormatter);
homeRunRegionFormatter = new XYRegionFormatter(Color.GREEN);
homeRunRegionFormatter.getPaint().setAlpha(75);
homeRunRegion = new RectRegion(2, Double.POSITIVE_INFINITY, HOME_RUN_DIST, Double.POSITIVE_INFINITY, "H. Run");
timFormatter.addRegion(homeRunRegion, homeRunRegionFormatter);
nickFormatter.addRegion(homeRunRegion, homeRunRegionFormatter);
joeFormatter.addRegion(homeRunRegion, homeRunRegionFormatter);
jamesFormatter.addRegion(homeRunRegion, homeRunRegionFormatter);
nickFormatter.setFillDirection(FillDirection.RANGE_ORIGIN);
}
} androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/widget/ 0000775 0000000 0000000 00000000000 12711435674 0025630 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/java/com/androidplot/demos/widget/DemoAppWidgetProvider.java 0000664 0000000 0000000 00000012360 12711435674 0032701 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.demos.widget;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.widget.RemoteViews;
import com.androidplot.demos.R;
import com.androidplot.ui.*;
import com.androidplot.util.PixelUtils;
import com.androidplot.xy.XYSeries;
import com.androidplot.xy.LineAndPointFormatter;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.xy.XYPlot;
import java.util.Arrays;
public class DemoAppWidgetProvider extends AppWidgetProvider {
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
for (int widgetId : appWidgetIds) {
XYPlot plot = new XYPlot(context, "Widget Example");
final int h = (int) context.getResources().getDimension(R.dimen.sample_widget_height);
final int w = (int) context.getResources().getDimension(R.dimen.sample_widget_width);
plot.getGraphWidget().setMargins(0, 0, 0 , 0);
plot.getGraphWidget().setPadding(0, 0, 0, 0);
plot.getGraphWidget().getGridBox().setPadding(20, 25, 0, 20);
plot.getGraphWidget().getDomainTickLabelPaint().setTextSize(PixelUtils.spToPix(10));
plot.getGraphWidget().getRangeTickLabelPaint().setTextSize(PixelUtils.spToPix(10));
plot.getGraphWidget().getDomainOriginTickLabelPaint().setTextSize(PixelUtils.spToPix(10));
plot.getGraphWidget().getRangeOriginTickLabelPaint().setTextSize(PixelUtils.spToPix(10));
plot.getGraphWidget().position(0, XLayoutStyle.ABSOLUTE_FROM_LEFT, 0,
YLayoutStyle.ABSOLUTE_FROM_TOP, AnchorPosition.LEFT_TOP);
plot.getGraphWidget().setSize(Size.FILL);
plot.getLayoutManager().moveToTop(plot.getTitleWidget());
plot.measure(w, h);
plot.layout(0, 0, w, h);
/*plot.getGraphWidget().setMarginBottom(PixelUtils.dpToPix(40));
plot.getGraphWidget().setMarginLeft(PixelUtils.dpToPix(80));
plot.getGraphWidget().setPaddingLeft(PixelUtils.dpToPix(80));
plot.setPlotMargins(0, 0, 0, 0);
plot.getGraphWidget().position(0, XLayoutStyle.ABSOLUTE_FROM_LEFT, 0,
YLayoutStyle.ABSOLUTE_FROM_TOP, AnchorPosition.LEFT_TOP);
plot.getGraphWidget().setSize(Size.FILL);*/
// Create a couple arrays of y-values to plot:
//Number[] series1Numbers = {1, 8, 5, 2, 7, 4};
//Number[] series2Numbers = {4, 6, 3, 8, 2, 10};
Number[] series1Numbers = {1, 4, 2, 8, 4, 16, 8, 32, 16, 64};
Number[] series2Numbers = {5, 2, 10, 5, 20, 10, 40, 20, 80, 40};
// Turn the above arrays into XYSeries':
XYSeries series1 = new SimpleXYSeries(
Arrays.asList(series1Numbers), // SimpleXYSeries takes a List so turn our array into a List
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, // Y_VALS_ONLY means use the element index as the x value
"Series1"); // Set the display title of the series
// same as above
XYSeries series2 = new SimpleXYSeries(Arrays.asList(series2Numbers),
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Series2");
// Create a formatter to use for drawing a series using LineAndPointRenderer:
LineAndPointFormatter series1Format = new LineAndPointFormatter(
Color.rgb(0, 200, 0), // line color
Color.rgb(0, 100, 0), // point color
null, null); // fill color (none)
// add a new series' to the xyplot:
plot.addSeries(series1, series1Format);
// same as above:
plot.addSeries(series2,
new LineAndPointFormatter(
Color.rgb(0, 0, 200), Color.rgb(0, 0, 100), null, null));
// reduce the number of range labels
plot.setTicksPerRangeLabel(3);
plot.setTicksPerDomainLabel(2);
// hide the legend:
plot.getLegendWidget().setVisible(false);
RemoteViews rv = new RemoteViews(context.getPackageName(), R.layout.demo_app_widget);
Bitmap bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
plot.draw(new Canvas(bitmap));
rv.setImageViewBitmap(R.id.imgView, bitmap);
appWidgetManager.updateAppWidget(widgetId, rv);
}
}
}
androidplot-0.9.7/demoapp/src/main/res/ 0000775 0000000 0000000 00000000000 12711435674 0020011 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/res/drawable-hdpi/ 0000775 0000000 0000000 00000000000 12711435674 0022514 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/res/drawable-hdpi/ic_launcher.png 0000775 0000000 0000000 00000006530 12711435674 0025505 0 ustar 00root root 0000000 0000000 PNG
IHDR H H UG
IDATx^{pTǿ}&dCCB HbZбT>бө?꣢C|0V ht g,%:V O0$>w휛}d 1=?;;e0D$LL`P 4
(1#2. Equ5j{** QYah
ߏgn)E VH@bHZX v ''/+8Q+}
Ny> ]m5L} D6GOAEPFky; 08hEVVV\M {Ql&^pT 4>82Rm/Lˑ] ͆3gc֢h IBfffPe=NSr_QQAQ97 pgFH|C֗` (
8,p: z7-ZUE.V@bk4 E1a@1+3rV@5*== }_r
ec:Dd6cz4',Y$Aq[I444qm/.~NtYNㆭ Cy+ FeILC!r2a±23l>AU__e ET66@{fɐ Buݳp{
U[Uamkx^ H6(n_qq1I7l3X*( L+A-0hnKV 1u uũWawugtPS@
q@,_t+' Gn U{)3u#$Gsp8ܽ@YF*K2 2 x)qdJdI6)E57`&c+A w'm>$zAi9,"}ufr.]2YZZZ~&PC燒QV>jcԨi.`T@ZuV}\㥽S6i(IQ8U! M ApVt[
2V
6}lL&oǧO+*N=w UMj:-G\
/؎
Ҋ ܟ::$kQ)u?q~~.yYb8 Ii{CpF!r U}t
~Oĉ\j~Y_Cui v]C@SAA>R-GpzP#AIPqXvO< =z֭}1KAù% Ǒ eSu##$+v\D,j4شP^^~nQP?4Ziƍ/yyy)&8RLЇKrA&uonns >|fǎ ;v?~z#G(Ι{Ez^+ JySA9;e!ͲTFFsR'8+u t:]mv@
^ իu'O&Ņ`a':b͵^z>ڎh+++UN3EE ޤZ&[1F9xZkqܫ˄'ELv4Ĵܲ: IENDB` androidplot-0.9.7/demoapp/src/main/res/drawable-xhdpi/ 0000775 0000000 0000000 00000000000 12711435674 0022704 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/res/drawable-xhdpi/ic_launcher.png 0000775 0000000 0000000 00000010750 12711435674 0025674 0 ustar 00root root 0000000 0000000 PNG
IHDR ` ` w8 IDATx^ pי=sh4i:$IM@8ĵk$J\qצb'C(JV؎@]jk 6^Sn6
9l1t"d@iz=9yU*ׯ LI>=pd $d d $YI~|F2 ,$?>j
$Idq
ˈHq 'D=%" $ 9I$ P??
^$?;{ 9\rq(
S$) 0 iX\C? x~YVCXB{$IU $ g|.8&{G7 I Ԏ%C) `2jr~ɢEzфKPLE>!(9`ws9ĉ#"V j^ ### 8vWeeec@&W9'Ia>qUvo\nۃe!QCvm yjV7 &ĥ~W%L6vڵx߾}Y /JD]Oƻ kz SfCQ9[U w+* I`xx]a !
B{ĉeO>dc(-xŪ 3 DQD~ UJφ"*Q杘3)L[A8̛f h~~~{ [6oKΙ :uzժU J]oNSӾLRP͗`s2[!VRρ@: -F'mbƒXaX/##Gٲe%I"x ?~zݺu Btť[FVG ^E6 CA0 zdJaW0ZU>Mkځe[Q v! ̇ ZuV4jr w4{CgØ= wz?) 7yٳ0uJo! 3NzK( ? Nu\pJR}A`.p7Wfa .EӭanCePIT 80ـg/ǵ1+ R
p H/_O^AD P@sCk7l ߠ d#*D
z 5i U
nޝP_5=Ţg@u ձ9s!(P,( !( <Kq ?ABP d x $!(J+b[
(1@Ji"FQ!pp,C~,Y|jŖ*ds` nh@rC_}ǂB-TJ ?䒧$;;P/ v +|psRpj ۘ45NKi QȸRf{8u z`s-$|c
|詢2 wzkYC˰_2M% ;]װ%I
C|J;z= OS~15wf̙]D zg,( ȳe-1 . ~TmQR'j53wMgQ˰CQס 'J& j_Ab~}>b puU*4Q4w}w&ޡhϊ5I,M}4\iP95*a
@DFYEx Cus~>Hcמ95w(Q}gCF<z
0} R iE $, zT6^S!f q~9gy@J!{Y2|%l r)(ș6rl@VR³xj@*ÐCi@< Q, $@^ sH$0<1Z{ o|_BH
`q/Mq @[S
!Z t )"1¾ v"uMݱ@`(K 't
A#
)> rC `k F5ߡQ{ }ӟ0+,\
4C Z!ĉ]KI=5{:J0 .9ѤT(J,ϴBy j_D A^^}' G ظq Qq;ހf}upczP/W# z%͐/s>iy_S'ԌDᮮ.ܹJnʕǏh4բ(
Ǎ $ *{Ϡ-
`lĸ) /=Vj:L F1PZ4HYY&|SZՊ0#|7jnnW[[+> NbJtw'O6֎O <}6mzd
H_2 @%IPҮ~{[n]ɓ')+UЬ;!5%(2ɸ|[n}lh|duw90ґ2ܞ/ (d2|gϞQ;:-z >.H3 .* L^q: " 3 .*LB A^ IENDB` androidplot-0.9.7/demoapp/src/main/res/drawable-xxhdpi/ 0000775 0000000 0000000 00000000000 12711435674 0023074 5 ustar 00root root 0000000 0000000 androidplot-0.9.7/demoapp/src/main/res/drawable-xxhdpi/ic_launcher.png 0000775 0000000 0000000 00000016271 12711435674 0026070 0 ustar 00root root 0000000 0000000 PNG
IHDR F IDATx^ t ř3:FI#$K!۲l" 8$fC 6N $,@r`V받K&lf,G$1 X2-ɖdukt͌}%h3=1~}_}U ABAH0
I|@!I ($' $gl d0 Bq@H0
I|,T7< dAEWF1n
,YE & eY͟Ph ) $zƉHڗ B@(seY6 0Du H`1
Yc rhp @/:oV Y)Y #pB?|$ M}v?h6 RU ύh#~%{R:Ψf`>(zBB³B4>,ˤyelؔKEs?.]tkNNΛk0w?&E-Y 5Ο?hѢE%s2] :[A!<4Oq G++ fʨL&r 4୳?
7߈1CZIbuuM6ݻ:?>%%% ߗeJN 3_|+nc.i!&
ssyُ$~bo$A$( z衲"( DACȑ# /_~z]S D$tw+ 9~Q07>#oRSSMczdީvG9nۈRfBIO2QL& br$fyސCA :;}(j`-06B@p xb3,R nZf)õ\E{ RgϞՏ?xIQQPQQQP=58ݺuǧ@ l,TV,> % Aw{W*t_c6 IVĘg .:; a>bGpnyi/ÿ 'xu\Ƣoy +s :3hM ڒعH_nfV?$k Gi5) o& i߾}6l8655d TͯqEdٗ}CQ6@[f"Ӿ
ڏ ?N\}tQ,tG/˜hvܹ4{Lؔ;z|\ 7
y s㉂yikUEgc ĝ@+/ H 2!n/Z{ C('Έ_Yw#=xӽi%mNP p鏨l? Ca sc,K$' jn]Po $M
C8]u1LFP ;y
f6Wr `"=!2 R4 'ldM4lf?O5!:ȉAP /ِ)N"dfzH[7`z@d 4^rOVmǫuwFb|fw Ϟ|@~Q 4)slQl_n5z& 6oD=L. h 6ȴsبT+#
hz (o| d=f6A=[Wbl(Ⱥ I8Z?=:;$0 QBZ1=GDR;*Ji+i XS6JqHm?<&;i&X8<d:C4wN9Wf 3ax) D9ood#߁
qXCNT6Ib=e )W߸` ޓC w/,D 4pw,ޣVl1|&C{kq ;*N
{{|v [L6;qoB@j=KfFy֤` XH] -.q t=DHizR"=j5v Gf6r %%!ʛv-~V" 0z%'|!G7uxj CPj%""}0j dչk0T(b
EQt*v-,ӑ`RX " n6!O%H|f?c~GɆ.j DQpVT&װ~nqݼ ey>Ѓ o^_D;،#'-AlL] rxo5("j: 7ӱb+nAJȴ _E$@m@<ѐJb4(36l,j""
'U-h։n A)^i Jٲd{'kNѴM([GPD"|Ŷ(ou"o
7 zyh7 |5uIFZX3VphkJ<뒙9$HZ8Fs1KV)/b"}︘Dv :n
uRF(!!!<߅Ps V@@JJ<7`t>R&w8:QM={
QhGnj Drɉ4X ڋiX; \Y+^ n 9WrAQƗXNT)Gg1\ϦCroCeMJM >)An/-[4"-hjhhp۷/f:z70W ȁ;mL_y wqFɛE jjsyQk
|l {ٺuԟ<<,7#z#}Kp쌖2n-LY!-6](,"
z1/a;'~KTbDi~g7~j)j[93%{`l# Y$Z6nݥM0I{f,(.^RYq-Ki! /e0痐4:vƈ ̻ͨ@63unz*@ށİs/`9}F``~l9H@ *}x-E9W!Ǧ66 _C R_[{" z? _Z^/6 уѢnG+{sEe@ yQÂ4jZehQ_k-!oXj XV`Ixg'NRpXɶ@DhSUxd.mba,
47>l4Ap8Qj\QO]]
xd{Č\yRs!{>.
Tײ Y/ + n HmiI Njqs{G<7g hivTԷ ᅹ2maG} u@mmmlXvBoZCf> tkN J&5HܵkWIlp\/OoWd" [ O(: E"@99 qoE2@\/ƺ92 )!R
ɗ 5wtA r̎Hql2^; )!
$ ri `#[hdV'':>fxLpps zȑCZ_-0 A~\m%߁ Tox @jD vG9ޭ܂>m i 1X6q$3 ϴ D\QQQ,~D5\z%UĠ{8&%JJs a YSm5Q)İ7aʇU3S nGvlC1>a͏E kX `V IW[Z2@\zp2a"iM]i#T[ڠ4A g{Pl"6*m2Eq ) l'|Iׁ+Цqj ~rĝ;wW QU'M#;4P \>mjjAK"Ϻ'kWVq͜щ A2@22^ץ^p 8-i'wcqxXb!͍ f.~
g^\Uky;<^ uf'Ɗ[ؠ/ h2Hќ [Q^2^,;
rzk "|T[ssR?eyɂ H"gToZ.93ְ `*54AIhV=jU2se?aQ] J O&݄ c,fX)Uw@=:tըY*wP $H4HP'Yrу]K2l^QQ>jϥ>F/..6_gϞw}Q S
vP&`ճ Ƃ>e$AD
RJTE
ƕ9sg*4a555¶mN[/+@EEEbQQnKG%Iʖi `Jc lDIӨoR{
r+}I ʄ2jtDkw/>ۣ̤e,9-.:cThy #XVVp}TRRROn+ $h
DZr!kwwqqqeY&m-6-RZ _[7qMr
"ʜ ȗe_,M,G-glPŅȔյ=)9!6,͞q3b-)̟^G@x҉'Y V=t tGo߾=*,,|n!סu58ifFzA Sc[RY2;,?xT r;`2E#֒
ixLD$! KmV[[+?}~v_~z=5PPP`.++$5===G)9{{{Ơ#>hN2u] :2
bCKu 咎 ?^nݺ[ښHTA0:G*(('~_v233ILiy 1CiQ+.x>2/97 W & ҩS+|w
zh,R @tVVVB]]uǎ __bO)^¼xY:U!Rn"t%,"tp=裿ONNmkk|a2_v5---9fͷ^̌T5ߓ9 To C&TUU5 8pO> L43cl f \x[OOOfnٲeC^^ fX,Hh4* '~jmmm|{ӦM/PBmzFmBk!ZRmmml&Ԅk&b|YEuTzNQ.--m4 ;99F>i zy5/pȔDkn {{{
j b=xq]@ Ȱ 8̾z߹ӷݷ;3=U,}nթ߯Ωs5\ Hh
p$tsp $8y98Z N~xN '@Bw?o<' @Bk 7c 5 1H5R8v!{=/O٩+S[ -4 "0,2t8d Q(y r[tdh a "t(DQ$7 P#!d 0@_ = PC;uHWBj@\p ޏ6Z8|̙ꈢxg RY(#!!3 l!%u!3 J9n[ aP <@J Y*aG)#[j8Q<㯰KEN`dxYZ$q `|hhh ĖQM6 ~p 4zϘL&%.`Qĵ&t:I? FB~b G @ UUU8sLqQQj+fE1
F b&Ϸ^ p|>[4 ={j1Յ^[[ Zy>IWssAb44
I ioiib'.XfաW^P MuzFidǿwM7-ݰayҤIX7M4sl6: \ 0 6]tI$8T8\!1μV{KK %0Lު*syyǍ 0$ *x6DQ$Sխ'.|eq nMrPSS#-" Z5d,x}-7Q =KU.$ 477 9kԨQSS+QO" mT`}'L |> 1[Uf]ޙq`/S\ JDŗę/a3xb&I'(Sw ^|>ly,YwuWVl߾:n8ݻK Iݙ ޘL /bsmMvL-|i#)M*
X!AuQ ^c1 PWS" CŅR;
pǘK1Ni9~}} D # X6}ta˖-c&LAE Djr5|B ﴴHbe?NwM&N ͑{Cn
2s ?
.O~i!
roFI}`6O( 99D[G zjbME }QSY Qee%rss`^2W,Yc$+ps;.Z*ѪPT ICdHMGa gh_VzAy3q핏f]'+Bb|dzx
<綾^"-hѢ$"+H}4+փ6̺"9l=`dLz1ATiKL ZOPh#x_z饨G#\ +VG({y5jPy>FG,BJмiHxJt1 8m4=x}P L )L+JQD]pe- ] _aϩQp+씡Y gOl\XPFr ̽o -S?g=R;ƈ? ,ғ)$"ܦհ H )FOn%Pbt
FWMCy2
CJ`jS"@($Qmnl;Q+3 1~788jf~Є]-Eve˼ɶ X
-gB&I8nQ-F2Dt%`Y;_˯e;UZV/~ 6 \%~od↡?Ęs*(EʉuW>/1WD]@]G%b֗\XÖ;M(2;rc|s|!KɌ 0
YwE'Aඑo";u$,8?wG %a &'PƧ;=awn^zl?3c`w2]Q[;]4)?#Iˢ,e- $' s2
?l/OFVqRHy^݉uS5[xE5M~xqTT1~a?Є\!-ѣ\%H GUZ,&fLUL/j 'ә)?z4A]oa_Cn bO6KfVs,@#T% ' {wFE : 5L%{NWIeDCjen&?g
*F%MGWz+}%Hp 1dDJ,GIN fdMXZ85F,1};(t:˲gH :2+3* Ӥ6r ]n, L$0iӻGhb\&4ݩ4G?>='NKᬄp5|\#2^{ʗg= F nƁ5-cx=7i ~YyH `{HzË˼SF* HN #@d-U kvg]i@ rrk!r<>Lٜ т^v#xR@q;Nm
1UKz/BN P~3爫_zFE '@x m1 yHm]ar:* Q'KT5 ɛ2G: @CmX; 7ǜх<^9eBMF`@)T aH @w:MւG:[hAʶ$pŒ b/> jOh&7HZ/˦} F))aJ<:( 'u
X{Cv;VMD~~p
pf0[a:`1'UR:uEHL ZJJJjwI V9-|vW95PQI*55_Q T -0ْQ=4 YſD9
k;ͮ*|&Ud颻|Z,HuXpH`iC(P5b R~ٝ|Rۥ-)|D`jhEV42 zqL6)Vԇ/aA(HĆ۰p>w A!rm1Xi?> brӅ0YںE?mʲB)z]i#M^^_W ;ӗ&J(| ;3Z" zj#,1,@]&m͜g(N &JB~f,ݢ-nsaWP\?@N #, ef=ӉAwC=t[E<ԬB)q1 ug%;,%g'D-3 I(//w-]41@+=Iw_Ӑ V%oY'F*^pMUJ4#`l6K.P7D_ 5mZ8`Qu߀5"*qKn+
W)% νrw;JeXS9ر8N<4hw^"eҟŬU u/g6+h%tbV' |=m.˅[Ǯ['Yi(6 $ s8UOύs\ Mf<{ MZ!
zC+B,rhS9 Ucڝ Z51 ;9jk 'B$2h Gp9;b@kr Ucs
qˠ& B!>@?Y`D 9w`TTpFh ?s\ N ~`TT@-eC!8QQ1LP %@PN ~`TT R(' c'0lxM-ĭEr4Hs PN N F
*Bp0k,ZY c T@B]A PN EL_SLr %` Z;@.˷#_JdFr ~i'X_9j(xA`?'У