{
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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/Formatter.java 0000664 0000000 0000000 00000003717 12766537502 0030300 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/HorizontalPosition.java 0000664 0000000 0000000 00000005124 12766537502 0032205 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 HorizontalPosition extends PositionMetric {
public HorizontalPosition(float value, HorizontalPositioning layoutStyle) {
super(value, layoutStyle);
validatePair(value, layoutStyle);
}
/**
* Throws IllegalArgumentException if there is a problem.
* @param value
*/
protected void validatePair(float value, HorizontalPositioning 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(HorizontalPositioning layoutType) {
super.setLayoutType(layoutType);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/HorizontalPositioning.java 0000664 0000000 0000000 00000001506 12766537502 0032703 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 HorizontalPositioning {
ABSOLUTE_FROM_LEFT,
ABSOLUTE_FROM_RIGHT,
ABSOLUTE_FROM_CENTER,
RELATIVE_TO_LEFT,
RELATIVE_TO_RIGHT,
RELATIVE_TO_CENTER
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/Insets.java 0000664 0000000 0000000 00000003025 12766537502 0027572 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.ui;
/**
* A set of insets for a rect space.
*/
public class Insets {
private float top;
private float bottom;
private float left;
private float right;
public Insets() {}
public Insets(float top, float bottom, float left, float right) {
this.top = top;
this.bottom = bottom;
this.left = left;
this.right = right;
}
public float getTop() {
return top;
}
public void setTop(float top) {
this.top = top;
}
public float getBottom() {
return bottom;
}
public void setBottom(float bottom) {
this.bottom = bottom;
}
public float getLeft() {
return left;
}
public void setLeft(float left) {
this.left = left;
}
public float getRight() {
return right;
}
public void setRight(float right) {
this.right = right;
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/LayoutManager.java 0000664 0000000 0000000 00000021123 12766537502 0031074 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.LinkedLayerList;
public class LayoutManager extends LinkedLayerList
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);
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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/LayoutMetric.java 0000664 0000000 0000000 00000003721 12766537502 0030751 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/PositionMetric.java 0000664 0000000 0000000 00000005357 12766537502 0031307 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/PositionMetrics.java 0000664 0000000 0000000 00000004133 12766537502 0031461 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 HorizontalPosition horizontalPosition;
private VerticalPosition verticalPosition;
private Anchor anchor;
private float layerDepth;
public PositionMetrics(float x, HorizontalPositioning horizontalPositioning, float y, VerticalPositioning verticalPositioning, Anchor anchor) {
setXPositionMetric(new HorizontalPosition(x, horizontalPositioning));
setYPositionMetric(new VerticalPosition(y, verticalPositioning));
setAnchor(anchor);
}
public VerticalPosition getYPositionMetric() {
return verticalPosition;
}
public void setYPositionMetric(VerticalPosition verticalPosition) {
this.verticalPosition = verticalPosition;
}
public Anchor getAnchor() {
return anchor;
}
public void setAnchor(Anchor 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 HorizontalPosition getXPositionMetric() {
return horizontalPosition;
}
public void setXPositionMetric(HorizontalPosition horizontalPosition) {
this.horizontalPosition = horizontalPosition;
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/RenderBundle.java 0000664 0000000 0000000 00000002747 12766537502 0030710 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/RenderStack.java 0000664 0000000 0000000 00000006757 12766537502 0030551 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/Resizable.java 0000664 0000000 0000000 00000003025 12766537502 0030245 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
*/
void layout(final DisplayDimensions dims);
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/SeriesAndFormatter.java 0000664 0000000 0000000 00000002521 12766537502 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;
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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/SeriesRenderer.java 0000664 0000000 0000000 00000010053 12766537502 0031245 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/Size.java 0000664 0000000 0000000 00000006056 12766537502 0027246 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, SizeMode.FILL, 0, SizeMode.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, SizeMode heightLayoutType, float width, SizeMode 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/SizeMetric.java 0000664 0000000 0000000 00000003774 12766537502 0030416 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 SizeMode} enumeration.
*
*/
public class SizeMetric extends LayoutMetric {
public SizeMetric(float value, SizeMode layoutType) {
super(value, layoutType);
}
protected void validatePair(float value, SizeMode 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(SizeMode layoutType) {
super.setLayoutType(layoutType);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/SizeMode.java 0000664 0000000 0000000 00000002533 12766537502 0030047 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;
/**
* 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 SizeMode {
ABSOLUTE,
RELATIVE,
FILL
} androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/TableModel.java 0000664 0000000 0000000 00000002501 12766537502 0030333 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/TableOrder.java 0000664 0000000 0000000 00000001370 12766537502 0030351 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/TableSizingMethod.java 0000664 0000000 0000000 00000001742 12766537502 0031705 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/TextOrientation.java 0000664 0000000 0000000 00000001360 12766537502 0031465 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 TextOrientation {
HORIZONTAL,
VERTICAL_ASCENDING,
VERTICAL_DESCENDING
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/VerticalPosition.java 0000664 0000000 0000000 00000005036 12766537502 0031627 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 VerticalPosition extends PositionMetric {
public VerticalPosition(float value, VerticalPositioning layoutStyle) {
super(value, layoutStyle);
}
/**
* Throws IllegalArgumentException if there is a problem.
* @param value
*/
protected void validatePair(float value, VerticalPositioning 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(VerticalPositioning layoutType) {
super.setLayoutType(layoutType);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/VerticalPositioning.java 0000664 0000000 0000000 00000001503 12766537502 0032320 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 VerticalPositioning {
ABSOLUTE_FROM_TOP,
ABSOLUTE_FROM_BOTTOM,
ABSOLUTE_FROM_CENTER,
RELATIVE_TO_TOP,
RELATIVE_TO_BOTTOM,
RELATIVE_TO_CENTER
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/widget/ 0000775 0000000 0000000 00000000000 12766537502 0026745 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/widget/EmptyWidget.java 0000664 0000000 0000000 00000002227 12766537502 0032055 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/widget/TextLabelWidget.java 0000664 0000000 0000000 00000013034 12766537502 0032641 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 TextOrientation 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, TextOrientation.HORIZONTAL);
}
public TextLabelWidget(LayoutManager layoutManager, String title, Size size, TextOrientation orientation) {
this(layoutManager, size, orientation);
setText(title);
}
public TextLabelWidget(LayoutManager layoutManager, Size size, TextOrientation orientation) {
super(layoutManager, new Size(0, SizeMode.ABSOLUTE, 0, SizeMode.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(), SizeMode.ABSOLUTE, size.width()+2, SizeMode.ABSOLUTE));
break;
case VERTICAL_ASCENDING:
case VERTICAL_DESCENDING:
setSize(new Size(size.width(), SizeMode.ABSOLUTE, size.height()+2, SizeMode.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,
Anchor.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 TextOrientation getOrientation() {
return orientation;
}
public void setOrientation(TextOrientation 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-1.2.1/androidplot-core/src/main/java/com/androidplot/ui/widget/Widget.java 0000664 0000000 0000000 00000032217 12766537502 0031040 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.HorizontalPositioning;
import com.androidplot.ui.VerticalPositioning;
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 Anchor getAnchor() {
return getPositionMetrics().getAnchor();
}
public void setAnchor(Anchor anchor) {
getPositionMetrics().setAnchor(anchor);
}
/**
* Same as {@link #position(float, HorizontalPositioning, float, VerticalPositioning, Anchor)}
* but with the anchor parameter defaulted to the upper left corner.
* @param x
* @param horizontalPositioning
* @param y
* @param verticalPositioning
*/
public void position(float x, HorizontalPositioning horizontalPositioning, float y, VerticalPositioning verticalPositioning) {
position(x, horizontalPositioning, y, verticalPositioning, Anchor.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 horizontalPositioning 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 verticalPositioning 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, HorizontalPositioning horizontalPositioning, float y,
VerticalPositioning verticalPositioning, Anchor anchor) {
setPositionMetrics(new PositionMetrics(x, horizontalPositioning, y, verticalPositioning, 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, SizeMode layoutType) {
size.getWidth().set(width, layoutType);
}
public void setHeight(float height) {
size.getHeight().setValue(height);
}
public void setHeight(float height, SizeMode 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, Anchor anchor) {
PointF point = new PointF();
switch (anchor) {
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: " + anchor);
}
return point;
}
public static PointF getAnchorCoordinates(RectF widgetRect, Anchor anchor) {
return PixelUtils.add(new PointF(widgetRect.left, widgetRect.top),
getAnchorOffset(widgetRect.width(), widgetRect.height(), anchor));
}
public static PointF getAnchorCoordinates(float x, float y, float width, float height, Anchor anchor) {
return getAnchorCoordinates(new RectF(x, y, x+width, y+height), anchor);
}
public void draw(Canvas canvas) throws PlotRenderException {
if (isVisible()) {
if (backgroundPaint != null) {
drawBackground(canvas, widgetDimensions.canvasRect);
}
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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/ 0000775 0000000 0000000 00000000000 12766537502 0026022 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/util/AttrUtils.java 0000664 0000000 0000000 00000024403 12766537502 0030623 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.StepMode;
import com.androidplot.xy.StepModel;
/**
* Methods for applying styleable attributes.
*
*/
public class AttrUtils {
public static void configureInsets(TypedArray attrs, Insets insets,
int topAttr, int bottomAttr, int leftAttr, int rightAttr) {
insets.setTop(attrs.getDimension(topAttr, insets.getTop()));
insets.setBottom(attrs.getDimension(bottomAttr, insets.getBottom()));
insets.setLeft(attrs.getDimension(leftAttr, insets.getLeft()));
insets.setRight(attrs.getDimension(rightAttr, insets.getRight()));
}
/**
* 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) {
configureTextPaint(attrs, paint, colorAttr, textSizeAttr, null);
}
/**
* Configure a {@link Paint} instance used for drawing text from xml attrs.
* @param attrs
* @param paint
* @param colorAttr
* @param textSizeAttr
* @param alignAttr
*/
public static void configureTextPaint(TypedArray attrs, Paint paint, int colorAttr,
int textSizeAttr, Integer alignAttr) {
if(attrs != null) {
setColor(attrs, paint, colorAttr);
setTextSize(attrs, paint, textSizeAttr);
if(alignAttr != null && attrs.hasValue(alignAttr)) {
configureTextAlign(attrs, paint, alignAttr);
}
}
}
/**
* Configure {@link Paint} text alignment from xml attrs.
* @param attrs
* @param paint
* @param alignAttr
*/
public static void configureTextAlign(TypedArray attrs, Paint paint, int alignAttr) {
if (attrs != null) {
//if(attrs.hasValue(alignAttr)) {
final Paint.Align alignment = Paint.Align.values()
[attrs.getInt(alignAttr, paint.getTextAlign().ordinal())];
paint.setTextAlign(alignment);
//}
}
}
/**
* 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 SizeMode sizeMode =
getSizeLayoutType(attrs, typeAttr, model.getLayoutType());
model.set(value, sizeMode);
}
private static SizeMode getSizeLayoutType(TypedArray attrs, int attr, SizeMode defaultValue) {
return SizeMode.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 HorizontalPositioning getXLayoutStyle(TypedArray attrs, int attr, HorizontalPositioning defaultValue) {
return HorizontalPositioning.values()[attrs.getInt(attr, defaultValue.ordinal())];
}
private static VerticalPositioning getYLayoutStyle(TypedArray attrs, int attr, VerticalPositioning defaultValue) {
return VerticalPositioning.values()[attrs.getInt(attr, defaultValue.ordinal())];
}
private static Anchor getAnchorPosition(TypedArray attrs, int attr, Anchor defaultValue) {
return Anchor.values()[attrs.getInt(attr, defaultValue.ordinal())];
}
public static void configureStep(TypedArray attrs, StepModel model, int stepModeAttr, int stepValueAttr) {
if(attrs != null) {
model.setMode(StepMode.values()[attrs.getInt(stepModeAttr, model.getMode().ordinal())]);
model.setValue(getIntFloatDimenValue(attrs, stepValueAttr, model.getValue()).doubleValue());
}
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/util/Configurator.java 0000664 0000000 0000000 00000032252 12766537502 0031333 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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/DisplayDimensions.java 0000664 0000000 0000000 00000002744 12766537502 0032332 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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/FontUtils.java 0000664 0000000 0000000 00000004250 12766537502 0030615 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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/LayerHash.java 0000664 0000000 0000000 00000010365 12766537502 0030552 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 Layerable}. Provides fast element retrieval via hash key in addition to
* mutable ordering (z indexing) of elements.
*/
public class LayerHash implements Layerable {
private HashMap hash;
private LinkedLayerList zlist;
{
hash = new HashMap<>();
zlist = new LinkedLayerList<>();
}
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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/LayerListOrganizer.java 0000664 0000000 0000000 00000006447 12766537502 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.util;
import java.util.List;
/**
* Utility class providing additional element organization operations.
* @param
*/
public class LayerListOrganizer implements Layerable {
private static final int ZERO = 0;
private static final int ONE = 1;
private List list;
public LayerListOrganizer(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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/Layerable.java 0000664 0000000 0000000 00000004137 12766537502 0030572 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 "layerable" 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 layer) is effectively the "bottom" element.
* @param
*/
public interface Layerable {
/**
* 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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/LinkedLayerList.java 0000664 0000000 0000000 00000003664 12766537502 0031735 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;
/**
* A implementation of {@link Layerable} backed by a {@link LinkedList}.
* @param
*/
public class LinkedLayerList extends LinkedList implements Layerable {
private LayerListOrganizer organizer = new LayerListOrganizer<>(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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/Mapping.java 0000664 0000000 0000000 00000002045 12766537502 0030261 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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/PixelUtils.java 0000664 0000000 0000000 00000014662 12766537502 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.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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/PlotStatistics.java 0000664 0000000 0000000 00000007362 12766537502 0031666 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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/RectFUtils.java 0000664 0000000 0000000 00000004121 12766537502 0030707 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;
import com.androidplot.ui.*;
/**
* 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;
}
/**
* Calculates a new {@link RectF} by applying insets to rect.
* @param rect
* @param insets
* @return The {@link RectF} created as a result of applying insets, or the passed in
* instance, if the insets were null.
*/
public static RectF applyInsets(RectF rect, Insets insets) {
if (insets != null) {
return new RectF(
rect.left + insets.getLeft(),
rect.top + insets.getTop(),
rect.right - insets.getRight(),
rect.bottom - insets.getBottom());
} else {
return rect;
}
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/util/Redrawer.java 0000664 0000000 0000000 00000010326 12766537502 0030442 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.lang.ref.WeakReference;
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. Callers should be sure to create a separate thread from which to use this class.
*/
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;
// used to temporarily pause rendering without disposing of the run thread
private boolean keepRunning;
// when set to false, run thread will be allowed to exit the main run loop
private boolean keepAlive;
private Thread thread;
/**
*
* @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 = new ArrayList<>();
for(Plot plot : plots) {
this.plots.add(new WeakReference<>(plot));
}
setMaxRefreshRate(maxRefreshRate);
thread = new Thread(this);
thread.start();
if(startImmediately) {
start();
}
}
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(WeakReference plotRef : plots) {
plotRef.get().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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/SeriesUtils.java 0000664 0000000 0000000 00000010272 12766537502 0031142 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-1.2.1/androidplot-core/src/main/java/com/androidplot/util/ValPixConverter.java 0000664 0000000 0000000 00000007031 12766537502 0031761 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 double valToPix(double val, double min, double max, double 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;
double pix = 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, double 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(double pix, double min, double max, double 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.");
}
double 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 = (float) ValPixConverter.valToPix(x.doubleValue(), minX.doubleValue(),
maxX.doubleValue(), plotArea.width(), false) + (plotArea.left);
float pixY = (float) ValPixConverter.valToPix(y.doubleValue(), minY.doubleValue(),
maxY.doubleValue(), plotArea.height(), true) + plotArea.top;
return new PointF(pixX, pixY);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/ 0000775 0000000 0000000 00000000000 12766537502 0025505 5 ustar 00root root 0000000 0000000 AdvancedLineAndPointRenderer.java 0000664 0000000 0000000 00000010753 12766537502 0033740 0 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy /*
* 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.*;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.RenderStack;
import com.androidplot.ui.SeriesRenderer;
import com.androidplot.util.ValPixConverter;
import java.util.ArrayList;
/**
* This is an experimental (but stable) implementation of an {@link XYSeriesRenderer} that provides instrumentation
* allowing advanced behaviors like dynamically coloring / styling individual segments of a series, etc. This class
* may be removed or renamed in future releases.
* Currently has the following constraints:
* - Interpolation is not supported
* - Only draws lines; no points or fill
* - Draws series lines using simple Canvas.drawLine(...) invocations.
* @since 0.9.9
*/
public class AdvancedLineAndPointRenderer extends XYSeriesRenderer {
private int latestIndex;
public AdvancedLineAndPointRenderer(XYPlot plot) {
super(plot);
}
@Override
protected void onRender(Canvas canvas, RectF plotArea, XYSeries series, Formatter formatter, RenderStack stack) throws PlotRenderException {
PointF thisPoint;
PointF lastPoint = 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(formatter.getLinePaint() != null) {
if (thisPoint != null && lastPoint != null) {
canvas.drawLine(lastPoint.x, lastPoint.y, thisPoint.x, thisPoint.y, formatter.getLinePaint(i, latestIndex, series.size()));
}
}
lastPoint = thisPoint;
}
}
@Override
protected void doDrawLegendIcon(Canvas canvas, RectF rect, Formatter formatter) {
if(formatter.getLinePaint() != null) {
canvas.drawLine(rect.left, rect.bottom, rect.right, rect.top, formatter.getLinePaint());
}
}
public void setLatestIndex(int latestIndex) {
this.latestIndex = latestIndex;
}
/**
* Formatter designed to work in tandem with {@link AdvancedLineAndPointRenderer}.
* @since 0.9.9
*/
public static class Formatter extends XYSeriesFormatter {
private Paint linePaint;
{
linePaint = new Paint();
linePaint.setStrokeWidth(3);
linePaint.setColor(Color.RED);
}
@Override
public Class getRendererClass() {
return AdvancedLineAndPointRenderer.class;
}
@Override
public SeriesRenderer getRendererInstance(XYPlot plot) {
return new AdvancedLineAndPointRenderer(plot);
}
public Paint getLinePaint() {
return linePaint;
}
/**
* By default, simply returns the line paint as-is. May be overridden to provide custom behavior based
* on input params.
* @param thisIndex
* @param latestIndex
* @param seriesSize
* @return
*/
public Paint getLinePaint(int thisIndex, int latestIndex, int seriesSize) {
return getLinePaint();
}
public void setLinePaint(Paint linePaint) {
this.linePaint = linePaint;
}
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/Axis.java 0000664 0000000 0000000 00000001273 12766537502 0027257 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 Axis {
DOMAIN,
RANGE
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/BarFormatter.java 0000664 0000000 0000000 00000003774 12766537502 0030753 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/BarRenderer.java 0000664 0000000 0000000 00000035336 12766537502 0030555 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 = (float) 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 = (float) 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 = (float) 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/BoundaryMode.java 0000664 0000000 0000000 00000001363 12766537502 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 enum BoundaryMode {
FIXED,
AUTO,
GROW,
SHRINK
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/CandlestickFormatter.java 0000664 0000000 0000000 00000013302 12766537502 0032457 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.Color;
import android.graphics.Paint;
import com.androidplot.ui.SeriesRenderer;
import com.androidplot.util.PixelUtils;
/**
* Format for drawing a value using {@link CandlestickRenderer}.
* @since 0.9.7
*/
public class CandlestickFormatter extends XYSeriesFormatter {
private static final float DEFAULT_WIDTH_PIX = PixelUtils.dpToPix(10);
private static final float DEFAULT_STROKE_PIX = PixelUtils.dpToPix(4);
private Paint wickPaint;
private Paint risingBodyFillPaint;
private Paint fallingBodyFillPaint;
private Paint risingBodyStrokePaint;
private Paint fallingBodyStrokePaint;
private Paint upperCapPaint;
private Paint lowerCapPaint;
private float bodyWidth = DEFAULT_WIDTH_PIX;
private float upperCapWidth = DEFAULT_WIDTH_PIX;
private float lowerCapWidth = DEFAULT_WIDTH_PIX;
private BodyStyle bodyStyle;
public enum BodyStyle {
Square,
Triangle
}
protected static Paint getDefaultFillPaint(int color) {
Paint p = new Paint();
p.setStyle(Paint.Style.FILL);
p.setColor(color);
return p;
}
protected static Paint getDefaultStrokePaint(int color) {
Paint p = new Paint();
p.setStyle(Paint.Style.STROKE);
p.setStrokeWidth(DEFAULT_STROKE_PIX);
p.setColor(color);
p.setAntiAlias(true);
return p;
}
public CandlestickFormatter() {
this(getDefaultStrokePaint(Color.YELLOW),
getDefaultFillPaint(Color.GREEN),
getDefaultFillPaint(Color.RED),
getDefaultStrokePaint(Color.GREEN),
getDefaultStrokePaint(Color.RED),
getDefaultStrokePaint(Color.YELLOW),
getDefaultStrokePaint(Color.YELLOW),
BodyStyle.Square);
}
public CandlestickFormatter(Paint wickPaint, Paint risingBodyFillPaint, Paint fallingBodyFillPaint,
Paint risingBodyStrokePaint, Paint fallingBodyStrokePaint,
Paint upperCapPaint, Paint lowerCapPaint, BodyStyle bodyStyle) {
setWickPaint(wickPaint);
setRisingBodyFillPaint(risingBodyFillPaint);
setFallingBodyFillPaint(fallingBodyFillPaint);
setRisingBodyStrokePaint(risingBodyStrokePaint);
setFallingBodyStrokePaint(fallingBodyStrokePaint);
setUpperCapPaint(upperCapPaint);
setLowerCapPaint(lowerCapPaint);
setBodyStyle(bodyStyle);
}
@Override
public Class getRendererClass() {
return CandlestickRenderer.class;
}
@Override
public SeriesRenderer getRendererInstance(XYPlot plot) {
return new CandlestickRenderer(plot);
}
public Paint getWickPaint() {
return wickPaint;
}
public void setWickPaint(Paint wickPaint) {
this.wickPaint = wickPaint;
}
public Paint getRisingBodyFillPaint() {
return risingBodyFillPaint;
}
public void setRisingBodyFillPaint(Paint risingBodyFillPaint) {
this.risingBodyFillPaint = risingBodyFillPaint;
}
public Paint getRisingBodyStrokePaint() {
return risingBodyStrokePaint;
}
public void setRisingBodyStrokePaint(Paint risingBodyStrokePaint) {
this.risingBodyStrokePaint = risingBodyStrokePaint;
}
public Paint getUpperCapPaint() {
return upperCapPaint;
}
public void setUpperCapPaint(Paint upperCapPaint) {
this.upperCapPaint = upperCapPaint;
}
public Paint getLowerCapPaint() {
return lowerCapPaint;
}
public void setLowerCapPaint(Paint lowerCapPaint) {
this.lowerCapPaint = lowerCapPaint;
}
public float getBodyWidth() {
return bodyWidth;
}
public void setBodyWidth(float bodyWidth) {
this.bodyWidth = bodyWidth;
}
public float getLowerCapWidth() {
return lowerCapWidth;
}
public void setLowerCapWidth(float lowerCapWidth) {
this.lowerCapWidth = lowerCapWidth;
}
public float getUpperCapWidth() {
return upperCapWidth;
}
public void setUpperCapWidth(float upperCapWidth) {
this.upperCapWidth = upperCapWidth;
}
public Paint getFallingBodyFillPaint() {
return fallingBodyFillPaint;
}
public void setFallingBodyFillPaint(Paint fallingBodyFillPaint) {
this.fallingBodyFillPaint = fallingBodyFillPaint;
}
public Paint getFallingBodyStrokePaint() {
return fallingBodyStrokePaint;
}
public void setFallingBodyStrokePaint(Paint fallingBodyStrokePaint) {
this.fallingBodyStrokePaint = fallingBodyStrokePaint;
}
public BodyStyle getBodyStyle() {
return bodyStyle;
}
public void setBodyStyle(BodyStyle bodyStyle) {
this.bodyStyle = bodyStyle;
}
/**
* Convenience method to set caps and wick to a single color in one call.
* @param paint
*/
public void setCapAndWickPaint(Paint paint) {
setUpperCapPaint(paint);
setLowerCapPaint(paint);
setWickPaint(paint);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/CandlestickMaker.java 0000664 0000000 0000000 00000007007 12766537502 0031560 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;
/**
* Helper utility to simplify the creation of of candlestick charts
* @since 0.9.7
*/
public abstract class CandlestickMaker {
/**
* Adds a candlestick chart to the specified plot using the specified
* high, low, open and close values.
* @param plot
* @param formatter
* @param openVals
* @param closeVals
* @param highVals
* @param lowVals
*/
public static void make(XYPlot plot, CandlestickFormatter formatter,
XYSeries openVals, XYSeries closeVals, XYSeries highVals, XYSeries lowVals) {
plot.addSeries(formatter, highVals, lowVals, openVals, closeVals);
}
/**
* Add a candlestick chart to the specified plot using the specified {@link CandlestickSeries}.
* @param plot
* @param formatter
* @param series
* @since 0.9.8
*/
public static void make(XYPlot plot, CandlestickFormatter formatter, CandlestickSeries series) {
make(plot, formatter, series.getOpenSeries(), series.getCloseSeries(),
series.getHighSeries(), series.getLowSeries());
}
/**
* Check the validity of series data comprising a {@link CandlestickSeries}.
* This is a development aid; be sure to remove any usage of this method in production code.
* @param series
* @since 0.9.8
*/
public static void check(CandlestickSeries series) {
check(series.getOpenSeries(), series.getCloseSeries(), series.getHighSeries(), series.getLowSeries());
}
/**
* Check the validity of series data comprising a candlestick chart.
* This is a development aid; be sure to remove any usage of this method in production code.
* @param openVals
* @param closeVals
* @param highVals
* @param lowVals
* @since 0.9.8
*/
public static void check(XYSeries openVals, XYSeries closeVals, XYSeries highVals, XYSeries lowVals) {
final int size = openVals.size();
assert closeVals.size() == size : "closeVals has irregular size.";
assert highVals.size() == size : "highVals has irregular size.";
assert lowVals.size() == size : "lowVals has irregular size.";
for(int i = 0; i < size; i++) {
final double highVal = highVals.getY(i).doubleValue();
final double lowVal = lowVals.getY(i).doubleValue();
final double openVal = openVals.getY(i).doubleValue();
final double closeVal = closeVals.getY(i).doubleValue();
assert openVal <= highVal : "Detected openVal > highVal at index " + i;
assert openVal >= lowVal : "Detected openVal < lowVal at index " + i;
assert closeVal <= highVal : "Detected closeVal > highVal at index " + i;
assert closeVal >= lowVal : "Detected closeVal < lowVal at index " + i;
assert lowVal <= highVal : "Detected lowVal > highVal at index " + i;
}
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/CandlestickRenderer.java 0000664 0000000 0000000 00000014116 12766537502 0032266 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.*;
import com.androidplot.ui.RenderStack;
import com.androidplot.ui.SeriesAndFormatter;
import com.androidplot.util.ValPixConverter;
import java.util.List;
/**
* Renders a group of {@link com.androidplot.xy.XYSeries} as a candlestick chart
* into an {@link com.androidplot.xy.XYPlot}.
*
* Constraints:
* - Exactly four series must be added using the same {@link CandlestickFormatter}.
* - Each of the four series has the same x(i) value.
* - Expects that series are added in the order of:
* high, low, open, close
*
* {@link CandlestickSeries} and {@link CandlestickMaker} provide simplified classes and methods
* for setting up a candlestick chart.
* @since 0.9.7
*/
public class CandlestickRenderer extends GroupRenderer {
private static final int HIGH_INDEX = 0;
private static final int LOW_INDEX = 1;
private static final int OPEN_INDEX = 2;
private static final int CLOSE_INDEX = 3;
public CandlestickRenderer(XYPlot plot) {
super(plot);
}
@Override
public void onRender(Canvas canvas, RectF plotArea, List> sfList, int seriesSize, RenderStack stack) {
for(int i = 0; i < seriesSize; i++) {
// x-val for all series should be identical so just grab x from the first series:
Number x = sfList.get(HIGH_INDEX).getSeries().getX(i);
Number high = sfList.get(HIGH_INDEX).getSeries().getY(i);
Number low = sfList.get(LOW_INDEX).getSeries().getY(i);
Number open = sfList.get(OPEN_INDEX).getSeries().getY(i);
Number close = sfList.get(CLOSE_INDEX).getSeries().getY(i);
drawValue(canvas, plotArea, sfList.get(0).getFormatter(), x, high, low, open, close);
}
}
protected void drawValue(Canvas canvas, RectF plotArea, FormatterType formatter,
Number x, Number high, Number low, Number open, Number close) {
final PointF highPix = ValPixConverter.valToPix(
x, high,
plotArea,
getPlot().getCalculatedMinX(),
getPlot().getCalculatedMaxX(),
getPlot().getCalculatedMinY(),
getPlot().getCalculatedMaxY());
final PointF lowPix = ValPixConverter.valToPix(
x, low,
plotArea,
getPlot().getCalculatedMinX(),
getPlot().getCalculatedMaxX(),
getPlot().getCalculatedMinY(),
getPlot().getCalculatedMaxY());
final PointF openPix = ValPixConverter.valToPix(
x, open,
plotArea,
getPlot().getCalculatedMinX(),
getPlot().getCalculatedMaxX(),
getPlot().getCalculatedMinY(),
getPlot().getCalculatedMaxY());
final PointF closePix = ValPixConverter.valToPix(
x, close,
plotArea,
getPlot().getCalculatedMinX(),
getPlot().getCalculatedMaxX(),
getPlot().getCalculatedMinY(),
getPlot().getCalculatedMaxY());
drawWick(canvas, highPix, lowPix, formatter);
drawBody(canvas, openPix, closePix, formatter);
drawUpperCap(canvas, highPix, formatter);
drawLowerCap(canvas, lowPix, formatter);
}
protected void drawWick(Canvas canvas, PointF min, PointF max, FormatterType formatter) {
canvas.drawLine(min.x, min.y, max.x, max.y, formatter.getWickPaint());
}
protected void drawBody(Canvas canvas, PointF open, PointF close, FormatterType formatter) {
final float halfWidth = formatter.getBodyWidth() / 2;
final RectF rect = new RectF(open.x - halfWidth, open.y, close.x + halfWidth, close.y);
Paint bodyFillPaint = open.y >= close.y ?
formatter.getRisingBodyFillPaint() : formatter.getFallingBodyFillPaint();
Paint bodyStrokePaint = open.y >= close.y ?
formatter.getRisingBodyStrokePaint() : formatter.getFallingBodyStrokePaint();
switch(formatter.getBodyStyle()) {
case Square:
canvas.drawRect(rect, bodyFillPaint);
canvas.drawRect(rect, bodyStrokePaint);
break;
case Triangle:
drawTriangle(canvas, rect, bodyFillPaint, bodyStrokePaint);
}
}
protected void drawUpperCap(Canvas canvas, PointF val, FormatterType formatter) {
final float halfWidth = formatter.getUpperCapWidth();
canvas.drawLine(val.x - halfWidth, val.y, val.x + halfWidth, val.y, formatter.getUpperCapPaint());
}
protected void drawLowerCap(Canvas canvas, PointF val, FormatterType formatter) {
final float halfWidth = formatter.getLowerCapWidth();
canvas.drawLine(val.x - halfWidth, val.y, val.x + halfWidth, val.y, formatter.getLowerCapPaint());
}
@Override
protected void doDrawLegendIcon(Canvas canvas, RectF rect, FormatterType formatter) {
// TODO
}
protected void drawTriangle(Canvas canvas, RectF rect,
Paint fillPaint, Paint strokePaint) {
Path path = new Path();
path.moveTo(rect.centerX(), rect.bottom);
path.lineTo(rect.left,rect.top);
path.lineTo(rect.right, rect.top);
path.close();
canvas.drawPath(path, fillPaint);
canvas.drawPath(path, strokePaint);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/CandlestickSeries.java 0000664 0000000 0000000 00000010643 12766537502 0031753 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 com.androidplot.xy.SimpleXYSeries;
import java.util.*;
/**
* Convenience class for representing a series of candlestick values;
* is NOT a descendant of {@link com.androidplot.xy.XYSeries} and therefore
* cannot be directly added to an {@link com.androidplot.xy.XYPlot}.
*
* This class is NOT threadsafe.
*
* @since 0.9.8
*/
public class CandlestickSeries {
private SimpleXYSeries highSeries = new SimpleXYSeries(null);
private SimpleXYSeries lowSeries = new SimpleXYSeries(null);
private SimpleXYSeries openSeries = new SimpleXYSeries(null);
private SimpleXYSeries closeSeries = new SimpleXYSeries(null);
protected static List generateRange(int start, int end) {
List range = new ArrayList<>(end - start);
for(int i = start; i < end; i++) {
range.add(i);
}
return range;
}
public CandlestickSeries(Item... items) {
this(Arrays.asList(items));
}
/**
* Creates a new CandlestickSeries.
* Calls {@link #CandlestickSeries(List, List)} with a list of xVals
* generated using the formula x=i.
* @param items
*/
public CandlestickSeries(List- items) {
this(generateRange(0, items.size()), items);
}
public CandlestickSeries(List xVals, List
- items) {
if(xVals.size() != items.size()) {
throw new IllegalArgumentException("xVals and yVals length must be identical.");
}
for(int i = 0; i < xVals.size(); i++) {
Number x = xVals.get(i);
highSeries.addLast(x, items.get(i).getHigh());
lowSeries.addLast(x, items.get(i).getLow());
openSeries.addLast(x, items.get(i).getOpen());
closeSeries.addLast(x, items.get(i).getClose());
}
}
public SimpleXYSeries getHighSeries() {
return highSeries;
}
public void setHighSeries(SimpleXYSeries highSeries) {
this.highSeries = highSeries;
}
public SimpleXYSeries getLowSeries() {
return lowSeries;
}
public void setLowSeries(SimpleXYSeries lowSeries) {
this.lowSeries = lowSeries;
}
public SimpleXYSeries getOpenSeries() {
return openSeries;
}
public void setOpenSeries(SimpleXYSeries openSeries) {
this.openSeries = openSeries;
}
public SimpleXYSeries getCloseSeries() {
return closeSeries;
}
public void setCloseSeries(SimpleXYSeries closeSeries) {
this.closeSeries = closeSeries;
}
public static class Item {
private double low;
private double high;
private double open;
private double close;
/**
* An individual candlestick value. Since it is illegal to include
* null values for any member of a candlestick, this class is modeled with
* double values instead of {@link Number} instances.
* @param low
* @param high
* @param open
* @param close
*/
public Item(double low, double high, double open, double close) {
this.low = low;
this.high = high;
this.open = open;
this.close = close;
}
public double getLow() {
return low;
}
public void setLow(double low) {
this.low = low;
}
public double getHigh() {
return high;
}
public void setHigh(double high) {
this.high = high;
}
public double getOpen() {
return open;
}
public void setOpen(double open) {
this.open = open;
}
public double getClose() {
return close;
}
public void setClose(double close) {
this.close = close;
}
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/CatmullRomInterpolator.java 0000664 0000000 0000000 00000024222 12766537502 0033034 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 XYCoords first;
private final XYCoords last;
private final XYSeries series;
public ExtrapolatedXYSeries(XYSeries series, XYCoords first, XYCoords 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.
XYCoords start = new XYCoords(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;
XYCoords end = new XYCoords(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 XYCoords(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 XYCoords(xi, yi));
}
result.add(new XYCoords(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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/FastLineAndPointRenderer.java 0000664 0000000 0000000 00000013704 12766537502 0033206 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.*;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.RenderStack;
import com.androidplot.ui.SeriesRenderer;
import com.androidplot.util.ValPixConverter;
import java.util.*;
/**
* A faster implementation of of {@link LineAndPointRenderer}. For performance reasons, has these constraints:
* - Interpolation is not supported
* - Does not draw fill
* @since 1.2.0
*/
public class FastLineAndPointRenderer extends XYSeriesRenderer {
private float[] points;
List segmentOffsets = new ArrayList<>();
List segmentLengths = new ArrayList<>();
public FastLineAndPointRenderer(XYPlot plot) {
super(plot);
}
@Override
protected void onRender(Canvas canvas, RectF plotArea, XYSeries series, Formatter formatter, RenderStack stack) throws PlotRenderException {
segmentOffsets.clear();
segmentLengths.clear();
final int numPoints = series.size() * 2;
if(points == null || points.length != numPoints) {
// only allocate when necessary:
points = new float[series.size()*2];
}
final Number minX = getPlot().getCalculatedMinX();
final Number maxX = getPlot().getCalculatedMaxX();
final Number minY = getPlot().getCalculatedMinY();
final Number maxY = getPlot().getCalculatedMaxY();
int segmentLen = 0;
boolean isLastPointNull = true;
for (int i = 0, j = 0; i < series.size(); i++, j+=2) {
Number y = series.getY(i);
Number x = series.getX(i);
PointF thisPoint;
if (y != null && x != null) {
if(isLastPointNull) {
segmentOffsets.add(j);
segmentLen = 0;
isLastPointNull = false;
}
thisPoint = ValPixConverter.valToPix(
x, y,
plotArea,
minX, maxX,
minY, maxY);
points[j] = thisPoint.x;
points[j+1] = thisPoint.y;
segmentLen+=2;
// if this is the last point, account for it in segment lengths:
if(i == series.size()-1) {
segmentLengths.add(segmentLen);
}
} else if(!isLastPointNull) {
segmentLengths.add(segmentLen);
isLastPointNull = true;
}
}
// draw segments
if(formatter.linePaint != null || formatter.vertexPaint != null) {
for (int i = 0; i < segmentOffsets.size(); i++) {
final int len = segmentLengths.get(i);
final int offset = segmentOffsets.get(i);
drawSegment(canvas, points, offset, len, formatter);
// if(formatter.vertexPaint != null) {
// // draw vertices:
// canvas.drawPoints(points, offset, len, formatter.vertexPaint);
// }
}
}
}
protected void drawSegment(Canvas canvas, float[] points, int offset, int len, Formatter formatter) {
if(formatter.linePaint != null) {
// draw lines:
if (len >= 4) {
// optimization to avoid using 2x storage space to represent the full path:
if ((len & 2) != 0) {
canvas.drawLines(points, offset, len - 2, formatter.linePaint);
canvas.drawLines(points, offset + 2, len - 2, formatter.linePaint);
} else {
canvas.drawLines(points, offset, len, formatter.linePaint);
canvas.drawLines(points, offset + 2, len - 4, formatter.linePaint);
}
}
}
if(formatter.vertexPaint != null) {
// draw vertices:
canvas.drawPoints(points, offset, len, formatter.vertexPaint);
}
}
@Override
protected void doDrawLegendIcon(Canvas canvas, RectF rect, Formatter formatter) {
if(formatter.getLinePaint() != null) {
canvas.drawLine(rect.left, rect.bottom, rect.right, rect.top, formatter.getLinePaint());
}
}
/**
* Formatter designed to work in tandem with {@link AdvancedLineAndPointRenderer}.
* @since 0.9.9
*/
public static class Formatter extends LineAndPointFormatter {
public Formatter(Integer lineColor, Integer vertexColor, Integer fillColor, PointLabelFormatter plf) {
super(lineColor, vertexColor, fillColor, plf);
}
public Formatter(Integer lineColor, Integer vertexColor,
Integer fillColor, PointLabelFormatter plf, FillDirection fillDir) {
super(lineColor, vertexColor, fillColor, plf, fillDir);
}
@Override
protected void initLinePaint(Integer lineColor) {
super.initLinePaint(lineColor);
// disable anti-aliasing by default:
getLinePaint().setAntiAlias(false);
}
@Override
public Class getRendererClass() {
return FastLineAndPointRenderer.class;
}
@Override
public SeriesRenderer getRendererInstance(XYPlot plot) {
return new FastLineAndPointRenderer(plot);
}
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/FillDirection.java 0000664 0000000 0000000 00000002253 12766537502 0031101 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/GroupRenderer.java 0000664 0000000 0000000 00000005625 12766537502 0031143 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/InterpolationParams.java 0000664 0000000 0000000 00000001476 12766537502 0032353 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 {
Class getInterpolatorClass();
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/Interpolator.java 0000664 0000000 0000000 00000001541 12766537502 0031033 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/LineAndPointFormatter.java 0000664 0000000 0000000 00000013560 12766537502 0032565 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/LineAndPointRenderer.java 0000664 0000000 0000000 00000024436 12766537502 0032374 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(XYCoords 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 = (float) 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/PanZoom.java 0000664 0000000 0000000 00000040041 12766537502 0027732 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import android.graphics.*;
import android.view.*;
import java.util.*;
/**
* Enables basic pan/zoom touch behavior for an {@link XYPlot}.
* TODO: zoom using dynamic center point
* TODO: stretch both mode
*/
public class PanZoom implements View.OnTouchListener {
private static final float MIN_DIST_2_FING = 5f;
private XYPlot plot;
private Pan pan;
private Zoom zoom;
private boolean isEnabled = true;
private DragState dragState = DragState.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;
// rectangle created by the space between two fingers
private RectF dist;
private boolean mCalledBySelf;
private View.OnTouchListener delegate;
// Definition of the touch states
protected enum DragState
{
NONE,
ONE_FINGER,
TWO_FINGERS
}
public enum Pan {
HORIZONTAL,
VERTICAL,
BOTH
}
public enum Zoom {
/**
* Zoom on the horizontal axis only
*/
STRETCH_HORIZONTAL,
/**
* Zoom on the vertical axis only
*/
STRETCH_VERTICAL,
/**
* Zoom on the vertical axis by the vertical distance between each finger, while zooming
* on the horizontal axis by the horizantal distance between each finger.
*/
STRETCH_BOTH,
/**
* Zoom each axis by the same amount, specifically the total distance between each finger.
*/
SCALE
}
protected PanZoom(XYPlot plot, Pan pan, Zoom zoom) {
this.plot = plot;
this.pan = pan;
this.zoom = zoom;
}
/**
* Convenience method for enabling pan/zoom behavior on an instance of {@link XYPlot}, using
* a default behavior of {@link Pan#BOTH} and {@link Zoom#SCALE}.
* Use {@link PanZoom#attach(XYPlot, Pan, Zoom)} for finer grain control of this behavior.
* @param plot
* @return
*/
public static PanZoom attach(XYPlot plot) {
return attach(plot, Pan.BOTH, Zoom.SCALE);
}
public static PanZoom attach(XYPlot plot, Pan pan, Zoom zoom) {
PanZoom pz = new PanZoom(plot, pan, zoom);
plot.setOnTouchListener(pz);
return pz;
}
public boolean isEnabled() {
return isEnabled;
}
public void setEnabled(boolean enabled) {
isEnabled = enabled;
}
protected void setDomainBoundaries(final Number lowerBoundary, final BoundaryMode lowerBoundaryMode,
final Number upperBoundary, final BoundaryMode upperBoundaryMode) {
plot.setDomainBoundaries(lowerBoundary, lowerBoundaryMode, upperBoundary, upperBoundaryMode);
if(mCalledBySelf) {
mCalledBySelf = false;
} else {
minXLimit = lowerBoundaryMode == BoundaryMode.FIXED ?
lowerBoundary.floatValue() : plot.getCalculatedMinX().floatValue();
maxXLimit = upperBoundaryMode == BoundaryMode.FIXED ?
upperBoundary.floatValue() : plot.getCalculatedMaxX().floatValue();
lastMinX = minXLimit;
lastMaxX = maxXLimit;
}
}
protected void setRangeBoundaries(final Number lowerBoundary, final BoundaryMode lowerBoundaryMode,
final Number upperBoundary, final BoundaryMode upperBoundaryMode) {
plot.setRangeBoundaries(lowerBoundary, lowerBoundaryMode, upperBoundary, upperBoundaryMode);
if(mCalledBySelf) {
mCalledBySelf = false;
} else {
minYLimit = lowerBoundaryMode == BoundaryMode.FIXED ?
lowerBoundary.floatValue() : plot.getCalculatedMinY().floatValue();
maxYLimit = upperBoundaryMode == BoundaryMode.FIXED ?
upperBoundary.floatValue() : plot.getCalculatedMaxY().floatValue();
lastMinY = minYLimit;
lastMaxY = maxYLimit;
}
}
protected void setDomainBoundaries(final Number lowerBoundary,
final Number upperBoundary, final BoundaryMode mode) {
plot.setDomainBoundaries(lowerBoundary, upperBoundary, mode);
if(mCalledBySelf) {
mCalledBySelf = false;
} else {
minXLimit = mode == BoundaryMode.FIXED ?
lowerBoundary.floatValue() : plot.getCalculatedMinX().floatValue();
maxXLimit = mode == BoundaryMode.FIXED ?
upperBoundary.floatValue() : plot.getCalculatedMaxX().floatValue();
lastMinX = minXLimit;
lastMaxX = maxXLimit;
}
}
protected synchronized void setRangeBoundaries(final Number lowerBoundary,
final Number upperBoundary, final BoundaryMode mode) {
plot.setRangeBoundaries(lowerBoundary, upperBoundary, mode);
if(mCalledBySelf) {
mCalledBySelf = false;
} else {
minYLimit = mode == BoundaryMode.FIXED ?
lowerBoundary.floatValue() : plot.getCalculatedMinY().floatValue();
maxYLimit = mode == BoundaryMode.FIXED ?
upperBoundary.floatValue() : plot.getCalculatedMaxY().floatValue();
lastMinY = minYLimit;
lastMaxY = maxYLimit;
}
}
@Override
public boolean onTouch(final View view, final MotionEvent event) {
boolean isConsumed = false;
if(delegate != null) {
isConsumed = delegate.onTouch(view, event);
}
if(isEnabled() && !isConsumed) {
switch (event.getAction() & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: // start gesture
firstFingerPos = new PointF(event.getX(), event.getY());
dragState = DragState.ONE_FINGER;
break;
case MotionEvent.ACTION_POINTER_DOWN: // second finger
{
dist = getDistance(event);
// the distance check is done to avoid false alarms
if (dist.width() > MIN_DIST_2_FING || dist.width() < -MIN_DIST_2_FING) {
dragState = DragState.TWO_FINGERS;
}
break;
}
case MotionEvent.ACTION_POINTER_UP: // end zoom
dragState = DragState.NONE;
break;
case MotionEvent.ACTION_MOVE:
if (dragState == DragState.ONE_FINGER) {
pan(event);
} else if (dragState == DragState.TWO_FINGERS) {
zoom(event);
}
break;
}
}
// we're forced to consume the event here as not consuming it will prevent future calls:
return true;
}
/**
* Calculates the distance between two finger motion events.
* @param evt
* @return
*/
private RectF getDistance(final MotionEvent evt) {
float left;
float right;
float top;
float bottom;
if(evt.getX(0) > evt.getX(1)) {
left = evt.getX(1);
right = evt.getX(0);
} else {
left = evt.getX(0);
right = evt.getX(1);
}
if(evt.getY(0) > evt.getY(1)) {
top = evt.getY(1);
bottom = evt.getY(0);
} else {
top = evt.getY(0);
bottom = evt.getY(1);
}
return new RectF(left, top, right, bottom);
}
private float getMinXLimit() {
if(minXLimit == Float.MAX_VALUE) {
minXLimit = plot.getCalculatedMinX().floatValue();
lastMinX = minXLimit;
}
return minXLimit;
}
protected float getMaxXLimit() {
if(maxXLimit == Float.MAX_VALUE) {
maxXLimit = plot.getCalculatedMaxX().floatValue();
lastMaxX = maxXLimit;
}
return maxXLimit;
}
protected float getMinYLimit() {
if(minYLimit == Float.MAX_VALUE) {
minYLimit = plot.getCalculatedMinY().floatValue();
lastMinY = minYLimit;
}
return minYLimit;
}
protected float getMaxYLimit() {
if(maxYLimit == Float.MAX_VALUE) {
maxYLimit = plot.getCalculatedMaxY().floatValue();
lastMaxY = maxYLimit;
}
return maxYLimit;
}
protected float getLastMinX() {
if(lastMinX == Float.MAX_VALUE) {
lastMinX = plot.getCalculatedMinX().floatValue();
}
return lastMinX;
}
protected float getLastMaxX() {
if(lastMaxX == Float.MAX_VALUE) {
lastMaxX = plot.getCalculatedMaxX().floatValue();
}
return lastMaxX;
}
protected float getLastMinY() {
if(lastMinY == Float.MAX_VALUE) {
lastMinY = plot.getCalculatedMinY().floatValue();
}
return lastMinY;
}
private float getLastMaxY() {
if(lastMaxY == Float.MAX_VALUE) {
lastMaxY = plot.getCalculatedMaxY().floatValue();
}
return lastMaxY;
}
protected 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(EnumSet.of(Pan.HORIZONTAL, Pan.BOTH).contains(pan)) {
calculatePan(oldFirstFinger, newX, true);
mCalledBySelf = true;
setDomainBoundaries(newX.x, newX.y, BoundaryMode.FIXED);
lastMinX = newX.x;
lastMaxX = newX.y;
}
if(EnumSet.of(Pan.VERTICAL, Pan.BOTH).contains(pan)) {
calculatePan(oldFirstFinger, newX, false);
mCalledBySelf = true;
setRangeBoundaries(newX.x, newX.y, BoundaryMode.FIXED);
lastMinY = newX.x;
lastMaxY = newX.y;
}
plot.redraw();
}
protected 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) / plot.getWidth());
} else {
newX.x = getLastMinY();
newX.y = getLastMaxY();
offset = -(oldFirstFinger.y - firstFingerPos.y) * ((newX.y - newX.x) / plot.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;
}
}
}
protected boolean isValidScale(float scale) {
if(Float.isInfinite(scale) || Float.isNaN(scale) || scale > -0.001 && scale < 0.001) {
return false;
}
return true;
}
protected void zoom(final MotionEvent motionEvent) {
final RectF oldDist = dist;
final RectF newDist = getDistance(motionEvent);
dist = newDist;
RectF newRect = new RectF();
float scaleX = 1;
float scaleY = 1;
switch(zoom) {
case STRETCH_HORIZONTAL:
scaleX = oldDist.width() / dist.width();
if(!isValidScale(scaleX)) {
return;
}
break;
case STRETCH_VERTICAL:
scaleY = oldDist.height() / dist.height();
if(!isValidScale(scaleY)) {
return;
}
break;
case STRETCH_BOTH:
scaleX = oldDist.width() / dist.width();
scaleY = oldDist.height() / dist.height();
if(!isValidScale(scaleX) || !isValidScale(scaleY)) {
return;
}
break;
case SCALE:
scaleX = oldDist.width() / dist.width();
scaleY = oldDist.height() / dist.height();
// use the greater value to scale each axis evenly:
if(scaleX > scaleY) {
scaleY = scaleX;
} else {
scaleX = scaleY;
}
if(!isValidScale(scaleX) || !isValidScale(scaleY)) {
return;
}
break;
}
if(EnumSet.of(
Zoom.STRETCH_HORIZONTAL,
Zoom.STRETCH_BOTH,
Zoom.SCALE).contains(zoom)) {
calculateZoom(newRect, scaleX, true);
mCalledBySelf = true;
setDomainBoundaries(newRect.left, newRect.right, BoundaryMode.FIXED);
lastMinX = newRect.left;
lastMaxX = newRect.right;
}
if(EnumSet.of(
Zoom.STRETCH_VERTICAL,
Zoom.STRETCH_BOTH,
Zoom.SCALE).contains(zoom)) {
calculateZoom(newRect, scaleY, false);
mCalledBySelf = true;
setRangeBoundaries(newRect.top, newRect.bottom, BoundaryMode.FIXED);
lastMinY = newRect.top;
lastMaxY = newRect.bottom;
}
plot.redraw();
}
protected void calculateZoom(RectF newRect, float scale, boolean isHorizontal) {
final float calcMax;
final float span;
if(isHorizontal) {
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;
if(isHorizontal) {
newRect.left = midPoint - offset;
newRect.right = midPoint + offset;
if(newRect.left < getMinXLimit()) {
newRect.left = getMinXLimit();
}
if(newRect.right > getMaxXLimit()) {
newRect.right = getMaxXLimit();
}
} else {
newRect.top = midPoint - offset;
newRect.bottom = midPoint + offset;
if(newRect.top < getMinYLimit()) {
newRect.top = getMinYLimit();
}
if(newRect.bottom > getMaxYLimit()) {
newRect.bottom = getMaxYLimit();
}
}
}
public Pan getPan() {
return pan;
}
public void setPan(Pan pan) {
this.pan = pan;
}
public Zoom getZoom() {
return zoom;
}
public void setZoom(Zoom zoom) {
this.zoom = zoom;
}
public View.OnTouchListener getDelegate() {
return delegate;
}
/**
* Set a delegate to receive onTouch calls before this class does. If the delegate wishes
* to consume the event, it should return true, otherwise it should return false. Returning
* false will not prevent future onTouch events from filtering through the delegate as it normally
* would when attaching directly to an instance of {@link View}.
* @param delegate
*/
public void setDelegate(View.OnTouchListener delegate) {
this.delegate = delegate;
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/PointLabelFormatter.java 0000664 0000000 0000000 00000004746 12766537502 0032300 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/PointLabeler.java 0000664 0000000 0000000 00000001344 12766537502 0030732 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 {
String getLabel(XYSeries series, int index);
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/RectRegion.java 0000664 0000000 0000000 00000015037 12766537502 0030417 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/SimpleXYSeries.java 0000664 0000000 0000000 00000022165 12766537502 0031243 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 XYCoords} with first equal to x-val and second equal to y-val.
*/
public XYCoords removeFirst() {
lock.writeLock().lock();
try {
if (size() <= 0) {
throw new NoSuchElementException();
}
return new XYCoords(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 XYCoords} with first equal to x-val and second equal to y-val.
*/
public XYCoords removeLast() {
lock.writeLock().lock();
try {
if (size() <= 0) {
throw new NoSuchElementException();
}
return new XYCoords(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);
}
public LinkedList getxVals() {
return xVals;
}
public LinkedList getyVals() {
return yVals;
}
/**
* Remove all values from the series
*/
public void clear() {
lock.writeLock().lock();
try {
xVals.clear();
yVals.clear();
} finally {
lock.writeLock().unlock();
}
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/Step.java 0000664 0000000 0000000 00000003042 12766537502 0027262 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 Step {
private final double stepCount;
private final double stepPix;
private final double stepVal;
//public XYStep() {}
public Step(double stepCount, double 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 double 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/StepFormatter.java 0000664 0000000 0000000 00000002541 12766537502 0031151 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/StepMode.java 0000664 0000000 0000000 00000001650 12766537502 0030072 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 lines.
*/
public enum StepMode {
SUBDIVIDE, // default
INCREMENT_BY_VAL,
INCREMENT_BY_PIXELS
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/StepModel.java 0000664 0000000 0000000 00000002242 12766537502 0030244 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 StepModel {
public StepModel(StepMode mode, double value) {
setMode(mode);
setValue(value);
}
private StepMode mode;
private double value;
public StepMode getMode() {
return mode;
}
public void setMode(StepMode mode) {
this.mode = mode;
}
public double getValue() {
return value;
}
public void setValue(double value) {
this.value = value;
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/StepRenderer.java 0000664 0000000 0000000 00000002264 12766537502 0030756 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, lastPoint.y);
path.lineTo(thisPoint.x, thisPoint.y);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/ValueMarker.java 0000664 0000000 0000000 00000007410 12766537502 0030570 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;
import com.androidplot.ui.TextOrientation;
/**
* 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;
}
private Number value;
private Paint linePaint;
private Paint textPaint;
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);
}
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;
}
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 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XValueMarker.java 0000664 0000000 0000000 00000003604 12766537502 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.xy;
import android.graphics.Paint;
import com.androidplot.ui.VerticalPositioning;
import com.androidplot.ui.VerticalPosition;
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 VerticalPosition(3, VerticalPositioning.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, VerticalPosition 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, VerticalPosition textPosition, int linePaint, int textPaint) {
super(value, text, textPosition, linePaint, textPaint);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYBounds.java 0000664 0000000 0000000 00000004653 12766537502 0030073 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYConstraints.java 0000664 0000000 0000000 00000011124 12766537502 0031137 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYCoords.java 0000664 0000000 0000000 00000001522 12766537502 0030062 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 XYCoords {
public Number x;
public Number y;
public XYCoords(Number x, Number y) {
this.x = x;
this.y = y;
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYFramingModel.java 0000664 0000000 0000000 00000001333 12766537502 0031175 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYGraphWidget.java 0000664 0000000 0000000 00000115407 12766537502 0031046 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.res.*;
import android.graphics.*;
import com.androidplot.*;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.*;
import com.androidplot.ui.widget.Widget;
import com.androidplot.util.*;
import java.text.DecimalFormat;
import java.text.Format;
import java.util.*;
/**
* Displays graphical data (lines, points, etc.) annotated with domain and range tick markers.
* The inner area of the graph upon which grid lines and points are rendered is called the "grid" area.
*/
public class XYGraphWidget extends Widget {
private static final int ZERO = 0;
private static final int ONE = 1;
private static final int TWO = 2;
/**
* Fudge factor used to compensate for double<->float precision loss.
*/
private static final float FUDGE = 0.00001f;
private static final float DEFAULT_LINE_LABEL_TEXT_SIZE_PX = PixelUtils.spToPix(15);
private static final int MARKER_LABEL_SPACING = TWO;
/**
* Line interval per range label
*/
private int linesPerRangeLabel = ONE;
/**
* Line interval per domain label
*/
private int linesPerDomainLabel = ONE;
private Insets gridInsets = new Insets();
/**
* Insets defining the positioning of line labels relative to the edges of the graph
*/
private Insets lineLabelInsets = new Insets();
private RectF gridRect;
private RectF labelRect;
/**
* how far lines extend on labeled "tick" lines
*/
private float lineExtensionTop;
private float lineExtensionBottom;
private float lineExtensionLeft;
private float lineExtensionRight;
/**
* Background color of the grid area
*/
private Paint gridBackgroundPaint;
/**
* Color of range grid lines
*/
private Paint rangeGridLinePaint;
/**
* Color of range sub-grid lines
*/
private Paint rangeSubGridLinePaint;
/**
* Color of domain grid lines
*/
private Paint domainGridLinePaint;
/**
* Color of domain sub-grid lines
*/
private Paint domainSubGridLinePaint;
private boolean isGridClippingEnabled = true;
private Paint domainCursorPaint;
private Paint rangeCursorPaint;
private XYPlot plot;
private Paint domainOriginLinePaint;
private Paint rangeOriginLinePaint;
private float domainCursorPosition;
private float rangeCursorPosition;
private boolean drawMarkersEnabled = true;
private boolean drawGridOnTop;
/**
* Set of edges for which line labels should be displayed
*/
private Set lineLabelEdges = new HashSet<>();
private RenderStack renderStack;
private CursorLabelFormatter cursorLabelFormatter;
private HashMap lineLabelStyles = getDefaultLineLabelStyles();
private HashMap lineLabelRenderers = getDefaultLineLabelRenderers();
public float getLineExtensionTop() {
return lineExtensionTop;
}
public void setLineExtensionTop(float lineExtensionTop) {
this.lineExtensionTop = lineExtensionTop;
}
public float getLineExtensionBottom() {
return lineExtensionBottom;
}
public void setLineExtensionBottom(float lineExtensionBottom) {
this.lineExtensionBottom = lineExtensionBottom;
}
public float getLineExtensionLeft() {
return lineExtensionLeft;
}
public void setLineExtensionLeft(float lineExtensionLeft) {
this.lineExtensionLeft = lineExtensionLeft;
}
public float getLineExtensionRight() {
return lineExtensionRight;
}
public void setLineExtensionRight(float lineExtensionRight) {
this.lineExtensionRight = lineExtensionRight;
}
public static class LineLabelRenderer {
public void drawLabel(Canvas canvas, LineLabelStyle style, Number val, float x, float y, boolean isOrigin) {
final int canvasState = canvas.save();
try {
final String txt = style.format.format(val.doubleValue());
canvas.rotate(style.getRotation(), x, y);
drawLabel(canvas, txt, style.getPaint(), x, y, isOrigin);
} finally {
canvas.restoreToCount(canvasState);
}
}
protected void drawLabel(Canvas canvas, String text, Paint paint, float x, float y, boolean isOrigin) {
canvas.drawText(text, x, y, paint);
}
}
public static class LineLabelStyle {
private Paint paint = new Paint();
private float rotation = 0;
private Format format = new DecimalFormat("0.0");
{
paint.setColor(Color.LTGRAY);
paint.setAntiAlias(true);
paint.setTextAlign(Paint.Align.CENTER);
paint.setTextSize(DEFAULT_LINE_LABEL_TEXT_SIZE_PX);
}
public Format getFormat() {
return format;
}
public void setFormat(Format format) {
this.format = format;
}
public float getRotation() {
return rotation;
}
public void setRotation(float rotation) {
this.rotation = rotation;
}
public Paint getPaint() {
return paint;
}
public void setPaint(Paint paint) {
this.paint = paint;
}
}
protected HashMap getDefaultLineLabelStyles() {
HashMap defaults = new HashMap<>();
defaults.put(Edge.TOP, new LineLabelStyle());
defaults.put(Edge.BOTTOM, new LineLabelStyle());
defaults.put(Edge.LEFT, new LineLabelStyle());
defaults.put(Edge.RIGHT, new LineLabelStyle());
return defaults;
}
protected HashMap getDefaultLineLabelRenderers() {
HashMap defaults = new HashMap<>();
defaults.put(Edge.TOP, new LineLabelRenderer());
defaults.put(Edge.BOTTOM, new LineLabelRenderer());
defaults.put(Edge.LEFT, new LineLabelRenderer());
defaults.put(Edge.RIGHT, new LineLabelRenderer());
return defaults;
}
public LineLabelRenderer getLineLabelRenderer(Edge edge) {
return lineLabelRenderers.get(edge);
}
public void setLineLabelRenderer(Edge edge, LineLabelRenderer renderer) {
lineLabelRenderers.put(edge, renderer);
}
public LineLabelStyle getLineLabelStyle(Edge edge) {
return lineLabelStyles.get(edge);
}
public void setLineLabelStyle(Edge edge, LineLabelStyle style) {
lineLabelStyles.put(edge, style);
}
public CursorLabelFormatter getCursorLabelFormatter() {
return cursorLabelFormatter;
}
public void setCursorLabelFormatter(
CursorLabelFormatter cursorLabelFormatter) {
this.cursorLabelFormatter = cursorLabelFormatter;
}
public interface CursorLabelFormatter {
/**
*
* @return The Paint to be used to draw the cursor text label.
*/
Paint getTextPaint();
/**
*
* @return Null if no background should be drawn,
* the Paint used to draw the background otherwise.
*/
Paint getBackgroundPaint();
String getLabelText(Number x, Number y);
}
/**
* Apply xml attrs
* @param attrs
*/
public void processAttrs(TypedArray attrs) {
setDrawGridOnTop(attrs.getBoolean(R.styleable.xy_XYPlot_drawGridOnTop, isDrawGridOnTop()));
int tlp = attrs.getInt(R.styleable.xy_XYPlot_lineLabels, 0);
if(tlp != 0) {
setLineLabelEdges(tlp);
}
setGridClippingEnabled(attrs.getBoolean(R.styleable.xy_XYPlot_gridClippingEnabled,
isGridClippingEnabled()));
final LineLabelStyle lineLabelStyleTop = getLineLabelStyle(Edge.TOP);
final LineLabelStyle lineLabelStyleBottom = getLineLabelStyle(Edge.BOTTOM);
final LineLabelStyle lineLabelStyleLeft = getLineLabelStyle(Edge.LEFT);
final LineLabelStyle lineLabelStyleRight = getLineLabelStyle(Edge.RIGHT);
lineLabelStyleTop.setRotation(attrs.getFloat(
R.styleable.xy_XYPlot_lineLabelRotationTop,
lineLabelStyleTop.getRotation()));
lineLabelStyleBottom.setRotation(attrs.getFloat(
R.styleable.xy_XYPlot_lineLabelRotationBottom,
lineLabelStyleBottom.getRotation()));
lineLabelStyleLeft.setRotation(attrs.getFloat(
R.styleable.xy_XYPlot_lineLabelRotationLeft,
lineLabelStyleLeft.getRotation()));
lineLabelStyleRight.setRotation(attrs.getFloat(
R.styleable.xy_XYPlot_lineLabelRotationRight,
lineLabelStyleRight.getRotation()));
setLineExtensionTop(attrs.getDimension(
R.styleable.xy_XYPlot_lineExtensionTop, getLineExtensionTop()));
setLineExtensionBottom(attrs.getDimension(
R.styleable.xy_XYPlot_lineExtensionBottom, getLineExtensionBottom()));
setLineExtensionLeft(attrs.getDimension(
R.styleable.xy_XYPlot_lineExtensionLeft, getLineExtensionLeft()));
setLineExtensionRight(attrs.getDimension(
R.styleable.xy_XYPlot_lineExtensionRight, getLineExtensionRight()));
AttrUtils.configureTextPaint(attrs, lineLabelStyleTop.getPaint(),
R.styleable.xy_XYPlot_lineLabelTextColorTop,
R.styleable.xy_XYPlot_lineLabelTextSizeTop,
R.styleable.xy_XYPlot_lineLabelAlignTop);
AttrUtils.configureTextPaint(attrs, lineLabelStyleBottom.getPaint(),
R.styleable.xy_XYPlot_lineLabelTextColorBottom,
R.styleable.xy_XYPlot_lineLabelTextSizeBottom,
R.styleable.xy_XYPlot_lineLabelAlignBottom);
AttrUtils.configureTextPaint(attrs, lineLabelStyleLeft.getPaint(),
R.styleable.xy_XYPlot_lineLabelTextColorLeft,
R.styleable.xy_XYPlot_lineLabelTextSizeLeft,
R.styleable.xy_XYPlot_lineLabelAlignLeft);
AttrUtils.configureTextPaint(attrs, lineLabelStyleRight.getPaint(),
R.styleable.xy_XYPlot_lineLabelTextColorRight,
R.styleable.xy_XYPlot_lineLabelTextSizeRight,
R.styleable.xy_XYPlot_lineLabelAlignRight);
AttrUtils.configureInsets(attrs, getGridInsets(),
R.styleable.xy_XYPlot_gridInsetTop,
R.styleable.xy_XYPlot_gridInsetBottom,
R.styleable.xy_XYPlot_gridInsetLeft,
R.styleable.xy_XYPlot_gridInsetRight);
AttrUtils.configureInsets(attrs, getLineLabelInsets(),
R.styleable.xy_XYPlot_lineLabelInsetTop,
R.styleable.xy_XYPlot_lineLabelInsetBottom,
R.styleable.xy_XYPlot_lineLabelInsetLeft,
R.styleable.xy_XYPlot_lineLabelInsetRight);
// graph size & position
AttrUtils.configureWidget(attrs, this,
R.styleable.xy_XYPlot_graphHeightMode, R.styleable.xy_XYPlot_graphHeight,
R.styleable.xy_XYPlot_graphWidthMode, R.styleable.xy_XYPlot_graphWidth,
R.styleable.xy_XYPlot_graphHorizontalPositioning, R.styleable.xy_XYPlot_graphHorizontalPosition,
R.styleable.xy_XYPlot_graphVerticalPositioning, R.styleable.xy_XYPlot_graphVerticalPosition,
R.styleable.xy_XYPlot_graphAnchor, R.styleable.xy_XYPlot_graphVisible);
// domainLabel size & position
AttrUtils.configureWidget(attrs, this,
R.styleable.xy_XYPlot_domainTitleHeightMode, R.styleable.xy_XYPlot_domainTitleHeight,
R.styleable.xy_XYPlot_domainTitleWidthMode, R.styleable.xy_XYPlot_domainTitleWidth,
R.styleable.xy_XYPlot_domainTitleHorizontalPositioning, R.styleable.xy_XYPlot_domainTitleHorizontalPosition,
R.styleable.xy_XYPlot_domainTitleVerticalPositioning, R.styleable.xy_XYPlot_domainTitleVerticalPosition,
R.styleable.xy_XYPlot_domainTitleAnchor, R.styleable.xy_XYPlot_domainTitleVisible);
// rangeLabel size & position
AttrUtils.configureWidget(attrs, this,
R.styleable.xy_XYPlot_rangeTitleHeightMode, R.styleable.xy_XYPlot_rangeTitleHeight,
R.styleable.xy_XYPlot_rangeTitleWidthMode, R.styleable.xy_XYPlot_rangeTitleWidth,
R.styleable.xy_XYPlot_rangeTitleHorizontalPositioning, R.styleable.xy_XYPlot_rangeTitleHorizontalPosition,
R.styleable.xy_XYPlot_rangeTitleVerticalPositioning, R.styleable.xy_XYPlot_rangeTitleVerticalPosition,
R.styleable.xy_XYPlot_rangeTitleAnchor, R.styleable.xy_XYPlot_rangeTitleVisible);
// graphWidget
AttrUtils.configureBoxModelable(attrs, this,
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);
// domainOriginLinePaint
AttrUtils.configureLinePaint(attrs, getDomainOriginLinePaint(),
R.styleable.xy_XYPlot_domainOriginLineColor,
R.styleable.xy_XYPlot_domainOriginLineThickness);
// rangeOriginLinePaint
AttrUtils.configureLinePaint(attrs, getRangeOriginLinePaint(),
R.styleable.xy_XYPlot_rangeOriginLineColor,
R.styleable.xy_XYPlot_rangeOriginLineThickness);
AttrUtils.configureLinePaint(attrs, getDomainGridLinePaint(),
R.styleable.xy_XYPlot_domainLineColor,
R.styleable.xy_XYPlot_domainLineThickness);
AttrUtils.configureLinePaint(attrs, getRangeGridLinePaint(),
R.styleable.xy_XYPlot_rangeLineColor,
R.styleable.xy_XYPlot_rangeLineThickness);
getBackgroundPaint().setColor(attrs.getColor(
R.styleable.xy_XYPlot_graphBackgroundColor,
getBackgroundPaint().getColor()));
getGridBackgroundPaint().setColor(attrs.getColor(
R.styleable.xy_XYPlot_gridBackgroundColor,
getGridBackgroundPaint().getColor()));
}
/**
* Grid insets
*/
public Insets getGridInsets() {
return gridInsets;
}
public void setGridInsets(Insets gridInsets) {
this.gridInsets = gridInsets;
}
/**
* Domain / Range label insets
*/
public Insets getLineLabelInsets() {
return lineLabelInsets;
}
public void setLineLabelInsets(Insets lineLabelInsets) {
this.lineLabelInsets = lineLabelInsets;
}
public RectF getGridRect() {
return gridRect;
}
public void setGridRect(RectF gridRect) {
this.gridRect = gridRect;
}
public RectF getLabelRect() {
return labelRect;
}
public void setLabelRect(RectF labelRect) {
this.labelRect = labelRect;
}
public boolean isGridClippingEnabled() {
return isGridClippingEnabled;
}
public void setGridClippingEnabled(boolean gridClippingEnabled) {
isGridClippingEnabled = gridClippingEnabled;
}
public boolean isLineLabelEnabled(Edge position) {
return lineLabelEdges.contains(position);
}
public void setLineLabelEdges(Edge... positions) {
Set positionSet = new HashSet<>();
if(positions != null) {
for(Edge position : positions) {
positionSet.add(position);
}
}
setLineLabelEdges(positionSet);
}
public void setLineLabelEdges(Set positions) {
this.lineLabelEdges = positions;
}
protected void setLineLabelEdges(int bitfield) {
for(Edge tp : Edge.values()) {
if((tp.value & bitfield) == tp.value) {
lineLabelEdges.add(tp);
}
}
}
public enum Edge {
LEFT(1),
RIGHT(2),
TOP(4),
BOTTOM(8);
private final int value;
Edge(int value) {
this.value = value;
}
public int getValue() {
return value;
}
}
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);
final Paint defaultLinePaint = new Paint();
defaultLinePaint.setColor(Color.rgb(180, 180, 180));
defaultLinePaint.setAntiAlias(true);
defaultLinePaint.setStyle(Paint.Style.STROKE);
rangeGridLinePaint = new Paint(defaultLinePaint);
domainGridLinePaint = new Paint(defaultLinePaint);
domainSubGridLinePaint = new Paint(defaultLinePaint);
rangeSubGridLinePaint = new Paint(defaultLinePaint);
domainOriginLinePaint = new Paint(defaultLinePaint);
rangeOriginLinePaint = new Paint(defaultLinePaint);
domainCursorPaint = new Paint();
domainCursorPaint.setColor(Color.YELLOW);
rangeCursorPaint = new Paint();
rangeCursorPaint.setColor(Color.YELLOW);
setMarginTop(7);
setMarginRight(4);
setMarginBottom(4);
setClippingEnabled(true);
}
public XYGraphWidget(LayoutManager layoutManager, XYPlot plot, Size size) {
super(layoutManager, size);
this.plot = plot;
renderStack = new RenderStack(plot);
}
/**
* 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 - gridRect.top, plot
.getCalculatedMinY().doubleValue(), plot.getCalculatedMaxY()
.doubleValue(), gridRect.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 - gridRect.left, plot
.getCalculatedMinX().doubleValue(), plot.getCalculatedMaxX()
.doubleValue(), gridRect.width(), false);
}
@Override
protected void doOnDraw(Canvas canvas, RectF widgetRect)
throws PlotRenderException {
if(gridRect == null) {
gridRect = RectFUtils.applyInsets(widgetRect, gridInsets);
}
if(labelRect == null) {
labelRect = RectFUtils.applyInsets(widgetRect, lineLabelInsets);
}
// don't draw if we have no space to draw into
if (gridRect.height() > ZERO && gridRect.width() > ZERO) {
if (plot.getCalculatedMinX() != null
&& plot.getCalculatedMaxX() != null
&& plot.getCalculatedMinY() != null
&& plot.getCalculatedMaxY() != null) {
if(drawGridOnTop) {
drawData(canvas);
drawGrid(canvas);
} else {
drawGrid(canvas);
drawData(canvas);
}
drawCursors(canvas);
if (isDrawMarkersEnabled()) {
drawMarkers(canvas);
}
}
}
}
private void drawDomainLine(Canvas canvas, float xPix, Number xVal,
Paint linePaint, boolean isOrigin) {
// lines
if (linePaint != null) {
canvas.drawLine(xPix, gridRect.top - lineExtensionTop,
xPix, gridRect.bottom + lineExtensionBottom, linePaint);
}
// labels
drawLineLabel(canvas, Edge.TOP, xVal, xPix, labelRect.top, isOrigin);
drawLineLabel(canvas, Edge.BOTTOM, xVal, xPix, labelRect.bottom, isOrigin);
}
public void drawRangeLine(Canvas canvas, float yPix, Number yVal,
Paint linePaint, boolean isOrigin) {
// lines
if (linePaint != null) {
canvas.drawLine(gridRect.left - lineExtensionLeft, yPix,
gridRect.right + lineExtensionRight, yPix, linePaint);
}
// labels
drawLineLabel(canvas, Edge.LEFT, yVal, labelRect.left, yPix, isOrigin);
drawLineLabel(canvas, Edge.RIGHT, yVal, labelRect.right, yPix, isOrigin);
}
protected void drawLineLabel(Canvas canvas, Edge edge, Number val, float x, float y, boolean isOrigin) {
if(isLineLabelEnabled(edge)) {
getLineLabelRenderer(edge).drawLabel(canvas, getLineLabelStyle(edge), val, x, y, isOrigin);
}
}
/**
* Draws the drid and domain/range labels for the plot.
*
* @param canvas
*/
protected void drawGrid(Canvas canvas) {
if(!drawGridOnTop) {
drawGridBackground(canvas);
}
double domainOrigin;
if (plot.getDomainOrigin() != null) {
double domainOriginVal = plot.getDomainOrigin().doubleValue();
domainOrigin = ValPixConverter.valToPix(domainOriginVal, plot
.getCalculatedMinX().doubleValue(), plot
.getCalculatedMaxX().doubleValue(), gridRect.width(),
false);
domainOrigin += gridRect.left;
// if no origin is set, use the leftmost value visible on the grid:
} else {
domainOrigin = gridRect.left;
}
Step domainStep = XYStepCalculator.getStep(plot, Axis.DOMAIN,
gridRect, plot.getCalculatedMinX().doubleValue(), plot
.getCalculatedMaxX().doubleValue());
// draw domain origin:
if (domainOrigin >= gridRect.left
&& domainOrigin <= gridRect.right) {
drawDomainLine(canvas, (float) domainOrigin, plot.getDomainOrigin()
.doubleValue(), domainOriginLinePaint, true);
}
// draw lines LEFT of origin:
double xPix = domainOrigin - domainStep.getStepPix();
for (int i = ONE; xPix >= gridRect.left - FUDGE; xPix = domainOrigin
- (i * domainStep.getStepPix())) {
double xVal = plot.getDomainOrigin().doubleValue() - i
* domainStep.getStepVal();
if (xPix <= gridRect.right) {
final boolean isDomainTick = i% getLinesPerDomainLabel() == ZERO;
final Paint lp = isDomainTick ? domainGridLinePaint : domainSubGridLinePaint;
drawDomainLine(canvas, (float) xPix, xVal, lp, false);
}
i++;
}
// draw lines RIGHT of origin:
xPix = domainOrigin + domainStep.getStepPix();
for (int i = ONE; xPix <= gridRect.right + FUDGE; xPix = domainOrigin
+ (i * domainStep.getStepPix())) {
double xVal = plot.getDomainOrigin().doubleValue() + i
* domainStep.getStepVal();
if (xPix >= gridRect.left) {
final boolean isDomainTick = i% getLinesPerDomainLabel() == ZERO;
final Paint lp = isDomainTick ? domainGridLinePaint : domainSubGridLinePaint;
drawDomainLine(canvas, (float) xPix, xVal, lp, false);
}
i++;
}
double rangeOrigin;
if (plot.getRangeOrigin() != null) {
double rangeOriginD = plot.getRangeOrigin().doubleValue();
rangeOrigin = ValPixConverter.valToPix(rangeOriginD, plot
.getCalculatedMinY().doubleValue(), plot
.getCalculatedMaxY().doubleValue(),
gridRect.height(), true);
rangeOrigin += gridRect.top;
// if no origin is set, use the leftmost value visible on the grid
} else {
rangeOrigin = gridRect.bottom;
}
Step rangeStep = XYStepCalculator.getStep(plot, Axis.RANGE,
gridRect, plot.getCalculatedMinY().doubleValue(), plot
.getCalculatedMaxY().doubleValue());
// draw range origin:
if (rangeOrigin >= gridRect.top && rangeOrigin <= gridRect.bottom) {
drawRangeLine(canvas, (float) rangeOrigin, plot.getRangeOrigin()
.doubleValue(), rangeOriginLinePaint, true);
}
final double rangeStepPix = rangeStep.getStepPix();
// draw lines ABOVE origin:
double yPix = rangeOrigin - rangeStep.getStepPix();
for (int i = ONE; yPix >= gridRect.top - FUDGE; yPix = rangeOrigin - (i * rangeStepPix)) {
double yVal = plot.getRangeOrigin().doubleValue() + i
* rangeStep.getStepVal();
if (yPix <= gridRect.bottom) {
final boolean isRangeTick = i% getLinesPerRangeLabel() == ZERO;
final Paint lp = isRangeTick ? rangeGridLinePaint : rangeSubGridLinePaint;
drawRangeLine(canvas, (float)yPix, yVal, lp, false);
}
i++;
}
// draw lines BENEATH origin:
yPix = rangeOrigin + rangeStep.getStepPix();
for (int i = ONE; yPix <= gridRect.bottom + FUDGE; yPix = rangeOrigin + (i * rangeStepPix)) {
double yVal = plot.getRangeOrigin().doubleValue() - i
* rangeStep.getStepVal();
if (yPix >= gridRect.top) {
final boolean isRangeTick = i% getLinesPerRangeLabel() == ZERO;
final Paint lp = isRangeTick ? rangeGridLinePaint : rangeSubGridLinePaint;
drawRangeLine(canvas, (float)yPix, yVal, lp, false);
}
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) {
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 > gridRect.right) {
textRect.offset(-(textRect.right - gridRect.right), ZERO);
}
if (textRect.top < gridRect.top) {
textRect.offset(0, gridRect.top - textRect.top);
}
canvas.drawText(text, textRect.left, textRect.bottom,
marker.getTextPaint());
}
protected void drawMarkers(Canvas canvas) {
for (YValueMarker marker : plot.getYValueMarkers()) {
if (marker.getValue() != null) {
double yVal = marker.getValue().doubleValue();
float yPix = (float) ValPixConverter.valToPix(yVal, plot
.getCalculatedMinY().doubleValue(), plot
.getCalculatedMaxY().doubleValue(), gridRect.height(), true);
yPix += gridRect.top;
canvas.drawLine(gridRect.left, yPix,
gridRect.right, yPix, marker.getLinePaint());
float xPix = marker.getTextPosition().getPixelValue(
gridRect.width());
xPix += gridRect.left;
if (marker.getText() != null) {
drawMarkerText(canvas, marker.getText(), marker, xPix, yPix);
}
}
}
for (XValueMarker marker : plot.getXValueMarkers()) {
if (marker.getValue() != null) {
double xVal = marker.getValue().doubleValue();
float xPix = (float) ValPixConverter.valToPix(xVal, plot
.getCalculatedMinX().doubleValue(), plot
.getCalculatedMaxX().doubleValue(), gridRect.width(), false);
xPix += gridRect.left;
canvas.drawLine(xPix, gridRect.top, xPix, gridRect.bottom, marker.getLinePaint());
float yPix = marker.getTextPosition().getPixelValue(gridRect.height());
yPix += gridRect.top;
if (marker.getText() != null) {
drawMarkerText(canvas, marker.getText(), marker, xPix, yPix);
}
}
}
}
protected void drawCursors(Canvas canvas) {
boolean hasDomainCursor = false;
// draw the domain cursor:
if (domainCursorPaint != null
&& domainCursorPosition <= gridRect.right
&& domainCursorPosition >= gridRect.left) {
hasDomainCursor = true;
canvas.drawLine(domainCursorPosition, gridRect.top,
domainCursorPosition, gridRect.bottom,
domainCursorPaint);
}
boolean hasRangeCursor = false;
// draw the range cursor:
if (rangeCursorPaint != null
&& rangeCursorPosition >= gridRect.top
&& rangeCursorPosition <= gridRect.bottom) {
hasRangeCursor = true;
canvas.drawLine(gridRect.left, rangeCursorPosition,
gridRect.right, rangeCursorPosition, rangeCursorPaint);
}
if(getCursorLabelFormatter() != null && hasRangeCursor && hasDomainCursor) {
final String label = getCursorLabelFormatter().
getLabelText(getDomainCursorVal(), getRangeCursorVal());
// convert the label dimensions rect into floating-point:
RectF cursorRect = new RectF(FontUtils.getPackedStringDimensions(
label, getCursorLabelFormatter().getTextPaint()));
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 >= gridRect.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 <= gridRect.top) {
cursorRect.offsetTo(cursorRect.left, rangeCursorPosition);
}
if (getCursorLabelFormatter().getBackgroundPaint() != null) {
canvas.drawRect(cursorRect, getCursorLabelFormatter().getBackgroundPaint());
}
canvas.drawText(label, cursorRect.left, cursorRect.bottom,
getCursorLabelFormatter().getTextPaint());
}
}
protected void drawGridBackground(Canvas canvas) {
if(gridBackgroundPaint != null) {
canvas.drawRect(gridRect, gridBackgroundPaint);
}
}
/**
* Draws lines and points for each element in the series.
*
* @param canvas
* @throws PlotRenderException
*/
protected void drawData(Canvas canvas) throws PlotRenderException {
if (drawGridOnTop) {
drawGridBackground(canvas);
}
try {
if(isGridClippingEnabled) {
canvas.save(Canvas.ALL_SAVE_FLAG);
canvas.clipRect(gridRect, android.graphics.Region.Op.INTERSECT);
}
renderStack.sync();
for(RenderStack.StackElement thisElement : renderStack.getElements()) {
if(thisElement.isEnabled()) {
Class rendererClass =
thisElement.get().getFormatter().getRendererClass();
plot.getRenderer(rendererClass).render(
canvas, gridRect, thisElement.get(), renderStack);
}
}
} finally {
if(isGridClippingEnabled) {
canvas.restore();
}
}
}
protected void drawPoint(Canvas canvas, PointF point, Paint paint) {
canvas.drawPoint(point.x, point.y, paint);
}
public Paint getGridBackgroundPaint() {
return gridBackgroundPaint;
}
public void setGridBackgroundPaint(Paint gridBackgroundPaint) {
this.gridBackgroundPaint = gridBackgroundPaint;
}
/**
* 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;
}
public int getLinesPerRangeLabel() {
return linesPerRangeLabel;
}
public void setLinesPerRangeLabel(int linesPerRangeLabel) {
this.linesPerRangeLabel = linesPerRangeLabel;
}
public int getLinesPerDomainLabel() {
return linesPerDomainLabel;
}
public void setLinesPerDomainLabel(int linesPerDomainLabel) {
this.linesPerDomainLabel = linesPerDomainLabel;
}
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 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 boolean isDrawGridOnTop() {
return drawGridOnTop;
}
public void setDrawGridOnTop(boolean drawGridOnTop) {
this.drawGridOnTop = drawGridOnTop;
}
public boolean isDrawMarkersEnabled() {
return drawMarkersEnabled;
}
public void setDrawMarkersEnabled(boolean drawMarkersEnabled) {
this.drawMarkersEnabled = drawMarkersEnabled;
}
/**
* Checks whether the point exists within the visible grid space.
*
* @param x
* @param y
* @return
* @since 1.0
*/
public boolean containsPoint(float x, float y) {
if (gridRect != null) {
return gridRect.contains(x, y);
}
return false;
}
} androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYLegendWidget.java 0000664 0000000 0000000 00000020344 12766537502 0031176 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.*;
/**
* Displays a legend for each series added to the owning {@link XYPlot}.
*/
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.getGraph().getGridBackgroundPaint();
if(drawIconBackgroundEnabled && bgPaint != null) {
canvas.drawRect(iconRect, bgPaint);
}
}
private void finishDrawingCell(Canvas canvas, RectF cellRect, RectF iconRect, String text) {
Paint bgPaint = plot.getGraph().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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYPlot.java 0000664 0000000 0000000 00000122377 12766537502 0027563 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.TextOrientation;
import com.androidplot.ui.widget.TextLabelWidget;
import com.androidplot.util.AttrUtils;
import com.androidplot.util.PixelUtils;
import com.androidplot.util.SeriesUtils;
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_PLOT_LEFT_MARGIN_DP = 1;
private static final int DEFAULT_PLOT_RIGHT_MARGIN_DP = 1;
private static final int DEFAULT_PLOT_TOP_MARGIN_DP = 1;
private static final int DEFAULT_PLOT_BOTTOM_MARGIN_DP = 1;
private BoundaryMode domainOriginBoundaryMode;
private BoundaryMode rangeOriginBoundaryMode;
// widgets
private XYLegendWidget legend;
private XYGraphWidget graph;
private TextLabelWidget domainTitle;
private TextLabelWidget rangeTitle;
private StepModel domainStepModel;
private StepModel 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;
private PreviewMode previewMode;
public enum PreviewMode {
LineAndPoint,
Candlestick,
Bar
}
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() {
legend = new XYLegendWidget(
getLayoutManager(),
this,
new Size(
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_H_DP),
SizeMode.ABSOLUTE, 0.5f, SizeMode.RELATIVE),
new DynamicTableModel(0, 1),
new Size(
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_ICON_SIZE_DP),
SizeMode.ABSOLUTE,
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_ICON_SIZE_DP),
SizeMode.ABSOLUTE));
graph = new XYGraphWidget(
getLayoutManager(),
this,
new Size(
PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_H_DP),
SizeMode.FILL,
PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_W_DP),
SizeMode.FILL));
Paint backgroundPaint = new Paint();
backgroundPaint.setColor(Color.DKGRAY);
backgroundPaint.setStyle(Paint.Style.FILL);
graph.setBackgroundPaint(backgroundPaint);
domainTitle = new TextLabelWidget(
getLayoutManager(),
new Size(
PixelUtils.dpToPix(DEFAULT_DOMAIN_LABEL_WIDGET_H_DP),
SizeMode.ABSOLUTE,
PixelUtils.dpToPix(DEFAULT_DOMAIN_LABEL_WIDGET_W_DP),
SizeMode.ABSOLUTE),
TextOrientation.HORIZONTAL);
rangeTitle = new TextLabelWidget(
getLayoutManager(),
new Size(
PixelUtils.dpToPix(DEFAULT_RANGE_LABEL_WIDGET_H_DP),
SizeMode.ABSOLUTE,
PixelUtils.dpToPix(DEFAULT_RANGE_LABEL_WIDGET_W_DP),
SizeMode.ABSOLUTE),
TextOrientation.VERTICAL_ASCENDING);
legend.position(
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_X_OFFSET_DP),
HorizontalPositioning.ABSOLUTE_FROM_RIGHT,
PixelUtils.dpToPix(DEFAULT_LEGEND_WIDGET_Y_OFFSET_DP),
VerticalPositioning.ABSOLUTE_FROM_BOTTOM,
Anchor.RIGHT_BOTTOM);
graph.position(
PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_X_OFFSET_DP),
HorizontalPositioning.ABSOLUTE_FROM_RIGHT,
PixelUtils.dpToPix(DEFAULT_GRAPH_WIDGET_Y_OFFSET_DP),
VerticalPositioning.ABSOLUTE_FROM_CENTER,
Anchor.RIGHT_MIDDLE);
domainTitle.position(
PixelUtils.dpToPix(DEFAULT_DOMAIN_LABEL_WIDGET_X_OFFSET_DP),
HorizontalPositioning.ABSOLUTE_FROM_LEFT,
PixelUtils.dpToPix(DEFAULT_DOMAIN_LABEL_WIDGET_Y_OFFSET_DP),
VerticalPositioning.ABSOLUTE_FROM_BOTTOM,
Anchor.LEFT_BOTTOM);
rangeTitle.position(
PixelUtils.dpToPix(DEFAULT_RANGE_LABEL_WIDGET_X_OFFSET_DP),
HorizontalPositioning.ABSOLUTE_FROM_LEFT,
PixelUtils.dpToPix(DEFAULT_RANGE_LABEL_WIDGET_Y_OFFSET_DP),
VerticalPositioning.ABSOLUTE_FROM_CENTER,
Anchor.LEFT_MIDDLE);
getLayoutManager().moveToTop(getTitle());
getLayoutManager().moveToTop(getLegend());
getDomainTitle().pack();
getRangeTitle().pack();
setPlotMarginLeft(PixelUtils.dpToPix(DEFAULT_PLOT_LEFT_MARGIN_DP));
setPlotMarginRight(PixelUtils.dpToPix(DEFAULT_PLOT_RIGHT_MARGIN_DP));
setPlotMarginTop(PixelUtils.dpToPix(DEFAULT_PLOT_TOP_MARGIN_DP));
setPlotMarginBottom(PixelUtils.dpToPix(DEFAULT_PLOT_BOTTOM_MARGIN_DP));
xValueMarkers = new ArrayList<>();
yValueMarkers = new ArrayList<>();
setDefaultBounds(new RectRegion(-1, 1, -1, 1));
domainStepModel = new StepModel(StepMode.SUBDIVIDE, 10);
rangeStepModel = new StepModel(StepMode.SUBDIVIDE, 10);
}
@Override
protected void onAfterConfig() {
// display some generic series data in editors that support it:
if(isInEditMode()) {
switch (previewMode) {
case LineAndPoint: {
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));
}
break;
case Candlestick: {
CandlestickSeries candlestickSeries = new CandlestickSeries(
new CandlestickSeries.Item(1, 10, 2, 9),
new CandlestickSeries.Item(4, 18, 6, 5),
new CandlestickSeries.Item(3, 11, 5, 10),
new CandlestickSeries.Item(2, 17, 2, 15),
new CandlestickSeries.Item(6, 11, 11, 7),
new CandlestickSeries.Item(8, 16, 10, 15));
CandlestickMaker.make(this, new CandlestickFormatter(), candlestickSeries);
}
break;
case Bar: {
throw new UnsupportedOperationException("Not yet implemented.");
}
default:
throw new UnsupportedOperationException("Unexpected preview mode: " + previewMode);
}
}
}
@Override
protected void processAttrs(TypedArray attrs) {
this. previewMode = PreviewMode.values()[attrs.getInt(
R.styleable.xy_XYPlot_previewMode, PreviewMode.LineAndPoint.ordinal())];
String domainLabelAttr = attrs.getString(R.styleable.xy_XYPlot_domainTitle);
if(domainLabelAttr != null) {
getDomainTitle().setText(domainLabelAttr);
}
String rangeLabelAttr = attrs.getString(R.styleable.xy_XYPlot_rangeTitle);
if(rangeLabelAttr != null) {
getRangeTitle().setText(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);
// domainLabelPaint
AttrUtils.configureTextPaint(attrs, getDomainTitle().getLabelPaint(),
R.styleable.xy_XYPlot_domainTitleTextColor, R.styleable.xy_XYPlot_domainTitleTextSize);
// rangeLabelPaint
AttrUtils.configureTextPaint(attrs, getRangeTitle().getLabelPaint(),
R.styleable.xy_XYPlot_rangeTitleTextColor, R.styleable.xy_XYPlot_rangeTitleTextSize);
// legendWTextPaint
AttrUtils.configureTextPaint(attrs, getLegend().getTextPaint(),
R.styleable.xy_XYPlot_legendTextColor,
R.styleable.xy_XYPlot_legendTextSize);
// legendIconSize
AttrUtils.configureSize(attrs, getLegend().getIconSize(),
R.styleable.xy_XYPlot_legendIconHeightMode, R.styleable.xy_XYPlot_legendIconHeight,
R.styleable.xy_XYPlot_legendIconWidthMode, R.styleable.xy_XYPlot_legendIconWidth);
// legend size & position
AttrUtils.configureWidget(attrs, getLegend(),
R.styleable.xy_XYPlot_legendHeightMode, R.styleable.xy_XYPlot_legendHeight,
R.styleable.xy_XYPlot_legendWidthMode, R.styleable.xy_XYPlot_legendWidth,
R.styleable.xy_XYPlot_legendHorizontalPositioning, R.styleable.xy_XYPlot_legendHorizontalPosition,
R.styleable.xy_XYPlot_legendVerticalPositioning, R.styleable.xy_XYPlot_legendVerticalPosition,
R.styleable.xy_XYPlot_legendAnchor, R.styleable.xy_XYPlot_legendVisible);
getGraph().processAttrs(attrs);
}
@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) {
return getGraph().containsPoint(x, y);
}
/** `
* Convenience method - wraps containsPoint(PointF).
*
* @param point
* @return
*/
public boolean containsPoint(PointF point) {
return containsPoint(point.x, point.y);
}
public void setCursorPosition(PointF point) {
getGraph().setCursorPosition(point);
}
public void setCursorPosition(float x, float y) {
getGraph().setCursorPosition(x, y);
}
public Number getYVal(PointF point) {
return getGraph().getYVal(point);
}
public Number getXVal(PointF point) {
return getGraph().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.getLinesPerRangeLabel().
* Equivalent to getGraphWidget().getLinesPerRangeLabel().
*
* @return
*/
public int getLinesPerRangeLabel() {
return graph.getLinesPerRangeLabel();
}
/**
* Convenience method - wraps XYGraphWidget.setLinesPerRangeLabel().
* Equivalent to getGraphWidget().setLinesPerRangeLabel().
*
* @param linesPerLabel
*/
public void setLinesPerRangeLabel(int linesPerLabel) {
graph.setLinesPerRangeLabel(linesPerLabel);
}
/**
* Convenience method - wraps XYGraphWidget.getLinesPerDomainLabel().
* Equivalent to getGraphWidget().getLinesPerDomainLabel().
*
* @return
*/
public int getLinesPerDomainLabel() {
return graph.getLinesPerDomainLabel();
}
/**
* Convenience method - wraps XYGraphWidget.setLinesPerDomainLabel().
* Equivalent to getGraphWidget().setLinesPerDomainLabel().
*
* @param linesPerDomainLabel
*/
public void setLinesPerDomainLabel(int linesPerDomainLabel) {
graph.setLinesPerDomainLabel(linesPerDomainLabel);
}
public StepMode getDomainStepMode() {
return domainStepModel.getMode();
}
public void setDomainStepMode(StepMode domainStepMode) {
domainStepModel.setMode(domainStepMode);
}
public double getDomainStepValue() {
return domainStepModel.getValue();
}
public void setDomainStepValue(double domainStepValue) {
domainStepModel.setValue(domainStepValue);
}
public void setDomainStep(StepMode mode, double value) {
setDomainStepMode(mode);
setDomainStepValue(value);
}
public StepMode getRangeStepMode() {
return rangeStepModel.getMode();
}
public void setRangeStepMode(StepMode rangeStepMode) {
rangeStepModel.setMode(rangeStepMode);
}
public double getRangeStepValue() {
return rangeStepModel.getValue();
}
public void setRangeStepValue(double rangeStepValue) {
rangeStepModel.setValue(rangeStepValue);
}
public void setRangeStep(StepMode mode, double value) {
setRangeStepMode(mode);
setRangeStepValue(value);
}
public XYLegendWidget getLegend() {
return legend;
}
public void setLegend(XYLegendWidget legend) {
this.legend = legend;
}
public XYGraphWidget getGraph() {
return graph;
}
public void setGraph(XYGraphWidget graph) {
this.graph = graph;
}
public TextLabelWidget getDomainTitle() {
return domainTitle;
}
public void setDomainTitle(TextLabelWidget domainTitle) {
this.domainTitle = domainTitle;
}
public void setDomainLabel(String domainLabel) {
getDomainTitle().setText(domainLabel);
}
public TextLabelWidget getRangeTitle() {
return rangeTitle;
}
public void setRangeTitle(TextLabelWidget rangeTitle) {
this.rangeTitle = rangeTitle;
}
public void setRangeLabel(String rangeLabel) {
getRangeTitle().setText(rangeLabel);
}
/**
* 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();
}
/**
* 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 StepModel getDomainStepModel() {
return domainStepModel;
}
public void setDomainStepModel(StepModel domainStepModel) {
this.domainStepModel = domainStepModel;
}
public StepModel getRangeStepModel() {
return rangeStepModel;
}
public void setRangeStepModel(StepModel rangeStepModel) {
this.rangeStepModel = rangeStepModel;
}
} androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYRegionFormatter.java 0000664 0000000 0000000 00000003624 12766537502 0031745 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-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYSeries.java 0000664 0000000 0000000 00000002562 12766537502 0030070 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);
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesFormatter.java 0000664 0000000 0000000 00000003147 12766537502 0031754 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.LayerHash;
import com.androidplot.util.Layerable;
public abstract class XYSeriesFormatter extends Formatter {
LayerHash regions;
{
regions = new LayerHash<>();
}
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 Layerable getRegions() {
return regions;
}
/**
* @param region
* @return
*/
public XYRegionFormatterType getRegionFormatter(RectRegion region) {
return regions.get(region);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesRenderer.java 0000664 0000000 0000000 00000003623 12766537502 0031556 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.Layerable;
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()) {
Layerable regionIndexer = sfPair.getFormatter().getRegions();
for (RectRegion region : regionIndexer.elements()) {
XYRegionFormatter f = sfPair.getFormatter().getRegionFormatter(region);
found.put(f, region.getLabel());
}
}
return found;
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/XYStepCalculator.java 0000664 0000000 0000000 00000005415 12766537502 0031563 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 Step getStep(XYPlot plot, Axis axisType, RectF rect, Number minVal, Number maxVal) {
Step 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 Step getStep(StepMode typeXY, float plotPixelSize, double stepValue, Number minVal, Number maxVal) {
//XYStep step = new XYStep();
double stepVal = 0;
double stepPix = 0;
double stepCount = 0;
switch(typeXY) {
case INCREMENT_BY_VAL:
stepVal = stepValue;
stepPix = stepValue / ValPixConverter.valPerPix(minVal.doubleValue(), maxVal.doubleValue(), plotPixelSize);
stepCount = plotPixelSize /stepPix;
break;
case INCREMENT_BY_PIXELS:
stepPix = stepValue;
stepCount = plotPixelSize /stepPix;
stepVal = ValPixConverter.valPerPix(minVal.doubleValue(), maxVal.doubleValue(), plotPixelSize)*stepPix;
break;
case SUBDIVIDE:
stepCount = stepValue;
stepPix = (plotPixelSize /(stepCount-1));
stepVal = ValPixConverter.valPerPix(minVal.doubleValue(), maxVal.doubleValue(), plotPixelSize)*stepPix;
break;
}
return new Step(stepCount, stepPix, stepVal);
}
}
androidplot-1.2.1/androidplot-core/src/main/java/com/androidplot/xy/YValueMarker.java 0000664 0000000 0000000 00000003623 12766537502 0030723 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.HorizontalPositioning;
import com.androidplot.ui.HorizontalPosition;
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 HorizontalPosition(3, HorizontalPositioning.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, HorizontalPosition 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, HorizontalPosition textPosition, int linePaint, int textPaint) {
super(value, text, textPosition, linePaint, textPaint);
}
}
androidplot-1.2.1/androidplot-core/src/main/res/ 0000775 0000000 0000000 00000000000 12766537502 0021620 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/main/res/values/ 0000775 0000000 0000000 00000000000 12766537502 0023117 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/main/res/values/attrs.xml 0000664 0000000 0000000 00000043435 12766537502 0025007 0 ustar 00root root 0000000 0000000
androidplot-1.2.1/androidplot-core/src/main/res/values/color.xml 0000664 0000000 0000000 00000001742 12766537502 0024763 0 ustar 00root root 0000000 0000000
#00000000
#000
#111
#FFF
#EEE
#888
androidplot-1.2.1/androidplot-core/src/main/res/values/style.xml 0000664 0000000 0000000 00000015436 12766537502 0025012 0 ustar 00root root 0000000 0000000
androidplot-1.2.1/androidplot-core/src/test/ 0000775 0000000 0000000 00000000000 12766537502 0021062 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/ 0000775 0000000 0000000 00000000000 12766537502 0022003 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/android/ 0000775 0000000 0000000 00000000000 12766537502 0023423 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/android/net/ 0000775 0000000 0000000 00000000000 12766537502 0024211 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/android/net/http/ 0000775 0000000 0000000 00000000000 12766537502 0025170 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/android/net/http/AndroidHttpClient.java 0000664 0000000 0000000 00000001546 12766537502 0031420 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-1.2.1/androidplot-core/src/test/java/com/ 0000775 0000000 0000000 00000000000 12766537502 0022561 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/ 0000775 0000000 0000000 00000000000 12766537502 0025100 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/LineRegionTest.java 0000664 0000000 0000000 00000004513 12766537502 0030641 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-1.2.1/androidplot-core/src/test/java/com/androidplot/PlotTest.java 0000664 0000000 0000000 00000027643 12766537502 0027535 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 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 = plot.getListeners();
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 = plot.getListeners();
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.text", param1);
params.put("renderMode", param2);
params.put("backgroundPaint.color", param3);
Configurator.configure(RuntimeEnvironment.application, plot, params);
assertEquals(param1, plot.getTitle().getText());
assertEquals(Plot.RenderMode.USE_BACKGROUND_THREAD, plot.getRenderMode());
assertEquals(Color.parseColor(param3), plot.getBackgroundPaint().getColor());
}
}
androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/RegionTest.java 0000664 0000000 0000000 00000003000 12766537502 0030017 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-1.2.1/androidplot-core/src/test/java/com/androidplot/test/ 0000775 0000000 0000000 00000000000 12766537502 0026057 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/test/AndroidplotTest.java 0000664 0000000 0000000 00000002244 12766537502 0032043 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(MyTestRunner.class)
public abstract class AndroidplotTest {
/**
* Convience method - to access the application context.
* @return
*/
protected Context getContext() {
return RuntimeEnvironment.application;
}
}
androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/test/MyTestRunner.java 0000664 0000000 0000000 00000000624 12766537502 0031343 0 ustar 00root root 0000000 0000000 package com.androidplot.test;
import org.junit.runners.model.*;
import org.robolectric.*;
public class MyTestRunner extends RobolectricTestRunner {
/**
* Constructs a new instance of the test runner.
*
* @throws InitializationError if the test class is malformed
*/
public MyTestRunner(Class testClass) throws InitializationError
{
super(testClass);
}
}
androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/ui/ 0000775 0000000 0000000 00000000000 12766537502 0025515 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/ui/DynamicTableModelTest.java 0000664 0000000 0000000 00000017753 12766537502 0032552 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-1.2.1/androidplot-core/src/test/java/com/androidplot/ui/FixedTableModelTest.java 0000664 0000000 0000000 00000020016 12766537502 0032207 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-1.2.1/androidplot-core/src/test/java/com/androidplot/util/ 0000775 0000000 0000000 00000000000 12766537502 0026055 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/util/ConfiguratorTest.java 0000664 0000000 0000000 00000004315 12766537502 0032225 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]);
}
}
LinkedLayerListOrganizerTest.java 0000664 0000000 0000000 00000004002 12766537502 0034415 0 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/util /*
* 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 LinkedLayerListOrganizerTest {
@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());
LayerListOrganizer organizer = new LayerListOrganizer(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-1.2.1/androidplot-core/src/test/java/com/androidplot/util/PixelUtilsTest.java 0000664 0000000 0000000 00000002325 12766537502 0031664 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-1.2.1/androidplot-core/src/test/java/com/androidplot/util/SeriesUtilsTest.java 0000664 0000000 0000000 00000011475 12766537502 0032043 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-1.2.1/androidplot-core/src/test/java/com/androidplot/util/ValPixConverterTest.java 0000664 0000000 0000000 00000010322 12766537502 0032651 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;
double value = 50;
assertEquals(value, 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(25d, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be at the very top:
value = 100;
assertEquals(0d, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be at the very top:
value = 0;
assertEquals(100d, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be smack in the middle:
min = -100;
value = 0;
assertEquals(50d, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be at the very bottom:
value = 100;
assertEquals(0d, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
// should be in the middle:
value = 0;
assertEquals(50d, ValPixConverter.valToPix(value, min, max, sizeInPix, true));
min = -100;
max = 100;
sizeInPix = 200;
assertEquals(0d, ValPixConverter.valToPix(-100, min, max, sizeInPix, false));
assertEquals(200d, 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;
double 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-1.2.1/androidplot-core/src/test/java/com/androidplot/xy/ 0000775 0000000 0000000 00000000000 12766537502 0025540 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/xy/CandlestickSeriesTest.java 0000664 0000000 0000000 00000004156 12766537502 0032650 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 org.junit.Test;
import java.util.Arrays;
import static junit.framework.Assert.assertEquals;
public class CandlestickSeriesTest {
@Test
public void testConstructors() throws Exception {
CandlestickSeries candlestickSeries = new CandlestickSeries(
new CandlestickSeries.Item(1, 10, 2, 9),
new CandlestickSeries.Item(4, 18, 6, 5),
new CandlestickSeries.Item(3, 11, 5, 10),
new CandlestickSeries.Item(2, 17, 2, 15),
new CandlestickSeries.Item(6, 11, 11, 7),
new CandlestickSeries.Item(8, 16, 10, 15));
XYSeries lowSeries = candlestickSeries.getLowSeries();
assertEquals(1d, lowSeries.getY(0));
assertEquals(4d, lowSeries.getY(1));
assertEquals(3d, lowSeries.getY(2));
XYSeries highSeries = candlestickSeries.getHighSeries();
assertEquals(10d, highSeries.getY(0));
assertEquals(18d, highSeries.getY(1));
assertEquals(11d, highSeries.getY(2));
XYSeries openSeries = candlestickSeries.getOpenSeries();
assertEquals(2d, openSeries.getY(0));
assertEquals(6d, openSeries.getY(1));
assertEquals(5d, openSeries.getY(2));
XYSeries closeSeries = candlestickSeries.getCloseSeries();
assertEquals(9d, closeSeries.getY(0));
assertEquals(5d, closeSeries.getY(1));
assertEquals(10d, closeSeries.getY(2));
CandlestickMaker.check(candlestickSeries);
}
}
FastLineAndPointRendererTest.java 0000664 0000000 0000000 00000006161 12766537502 0034021 0 ustar 00root root 0000000 0000000 androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/xy /*
* 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.*;
import org.junit.*;
import org.junit.runner.*;
import org.mockito.*;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@RunWith(MyTestRunner.class)
public class FastLineAndPointRendererTest extends AndroidplotTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void testOnRender() throws Exception {
RectF gridRect = new RectF(5, 5, 105, 105);
XYPlot plot = new XYPlot(getContext(), "Test");
FastLineAndPointRenderer.Formatter formatter =
new FastLineAndPointRenderer.Formatter(Color.RED, Color.RED, null, null);
// create a series composed of 3 "segments"; series portions separated by null values:
XYSeries series = new SimpleXYSeries(
SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "some data", 1, 2, null, 3, 4, 5, 6, 7, null, null, 8);
FastLineAndPointRenderer renderer = Mockito.spy(new FastLineAndPointRenderer(plot));
Canvas canvas = mock(Canvas.class);
renderer.onRender(canvas, gridRect, series, formatter, null);
// first segment
verify(renderer, times(1)).drawSegment(
eq(canvas),
any(float[].class),
eq(0),
eq(4),
eq(formatter));
verify(canvas, times(1)).drawPoints(
any(float[].class),
eq(0),
eq(4),
eq(formatter.getVertexPaint()));
// second segment
verify(renderer, times(1)).drawSegment(
eq(canvas),
any(float[].class),
eq(6),
eq(10),
eq(formatter));
verify(canvas, times(1)).drawPoints(
any(float[].class),
eq(6),
eq(10),
eq(formatter.getVertexPaint()));
// third segment
verify(renderer, times(1)).drawSegment(
eq(canvas),
any(float[].class),
eq(20),
eq(2),
eq(formatter));
verify(canvas, times(1)).drawPoints(
any(float[].class),
eq(20),
eq(2),
eq(formatter.getVertexPaint()));
}
}
androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/xy/RectRegionTest.java 0000664 0000000 0000000 00000004325 12766537502 0031310 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-1.2.1/androidplot-core/src/test/java/com/androidplot/xy/SimpleXYSeriesTest.java 0000664 0000000 0000000 00000010574 12766537502 0032137 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-1.2.1/androidplot-core/src/test/java/com/androidplot/xy/StepCalculatorTest.java 0000664 0000000 0000000 00000003476 12766537502 0032202 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 StepCalculatorTest {
@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;
double plotSize = 100;
double minVal = 0;
double maxVal = 100;
Step step = XYStepCalculator.getStep(StepMode.SUBDIVIDE,
(float) plotSize, numSegments, minVal, maxVal);
assertEquals(plotSize/(numSegments-1), step.getStepPix());
// make sure large values dont break anything:
minVal = 1000000000;
maxVal = 2000000000;
step = XYStepCalculator.getStep(StepMode.SUBDIVIDE,
(float) plotSize, numSegments, minVal, maxVal);
assertEquals(plotSize/(numSegments-1), step.getStepPix());
}
@Test
public void testIncrementByVal() throws Exception {
}
@Test
public void testIncrementByPixels() throws Exception {
}
}
androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/xy/XYLegendWidgetTest.java 0000664 0000000 0000000 00000004677 12766537502 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 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 {
static class MockXYPlot extends XYPlot {
public MockXYPlot() {
super(RuntimeEnvironment.application, "Test",
Plot.RenderMode.USE_MAIN_THREAD);
}
public void exposedOnSizeChanged(int w, int h, int oldw, int oldh) {
this.onSizeChanged(w, h, oldw, oldh);
}
public void exposedOnDraw(Canvas canvas) {
this.onDraw(canvas);
}
}
@After
public void tearDown() throws Exception {}
@Test
public void testDoOnDraw() throws Exception {
MockXYPlot plot = new MockXYPlot();
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());
plot.exposedOnSizeChanged(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.
plot.exposedOnDraw(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.
plot.exposedOnDraw(new Canvas());
}
}
androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/xy/XYPlotTest.java 0000664 0000000 0000000 00000035622 12766537502 0030452 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.text", param1);
params.put("renderMode", param2);
params.put("backgroundPaint.color", param3);
Configurator.configure(RuntimeEnvironment.application, plot, params);
assertEquals(param1, plot.getTitle().getText());
assertEquals(Plot.RenderMode.USE_BACKGROUND_THREAD, plot.getRenderMode());
assertEquals(Color.parseColor(param3), plot.getBackgroundPaint().getColor());
}
}
androidplot-1.2.1/androidplot-core/src/test/java/com/androidplot/xy/XYSeriesRendererTest.java 0000664 0000000 0000000 00000004325 12766537502 0032451 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(StepMode.SUBDIVIDE);
plot.setDomainStepValue(10);
plot.setDomainBoundaries(0, 100, BoundaryMode.FIXED);
plot.setRangeBoundaries(0, 100, BoundaryMode.FIXED);
plot.calculateMinMaxVals();
Step domainStep = XYStepCalculator.getStep(plot, Axis.DOMAIN, gridRect, plot.getCalculatedMinX().doubleValue(), plot.getCalculatedMaxX().doubleValue());
int x = 0;
double 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-1.2.1/build.gradle 0000664 0000000 0000000 00000003066 12766537502 0016333 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: 'java'
repositories {
mavenCentral()
jcenter()
}
ext {
theBuildToolsVersion = '24.0.2'
theCompileSdkVersion = 24
theTargetSdkVersion = 24
theMinSdkVersion = 5
theVersionName = '1.2.1'
theVersionCode = 19
}
buildscript {
repositories {
mavenCentral()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.2.0-beta3'
classpath 'com.github.dcendents:android-maven-gradle-plugin:1.5'
classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.7'
}
}
allprojects {
repositories {
mavenCentral()
}
}
/*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.14.1'
} androidplot-1.2.1/circle.yml 0000664 0000000 0000000 00000002475 12766537502 0016043 0 ustar 00root root 0000000 0000000
dependencies:
pre:
- echo y | android update sdk --no-ui --all --filter "android-24"
- echo y | android update sdk --no-ui --all --filter "build-tools-24.0.2"
test:
override:
- (./gradlew test assembleRelease javadoc):
timeout: 360
post:
# core lib:
- cp -r ${HOME}/${CIRCLE_PROJECT_REPONAME}/androidplot-core/build/outputs/aar/ $CIRCLE_ARTIFACTS
# demo app .apk:
- cp -r ${HOME}/${CIRCLE_PROJECT_REPONAME}/demoapp/build/outputs/apk/ $CIRCLE_ARTIFACTS
# javadoc:
- cp -r ${HOME}/${CIRCLE_PROJECT_REPONAME}/androidplot-core/build/docs/javadoc/ $CIRCLE_ARTIFACTS
# junit xml report:
- mkdir -p $CIRCLE_TEST_REPORTS/junit-xml/
- find . -type f -regex ".*/build/test-results/.*xml" -exec cp {} $CIRCLE_TEST_REPORTS/junit-xml/ \;
# junit html report:
# TODO: recursively copy subdirs etc
- mkdir -p $CIRCLE_TEST_REPORTS/junit-html/
- cp -r ${HOME}/${CIRCLE_PROJECT_REPONAME}/androidplot-core/build/reports/tests/release/* $CIRCLE_TEST_REPORTS/junit-html/
# lint report:
- mkdir -p $CIRCLE_TEST_REPORTS/lint/
- find . -type f -regex ".*/build/outputs/.*html" -exec cp {} $CIRCLE_TEST_REPORTS/lint/ \;
deployment:
master:
branch: master
commands:
- (./gradlew bintrayUpload):
timeout: 360
androidplot-1.2.1/demoapp-wearable/ 0000775 0000000 0000000 00000000000 12766537502 0017254 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/.gitignore 0000664 0000000 0000000 00000000007 12766537502 0021241 0 ustar 00root root 0000000 0000000 /build
androidplot-1.2.1/demoapp-wearable/build.gradle 0000664 0000000 0000000 00000003163 12766537502 0021536 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-1.2.1/demoapp-wearable/proguard-rules.pro 0000664 0000000 0000000 00000001215 12766537502 0022750 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-1.2.1/demoapp-wearable/src/ 0000775 0000000 0000000 00000000000 12766537502 0020043 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/ 0000775 0000000 0000000 00000000000 12766537502 0020767 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/AndroidManifest.xml 0000664 0000000 0000000 00000002617 12766537502 0024566 0 ustar 00root root 0000000 0000000
androidplot-1.2.1/demoapp-wearable/src/main/java/ 0000775 0000000 0000000 00000000000 12766537502 0021710 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/java/com/ 0000775 0000000 0000000 00000000000 12766537502 0022466 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/java/com/androidplot/ 0000775 0000000 0000000 00000000000 12766537502 0025005 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/java/com/androidplot/demo/ 0000775 0000000 0000000 00000000000 12766537502 0025731 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/java/com/androidplot/demo/wearable/ 0000775 0000000 0000000 00000000000 12766537502 0027513 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/java/com/androidplot/demo/wearable/MainActivity.java 0000664 0000000 0000000 00000007117 12766537502 0032765 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-1.2.1/demoapp-wearable/src/main/res/ 0000775 0000000 0000000 00000000000 12766537502 0021560 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/res/layout/ 0000775 0000000 0000000 00000000000 12766537502 0023075 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/res/layout/activity_main.xml 0000664 0000000 0000000 00000005544 12766537502 0026467 0 ustar 00root root 0000000 0000000
androidplot-1.2.1/demoapp-wearable/src/main/res/xml/ 0000775 0000000 0000000 00000000000 12766537502 0022360 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp-wearable/src/main/res/xml/line_point_formatter_with_labels.xml 0000664 0000000 0000000 00000001607 12766537502 0031706 0 ustar 00root root 0000000 0000000
androidplot-1.2.1/demoapp-wearable/src/main/res/xml/line_point_formatter_with_labels_2.xml 0000664 0000000 0000000 00000001607 12766537502 0032127 0 ustar 00root root 0000000 0000000
androidplot-1.2.1/demoapp/ 0000775 0000000 0000000 00000000000 12766537502 0015474 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp/build.gradle 0000664 0000000 0000000 00000002312 12766537502 0017751 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: 'com.android.application'
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-1.2.1/demoapp/proguard-project.txt 0000664 0000000 0000000 00000001657 12766537502 0021535 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-1.2.1/demoapp/project.properties 0000664 0000000 0000000 00000004425 12766537502 0021265 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-1.2.1/demoapp/src/ 0000775 0000000 0000000 00000000000 12766537502 0016263 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp/src/main/ 0000775 0000000 0000000 00000000000 12766537502 0017207 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp/src/main/AndroidManifest.xml 0000664 0000000 0000000 00000011746 12766537502 0023011 0 ustar 00root root 0000000 0000000
androidplot-1.2.1/demoapp/src/main/java/ 0000775 0000000 0000000 00000000000 12766537502 0020130 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp/src/main/java/com/ 0000775 0000000 0000000 00000000000 12766537502 0020706 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp/src/main/java/com/androidplot/ 0000775 0000000 0000000 00000000000 12766537502 0023225 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp/src/main/java/com/androidplot/demos/ 0000775 0000000 0000000 00000000000 12766537502 0024334 5 ustar 00root root 0000000 0000000 androidplot-1.2.1/demoapp/src/main/java/com/androidplot/demos/BarPlotExampleActivity.java 0000664 0000000 0000000 00000040221 12766537502 0031572 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.*;
/**
* An example of a Bar Plot.
*/
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.rgb(100, 150, 100), Color.LTGRAY);
formatter2 = new MyBarFormatter(Color.rgb(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), SizeMode.ABSOLUTE,
PixelUtils.dpToPix(100), SizeMode.ABSOLUTE),
TextOrientation.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, HorizontalPositioning.RELATIVE_TO_CENTER,
PixelUtils.dpToPix(45), VerticalPositioning.ABSOLUTE_FROM_TOP,
Anchor.TOP_MIDDLE);
selectionWidget.pack();
// reduce the number of range labels
plot.setLinesPerRangeLabel(3);
plot.setRangeLowerBoundary(0, BoundaryMode.FIXED);
plot.setLinesPerDomainLabel(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.getGraph().getLineLabelStyle(XYGraphWidget.Edge.BOTTOM).
setFormat(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.containsPoint(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-1.2.1/demoapp/src/main/java/com/androidplot/demos/CandlestickChartActivity.java 0000664 0000000 0000000 00000011462 12766537502 0032126 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.graphics.Paint;
import android.os.Bundle;
import com.androidplot.xy.CandlestickFormatter;
import com.androidplot.xy.CandlestickMaker;
import com.androidplot.xy.CandlestickSeries;
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;
/**
* 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);
CandlestickSeries candlestickSeries = new CandlestickSeries(
new CandlestickSeries.Item(1, 10, 2, 9),
new CandlestickSeries.Item(4, 18, 6, 5),
new CandlestickSeries.Item(3, 11, 5, 10),
new CandlestickSeries.Item(2, 17, 2, 15),
new CandlestickSeries.Item(6, 11, 11, 7),
new CandlestickSeries.Item(8, 16, 10, 15));
// draw a simple line plot of the close vals:
LineAndPointFormatter lpf = new LineAndPointFormatter(Color.BLACK, Color.BLACK, 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(candlestickSeries.getCloseSeries(), lpf);
CandlestickFormatter formatter = new CandlestickFormatter();
Paint p = formatter.getWickPaint();
p.setColor(Color.BLACK);
formatter.setCapAndWickPaint(p);
formatter.setRisingBodyStrokePaint(p);
formatter.setFallingBodyStrokePaint(p);
// 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.Square);
// add the candlestick series data to the plot:
CandlestickMaker.make(plot, formatter, candlestickSeries);
// setup the range tick label formatting, etc:
plot.setLinesPerRangeLabel(3);
plot.getGraph().getLineLabelStyle(XYGraphWidget.Edge.LEFT).
setFormat(new DecimalFormat("$0.00"));
// setup the domain tick label formatting, etc:
plot.setDomainBoundaries(-1, 6, BoundaryMode.FIXED);
plot.setDomainStep(StepMode.INCREMENT_BY_VAL, 1);
plot.getGraph().getLineLabelStyle(XYGraphWidget.Edge.BOTTOM).setFormat(new Format() {
@Override
public StringBuffer format(Object object, StringBuffer buffer,
FieldPosition field) {
int day = ((Number) object).intValue() % 7;
switch (day) {
case 0:
buffer.append("Sun");
break;
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;
case 6:
buffer.append("Sat");
default:
// show nothing
}
return buffer;
}
@Override
public Object parseObject(String string, ParsePosition position) {
return null;
}
});
}
}
androidplot-1.2.1/demoapp/src/main/java/com/androidplot/demos/DynamicXYPlotActivity.java 0000664 0000000 0000000 00000017772 12766537502 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.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.dynamic_xyplot_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.getGraph().getLineLabelStyle(XYGraphWidget.Edge.BOTTOM).
setFormat(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, 200, 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(StepMode.INCREMENT_BY_VAL);
dynamicPlot.setDomainStepValue(5);
dynamicPlot.setRangeStepMode(StepMode.INCREMENT_BY_VAL);
dynamicPlot.setRangeStepValue(10);
dynamicPlot.getGraph().getLineLabelStyle(
XYGraphWidget.Edge.LEFT).setFormat(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.getGraph().getDomainGridLinePaint().setPathEffect(dashFx);
dynamicPlot.getGraph().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 = 31;
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-1.2.1/demoapp/src/main/java/com/androidplot/demos/ECGExample.java 0000664 0000000 0000000 00000016511 12766537502 0027115 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.Paint;
import android.os.Bundle;
import com.androidplot.Plot;
import com.androidplot.util.Redrawer;
import com.androidplot.xy.*;
/**
* An example of a real-time plot displaying an asynchronously updated model of ECG data. There are three
* key items to pay attention to here:
* 1 - The model data is updated independently of all other data via a background thread. This is typical
* of most signal inputs.
*
* 2 - The main render loop is controlled by a separate thread governed by an instance of {@link Redrawer}.
* The alternative is to try synchronously invoking {@link Plot#redraw()} within whatever system is updating
* the model, which would severely degrade performance.
*
* 3 - The plot is set to render using a background thread via config attr in R.layout.ecg_example.xml.
* This ensures that the rest of the app will remain responsive during rendering.
*/
public class ECGExample extends Activity
{
private XYPlot plot;
/**
* Uses a separate thread to modulate redraw frequency.
*/
private Redrawer redrawer;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.ecg_example);
// initialize our XYPlot reference:
plot = (XYPlot) findViewById(R.id.plot);
ECGModel ecgSeries = new ECGModel(2000, 200, new ECGModel.Listener() {
@Override
public void onUpdate(int latestIndex) {
((AdvancedLineAndPointRenderer) plot.
getRenderer(AdvancedLineAndPointRenderer.class)).setLatestIndex(latestIndex);
}
});
// add a new series' to the xyplot:
plot.addSeries(ecgSeries, new MyFadeFormatter(2000));
plot.setRangeBoundaries(0, 10, BoundaryMode.FIXED);
plot.setDomainBoundaries(0, 2000, BoundaryMode.FIXED);
// reduce the number of range labels
plot.setLinesPerRangeLabel(3);
// start generating ecg data in the background:
ecgSeries.start();
// set a redraw rate of 30hz and start immediately:
redrawer = new Redrawer(plot, 30, true);
}
/**
* Special {@link AdvancedLineAndPointRenderer.Formatter} that draws a line
* that fades over time. Designed to be used in conjunction with a circular buffer model.
*/
public static class MyFadeFormatter extends AdvancedLineAndPointRenderer.Formatter {
private int trailSize;
public MyFadeFormatter(int trailSize) {
this.trailSize = trailSize;
}
@Override
public Paint getLinePaint(int thisIndex, int latestIndex, int seriesSize) {
// offset from the latest index:
int offset;
if(thisIndex > latestIndex) {
offset = latestIndex + (seriesSize - thisIndex);
} else {
offset = latestIndex - thisIndex;
}
float scale = 255f / trailSize;
int alpha = (int) (255 - (offset * scale));
getLinePaint().setAlpha(alpha > 0 ? alpha : 0);
return getLinePaint();
}
}
/**
* Primitive simulation of some kind of signal. For this example,
* we'll pretend its an ecg. This class represents the data as a circular buffer;
* data is added sequentially from left to right. When the end of the buffer is reached,
* i is reset back to 0 and simulated sampling continues.
*/
public static class ECGModel implements XYSeries {
private final Number[] data;
private final long delayMs;
private final int blipInteral;
private final Thread thread;
private boolean keepRunning;
private int latestIndex;
private Listener listener;
interface Listener {
/**
* Invoked whenever a new sample is added to the model
* @param latestIndex The new sample's index.
*/
void onUpdate(int latestIndex);
}
/**
*
* @param size Sample size contained within this model
* @param updateFreqHz Frequency at which new samples are added to the model
* @param listener Listener to be notified whenever a new sample is "read".
*/
public ECGModel(int size, int updateFreqHz, Listener listener) {
this.listener = listener;
data = new Number[size];
for(int i = 0; i < data.length; i++) {
data[i] = 0;
}
// translate hz into delay (ms):
delayMs = 1000 / updateFreqHz;
// add 7 "blips" into the signal:
blipInteral = size / 7;
thread = new Thread(new Runnable() {
@Override
public void run() {
try {
while (keepRunning) {
if (latestIndex >= data.length) {
latestIndex = 0;
}
// generate some random data:
if (latestIndex % blipInteral == 0) {
// insert a "blip" to simulate a heartbeat:
data[latestIndex] = (Math.random() * 10) + 3;
} else {
// insert a random sample:
data[latestIndex] = Math.random() * 2;
}
if(latestIndex < data.length - 1) {
// null out the point immediately following i, to disable
// connecting i and i+1 with a line:
data[latestIndex +1] = null;
}
ECGModel.this.listener.onUpdate(latestIndex);
Thread.sleep(delayMs);
latestIndex++;
}
} catch (InterruptedException e) {
keepRunning = false;
}
}
});
}
public void start() {
keepRunning = true;
thread.start();
}
@Override
public int size() {
return data.length;
}
@Override
public Number getX(int index) {
return index;
}
@Override
public Number getY(int index) {
return data[index];
}
@Override
public String getTitle() {
return "Signal";
}
}
@Override
public void onStop() {
super.onStop();
redrawer.finish();
}
}
androidplot-1.2.1/demoapp/src/main/java/com/androidplot/demos/FXPlotExampleActivity.java 0000664 0000000 0000000 00000011334 12766537502 0031406 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.*;
import android.graphics.*;
import android.os.*;
import com.androidplot.util.*;
import com.androidplot.xy.*;
import java.text.*;
import java.util.*;
/**
* A simple XYPlot
*/
public class FXPlotExampleActivity extends Activity {
private XYPlot plot;
/**
* Custom line label renderer that highlights origin labels
*/
class MyLineLabelRenderer extends XYGraphWidget.LineLabelRenderer {
@Override
protected void drawLabel(Canvas canvas, String text, Paint paint,
float x, float y, boolean isOrigin) {
if(isOrigin) {
// make the origin labels red:
final Paint originPaint = new Paint(paint);
originPaint.setColor(Color.RED);
super.drawLabel(canvas, text, originPaint, x, y , isOrigin);
} else {
super.drawLabel(canvas, text, paint, x, y , isOrigin);
}
}
}
/**
* Draws every other tick label and renders text in gray instead of white.
*/
class MySecondaryLabelRenderer extends MyLineLabelRenderer {
@Override
public void drawLabel(Canvas canvas, XYGraphWidget.LineLabelStyle style,
Number val, float x, float y, boolean isOrigin) {
if(val.doubleValue() % 2 == 0) {
final Paint paint = style.getPaint();
if(!isOrigin) {
paint.setColor(Color.GRAY);
}
super.drawLabel(canvas, style, val, x, y, isOrigin);
}
}
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.fx_plot_example);
// initialize our XYPlot reference:
plot = (XYPlot) findViewById(R.id.plot);
plot.setDomainStep(StepMode.INCREMENT_BY_VAL, 1);
plot.setRangeStep(StepMode.INCREMENT_BY_VAL, 1);
plot.centerOnDomainOrigin(0);
plot.centerOnRangeOrigin(0);
// create formatters to use for drawing a series using LineAndPointRenderer
// and configure them from xml:
LineAndPointFormatter series1Format = new LineAndPointFormatter();
series1Format.configure(getApplicationContext(),
R.xml.line_point_formatter);
// use our custom renderer to make origin labels red
plot.getGraph().setLineLabelRenderer(XYGraphWidget.Edge.BOTTOM, new MyLineLabelRenderer());
plot.getGraph().setLineLabelRenderer(XYGraphWidget.Edge.LEFT, new MyLineLabelRenderer());
// skip every other line for top and right edge labels
plot.getGraph().setLineLabelRenderer(XYGraphWidget.Edge.RIGHT, new MySecondaryLabelRenderer());
plot.getGraph().setLineLabelRenderer(XYGraphWidget.Edge.TOP, new MySecondaryLabelRenderer());
// don't show decimal places for top and right edge labels
plot.getGraph().getLineLabelStyle(XYGraphWidget.Edge.TOP).setFormat(new DecimalFormat("0"));
plot.getGraph().getLineLabelStyle(XYGraphWidget.Edge.RIGHT).setFormat(new DecimalFormat("0"));
// create a dash effect for domain and range grid lines:
DashPathEffect dashFx = new DashPathEffect(
new float[] {PixelUtils.dpToPix(3), PixelUtils.dpToPix(3)}, 0);
plot.getGraph().getDomainGridLinePaint().setPathEffect(dashFx);
plot.getGraph().getRangeGridLinePaint().setPathEffect(dashFx);
// add a new series' to the xyplot:
plot.addSeries(generateSeries(-5, 5, 100), series1Format);
}
protected XYSeries generateSeries(double minX, double maxX, double resolution) {
final double range = maxX - minX;
final double step = range / resolution;
List xVals = new ArrayList<>();
List yVals = new ArrayList<>();
double x = minX;
while (x <= maxX) {
xVals.add(x);
yVals.add(fx(x));
x +=step;
}
return new SimpleXYSeries(xVals, yVals, "f(x) = (x^2) - 13");
}
protected double fx(double x) {
return Math.abs(x*x) - 13;
}
}
androidplot-1.2.1/demoapp/src/main/java/com/androidplot/demos/ListViewActivity.java 0000664 0000000 0000000 00000011221 12766537502 0030457 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.getTitle().setText("plot" + pos);
List> thisSeriesList = seriesData.get(pos);
for(SeriesAndFormatter sf : thisSeriesList) {
p.addSeries(sf.getSeries(), sf.getFormatter());
}
p.redraw();
return v;
}
}
} androidplot-1.2.1/demoapp/src/main/java/com/androidplot/demos/MainActivity.java 0000664 0000000 0000000 00000015251 12766537502 0027604 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 startXYPlotWithBgImgExampleButton = (Button) findViewById(R.id.startXYPlotWithBgImgExample);
startXYPlotWithBgImgExampleButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, XYPlotWithBgImgActivity.class));
}
});
// ECG
Button startECGExampleButton = (Button) findViewById(R.id.startECGExample);
startECGExampleButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, ECGExample.class));
}
});
// f(x) plot
Button fxPlotExampleButton = (Button) findViewById(R.id.fxPlotExample);
fxPlotExampleButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(MainActivity.this, FXPlotExampleActivity.class));
}
});
}
}
androidplot-1.2.1/demoapp/src/main/java/com/androidplot/demos/OrientationSensorExampleActivity.java 0000664 0000000 0000000 00000023602 12766537502 0033720 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.*;
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().getDomainLineLabelPaint().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.setLinesPerRangeLabel(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.getDomainTitle().pack();
aprLevelsPlot.setRangeLabel("Angle (Degs)");
aprLevelsPlot.getRangeTitle().pack();
aprLevelsPlot.getGraph().getLineLabelStyle(XYGraphWidget.Edge.LEFT).
setFormat(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 FastLineAndPointRenderer.Formatter(
Color.rgb(100, 100, 200), null, null, null));
aprHistoryPlot.addSeries(pitchHistorySeries,
new FastLineAndPointRenderer.Formatter(
Color.rgb(100, 200, 100), null, null, null));
aprHistoryPlot.addSeries(rollHistorySeries,
new FastLineAndPointRenderer.Formatter(
Color.rgb(200, 100, 100), null, null, null));
aprHistoryPlot.setDomainStepMode(StepMode.INCREMENT_BY_VAL);
aprHistoryPlot.setDomainStepValue(HISTORY_SIZE/10);
aprHistoryPlot.setLinesPerRangeLabel(3);
aprHistoryPlot.setDomainLabel("Sample Index");
aprHistoryPlot.getDomainTitle().pack();
aprHistoryPlot.setRangeLabel("Angle (Degs)");
aprHistoryPlot.getRangeTitle().pack();
aprHistoryPlot.getGraph().getLineLabelStyle(XYGraphWidget.Edge.LEFT).
setFormat(new DecimalFormat("#"));
aprHistoryPlot.getGraph().getLineLabelStyle(XYGraphWidget.Edge.BOTTOM).
setFormat(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-1.2.1/demoapp/src/main/java/com/androidplot/demos/ScatterPlotActivity.java 0000664 0000000 0000000 00000005576 12766537502 0031175 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.setLinesPerRangeLabel(3);
// rotate domain labels 45 degrees to make them more compact horizontally:
//plot.getGraphWidget().setLineLabelRotation(XYGraphWidget.Edge.BOTTOM, -45f);
}
/**
* 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-1.2.1/demoapp/src/main/java/com/androidplot/demos/SimplePieChartActivity.java 0000664 0000000 0000000 00000013123 12766537502 0031565 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;
import com.androidplot.util.*;
import java.util.*;
/**
* The simplest possible example of using AndroidPlot to plot some data.
*/
public class SimplePieChartActivity extends Activity
{
public static final int SELECTED_SEGMENT_OFFSET = 50;
private TextView donutSizeTextView;
private SeekBar donutSizeSeekBar;
public 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);
final float padding = PixelUtils.dpToPix(30);
pie.getPie().setPadding(padding, padding, padding, padding);
// 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.getPie().containsPoint(click)) {
Segment segment = pie.getRenderer(PieRenderer.class).getContainingSegment(click);
final boolean isSelected = getFormatter(segment).getOffset() != 0;
deselectAll();
setSelected(segment, !isSelected);
pie.redraw();
}
return false;
}
private SegmentFormatter getFormatter(Segment segment) {
return pie.getFormatter(segment, PieRenderer.class);
}
private void deselectAll() {
List