{
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.2/androidplot-core/src/main/java/com/androidplot/ui/Formatter.java 0000664 0000000 0000000 00000004010 12773640640 0030260 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.halfhp.fig.*;
/**
* 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() {}
public Formatter(Context ctx, int xmlCfgId) {
configure(ctx, xmlCfgId);
}
public void configure(Context ctx, int xmlCfgId) {
Fig.configure(ctx, this, xmlCfgId);
}
/**
*
* @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.2/androidplot-core/src/main/java/com/androidplot/ui/HorizontalPosition.java 0000664 0000000 0000000 00000005124 12773640640 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.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.2/androidplot-core/src/main/java/com/androidplot/ui/HorizontalPositioning.java 0000664 0000000 0000000 00000001506 12773640640 0032700 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.2/androidplot-core/src/main/java/com/androidplot/ui/Insets.java 0000664 0000000 0000000 00000003025 12773640640 0027567 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.2/androidplot-core/src/main/java/com/androidplot/ui/LayoutManager.java 0000664 0000000 0000000 00000021123 12773640640 0031071 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.2/androidplot-core/src/main/java/com/androidplot/ui/LayoutMetric.java 0000664 0000000 0000000 00000003721 12773640640 0030746 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.2/androidplot-core/src/main/java/com/androidplot/ui/PositionMetric.java 0000664 0000000 0000000 00000005357 12773640640 0031304 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.2/androidplot-core/src/main/java/com/androidplot/ui/PositionMetrics.java 0000664 0000000 0000000 00000004133 12773640640 0031456 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.2/androidplot-core/src/main/java/com/androidplot/ui/RenderBundle.java 0000664 0000000 0000000 00000002747 12773640640 0030705 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.2/androidplot-core/src/main/java/com/androidplot/ui/RenderStack.java 0000664 0000000 0000000 00000006757 12773640640 0030546 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.2/androidplot-core/src/main/java/com/androidplot/ui/Resizable.java 0000664 0000000 0000000 00000003025 12773640640 0030242 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.2/androidplot-core/src/main/java/com/androidplot/ui/SeriesAndFormatter.java 0000664 0000000 0000000 00000002521 12773640640 0032063 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.2/androidplot-core/src/main/java/com/androidplot/ui/SeriesRenderer.java 0000664 0000000 0000000 00000010053 12773640640 0031242 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.2/androidplot-core/src/main/java/com/androidplot/ui/Size.java 0000664 0000000 0000000 00000005335 12773640640 0027242 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()));
}
public void setWidth(SizeMetric width) {
this.width = width;
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/ui/SizeMetric.java 0000664 0000000 0000000 00000003774 12773640640 0030413 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
/**
* Encapsulates a sizing algorithm and an associated value.
*
* The available algorithms list are stored in the {@link 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.2/androidplot-core/src/main/java/com/androidplot/ui/SizeMode.java 0000664 0000000 0000000 00000002533 12773640640 0030044 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.2/androidplot-core/src/main/java/com/androidplot/ui/TableModel.java 0000664 0000000 0000000 00000002501 12773640640 0030330 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.2/androidplot-core/src/main/java/com/androidplot/ui/TableOrder.java 0000664 0000000 0000000 00000001370 12773640640 0030346 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.2/androidplot-core/src/main/java/com/androidplot/ui/TableSizingMethod.java 0000664 0000000 0000000 00000001742 12773640640 0031702 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.2/androidplot-core/src/main/java/com/androidplot/ui/TextOrientation.java 0000664 0000000 0000000 00000001360 12773640640 0031462 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.2/androidplot-core/src/main/java/com/androidplot/ui/VerticalPosition.java 0000664 0000000 0000000 00000005036 12773640640 0031624 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.2/androidplot-core/src/main/java/com/androidplot/ui/VerticalPositioning.java 0000664 0000000 0000000 00000001503 12773640640 0032315 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.2/androidplot-core/src/main/java/com/androidplot/ui/widget/ 0000775 0000000 0000000 00000000000 12773640640 0026742 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/ui/widget/EmptyWidget.java 0000664 0000000 0000000 00000002227 12773640640 0032052 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.2/androidplot-core/src/main/java/com/androidplot/ui/widget/TextLabelWidget.java 0000664 0000000 0000000 00000013034 12773640640 0032636 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.2/androidplot-core/src/main/java/com/androidplot/ui/widget/Widget.java 0000664 0000000 0000000 00000032217 12773640640 0031035 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.2/androidplot-core/src/main/java/com/androidplot/util/ 0000775 0000000 0000000 00000000000 12773640640 0026017 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/util/AttrUtils.java 0000664 0000000 0000000 00000025003 12773640640 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.content.res.TypedArray;
import android.graphics.Paint;
import android.util.*;
import com.androidplot.ui.*;
import com.androidplot.ui.Size;
import com.androidplot.ui.widget.Widget;
import com.androidplot.xy.StepMode;
import com.androidplot.xy.StepModel;
/**
* Methods for applying styleable attributes.
*
*/
public class AttrUtils {
private static final String TAG = AttrUtils.class.getName();
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()));
}
}
public static void setColor(TypedArray attrs, Paint paint, int attrId) {
if(paint == null) {
Log.w(TAG, "Attempt to configure null Paint property for attrId: " + attrId);
} else {
paint.setColor(attrs.getColor(attrId, paint.getColor()));
}
}
public 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 != 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.2/androidplot-core/src/main/java/com/androidplot/util/DisplayDimensions.java 0000664 0000000 0000000 00000002744 12773640640 0032327 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.2/androidplot-core/src/main/java/com/androidplot/util/FontUtils.java 0000664 0000000 0000000 00000005155 12773640640 0030617 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.*;
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;
}
/**
* Draws text vertically centered on the specified coordinates
* @param canvas
* @param paint
* @param text
* @param cx
* @param cy
*/
public static void drawTextVerticallyCentered(Canvas canvas, String text, float cx, float cy, Paint paint) {
Rect textBounds = new Rect();
paint.getTextBounds(text, 0, text.length(), textBounds);
canvas.drawText(text, cx, cy - textBounds.exactCenterY(), paint);
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/util/LayerHash.java 0000664 0000000 0000000 00000010365 12773640640 0030547 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.2/androidplot-core/src/main/java/com/androidplot/util/LayerListOrganizer.java 0000664 0000000 0000000 00000006447 12773640640 0032466 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.2/androidplot-core/src/main/java/com/androidplot/util/Layerable.java 0000664 0000000 0000000 00000004137 12773640640 0030567 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.2/androidplot-core/src/main/java/com/androidplot/util/LinkedLayerList.java 0000664 0000000 0000000 00000003664 12773640640 0031732 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.2/androidplot-core/src/main/java/com/androidplot/util/Mapping.java 0000664 0000000 0000000 00000002045 12773640640 0030256 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.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.2/androidplot-core/src/main/java/com/androidplot/util/PixelUtils.java 0000664 0000000 0000000 00000012112 12773640640 0030761 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;
/**
* 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 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);
}
/**
*
* 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.2/androidplot-core/src/main/java/com/androidplot/util/PlotStatistics.java 0000664 0000000 0000000 00000007362 12773640640 0031663 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.2/androidplot-core/src/main/java/com/androidplot/util/RectFUtils.java 0000664 0000000 0000000 00000004121 12773640640 0030704 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.2/androidplot-core/src/main/java/com/androidplot/util/Redrawer.java 0000664 0000000 0000000 00000010326 12773640640 0030437 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.2/androidplot-core/src/main/java/com/androidplot/util/SeriesUtils.java 0000664 0000000 0000000 00000011036 12773640640 0031136 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.*;
import com.androidplot.xy.*;
import java.util.*;
/**
* Utilities for dealing with Series data.
*/
public class SeriesUtils {
public static RectRegion minMax(List seriesList) {
return minMax(null, seriesList);
}
public static RectRegion minMax(XYSeries... seriesList) {
return minMax(null, seriesList);
}
/**
* @param constraints may be null.
* @param seriesList
* @return
* @since 0.9.7
*/
public static RectRegion 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 RectRegion minMax(XYConstraints constraints, XYSeries... seriesArray) {
final RectRegion bounds = new RectRegion();
// 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)) {
minMax(bounds.getxRegion(), xi);
minMax(bounds.getyRegion(), yi);
}
}
}
}
}
return bounds;
}
/**
*
* @param bounds Starting minMax values to work from; only lists values that are greater than or less
* than those in bounds will be be used.
* @param lists lists to be evaluated for min/max values.
* @return the original bounds instance passed in
*/
public static Region minMax(Region bounds, List... lists) {
for (final List list : lists) {
for (final Number i : list) {
minMax(bounds, i);
}
}
return bounds;
}
/**
* Compares a number against the current min/max values in a region, updating the region
* with the new value if appropriate.
* @param bounds
* @param number
* @return
*/
public static Region minMax(Region bounds, Number number) {
if (number != null) {
final double di = number.doubleValue();
if (bounds.getMin() == null || di < bounds.getMin().doubleValue()) {
bounds.setMin(number);
}
if (bounds.getMax() == null || di > bounds.getMax().doubleValue()) {
bounds.setMax(number);
}
}
return bounds;
}
/**
* @param lists
* @return
* @since 0.9.7
*/
public static Region minMax(List... lists) {
return minMax(new Region(), lists);
}
public static void main(String[] args) {
// seed the list:
ArrayList values = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
values.add(Math.random() * 100);
}
final int numIterations = 20;
long sumTime = 0;
for(int j = 0; j < numIterations; j++) {
final long startTime = System.currentTimeMillis();
Region bounds = minMax(values);
final long thisIteration = System.currentTimeMillis() - startTime;
System.out.println("thisIteration took: " + thisIteration + "ms");
sumTime += thisIteration;
}
System.out.println("Benchmark avg:" + (sumTime / numIterations) + "ms.");
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/ 0000775 0000000 0000000 00000000000 12773640640 0025502 5 ustar 00root root 0000000 0000000 AdvancedLineAndPointRenderer.java 0000664 0000000 0000000 00000010525 12773640640 0033732 0 ustar 00root root 0000000 0000000 androidplot-1.2.2/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.content.*;
import android.graphics.*;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.RenderStack;
import com.androidplot.ui.SeriesRenderer;
/**
* 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;
for (int i = 0; i < series.size(); i++) {
Number y = series.getY(i);
Number x = series.getX(i);
if (y != null && x != null) {
thisPoint = getPlot().getBounds()
.transformScreen(x, y, plotArea);
} 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 static final int DEFAULT_STROKE_WIDTH = 3;
private Paint linePaint;
public Formatter() {
linePaint = new Paint();
linePaint.setStrokeWidth(DEFAULT_STROKE_WIDTH);
linePaint.setColor(Color.RED);
}
public Formatter(Context context, int xmlConfigId) {
this();
configure(context, xmlConfigId);
}
@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.2/androidplot-core/src/main/java/com/androidplot/xy/Axis.java 0000664 0000000 0000000 00000001273 12773640640 0027254 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.2/androidplot-core/src/main/java/com/androidplot/xy/BarFormatter.java 0000664 0000000 0000000 00000004151 12773640640 0030736 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.content.*;
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;
/**
* Should only be used in conjunction with calls to configure()...
*/
public BarFormatter() {
fillPaint = new Paint();
fillPaint.setStyle(Paint.Style.FILL);
fillPaint.setAlpha(100);
borderPaint = new Paint();
borderPaint.setStyle(Paint.Style.STROKE);
borderPaint.setAlpha(100);
}
public BarFormatter(int fillColor, int borderColor) {
this();
fillPaint.setColor(fillColor);
borderPaint.setColor(borderColor);
}
public BarFormatter(Context context, int xmlCfgId) {
this();
configure(context, xmlCfgId);
}
@Override
public Class getRendererClass() {
return BarRenderer.class;
}
@Override
public SeriesRenderer getRendererInstance(XYPlot plot) {
return new BarRenderer(plot);
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/BarRenderer.java 0000664 0000000 0000000 00000036002 12773640640 0030541 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;
/**
* Renders the points in an XYSeries as bars.
*/
public class BarRenderer extends GroupRenderer {
private Style style = Style.OVERLAID; // default Render Style
private BarWidthMode barWidthMode = BarWidthMode.FIXED_WIDTH; // default Width Style
private float barWidth = 5;
private float barGap = 1;
private Comparator barComparator = new BarComparator();
/**
* How bars should be laid out when in a group of 2 or more series.
*/
public enum Style {
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
}
/**
* Mode with which to calculate the width of each bar.
*/
public enum BarWidthMode {
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 setStyle(Style renderStyle) {
this.style = renderStyle;
}
public Style getStyle() {
return this.style;
}
public void setBarWidthMode(BarWidthMode widthStyle) {
this.barWidthMode = widthStyle;
}
public BarWidthMode getBarWidthMode() {
return this.barWidthMode;
}
public void setBarWidth(BarWidthMode mode, float value) {
setBarWidthMode(mode);
switch (mode) {
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) {
if(formatter.hasFillPaint()) {
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 (barWidthMode) {
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) getPlot().getBounds().yRegion
.transform(rangeOrigin, plotArea.top, plotArea.bottom, true);
switch (style) {
case OVERLAID:
Collections.sort(barGroup.bars, barComparator);
for (Bar bar : barGroup.bars) {
BarFormatter formatter = bar.getFormatter();
PointLabelFormatter plf = formatter.hasPointLabelFormatter()
? formatter.getPointLabelFormatter() : null;
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 (formatter.hasFillPaint() && 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 && plf.hasTextPaint() && 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.hasPointLabelFormatter()
? formatter.getPointLabelFormatter() : null;
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 (formatter.hasFillPaint() && 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 && plf.hasTextPaint() && 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.hasPointLabelFormatter()
? formatter.getPointLabelFormatter() : null;
PointLabeler pointLabeler = null;
if (formatter != null) {
pointLabeler = formatter.getPointLabeler();
}
int height = (int) b.barGroup.plotArea.bottom - b.intY;
int top = bottom - height;
if (formatter.hasFillPaint() && 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 && plf.hasTextPaint() && 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 double 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 = getPlot().getBounds().getxRegion()
.transform(xVal, plotArea.left, plotArea.right, false);
this.intX = (int) Math.round(pixX);
if (series.getY(seriesIndex) != null) {
this.yVal = series.getY(seriesIndex).doubleValue();
this.pixY = getPlot().getBounds().yRegion
.transform(yVal, plotArea.top, plotArea.bottom, true);
this.intY = (int) Math.round(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 (style) {
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.2/androidplot-core/src/main/java/com/androidplot/xy/BoundaryMode.java 0000664 0000000 0000000 00000001363 12773640640 0030740 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.2/androidplot-core/src/main/java/com/androidplot/xy/BubbleFormatter.java 0000664 0000000 0000000 00000004621 12773640640 0031427 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.content.*;
import android.graphics.*;
import com.androidplot.ui.*;
import com.androidplot.util.*;
/**
* Format for drawing a value using {@link BubbleRenderer}.
* @since 1.2.2
*/
public class BubbleFormatter extends XYSeriesFormatter {
private static final float DEFAULT_STROKE_PIX = 1;
private Paint strokePaint;
private Paint fillPaint;
{
strokePaint = new Paint();
strokePaint.setAntiAlias(true);
strokePaint.setStrokeWidth(PixelUtils.dpToPix(DEFAULT_STROKE_PIX));
strokePaint.setStyle(Paint.Style.STROKE);
fillPaint = new Paint();
fillPaint.setAntiAlias(true);
// default point labeler should draw z for bubbles:
setPointLabeler(new PointLabeler() {
@Override
public String getLabel(BubbleSeries series, int index) {
return series.getZ(index) + "";
}
});
}
public BubbleFormatter(Context context, int xmlCfgId) {
configure(context, xmlCfgId);
}
public BubbleFormatter(int fillColor, int strokeColor) {
fillPaint.setColor(fillColor);
strokePaint.setColor(strokeColor);
}
@Override
public Class getRendererClass() {
return BubbleRenderer.class;
}
@Override
public SeriesRenderer getRendererInstance(XYPlot plot) {
return new BubbleRenderer(plot);
}
public Paint getStrokePaint() {
return strokePaint;
}
public void setStrokePaint(Paint strokePaint) {
this.strokePaint = strokePaint;
}
public Paint getFillPaint() {
return fillPaint;
}
public void setFillPaint(Paint fillPaint) {
this.fillPaint = fillPaint;
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/BubbleRenderer.java 0000664 0000000 0000000 00000012701 12773640640 0031230 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import android.graphics.*;
import com.androidplot.Region;
import com.androidplot.exception.*;
import com.androidplot.ui.*;
import com.androidplot.util.*;
/**
* Renders three dimensional data onto an {@link XYPlot} as bubbles; the x/y values define the position
* of the bubble and z is uses as a scaling value for the bubble's radius.
* @since 1.2.2
*/
public class BubbleRenderer extends XYSeriesRenderer {
protected static final float MIN_BUBBLE_RADIUS_DEFAULT_DP = 9;
protected static final float MAX_BUBBLE_RADIUS_DEFAULT_DP = 25;
private Region bubbleBounds;
private BubbleScaleMode bubbleScaleMode = BubbleScaleMode.SQUARE_ROOT;
public enum BubbleScaleMode {
/**
* Bubble radius is scaled directly by {@link BubbleSeries} z-vals
*/
LINEAR,
/**
* Bubble radius is scaled by the square root of {@link BubbleSeries} z-vals.
* This is the default scaling used.
*/
SQUARE_ROOT
}
public BubbleRenderer(XYPlot plot) {
super(plot);
bubbleBounds = new Region(
PixelUtils.dpToPix(MIN_BUBBLE_RADIUS_DEFAULT_DP),
PixelUtils.dpToPix(MAX_BUBBLE_RADIUS_DEFAULT_DP));
}
@Override
protected void onRender(Canvas canvas, RectF plotArea, BubbleSeries series,
FormatterType formatter, RenderStack stack) throws PlotRenderException {
Region magnitudeBounds = calculateBounds();
for(int i = 0; i < series.size(); i++) {
// only render non-null values greater than zero:
if(series.getY(i) != null && series.getZ(i).doubleValue() > 0) {
final PointF centerPoint = getPlot().getBounds().
transform(series.getX(i), series.getY(i), plotArea, false, true);
// calculate bubble radius:
float bubbleRadius = magnitudeBounds.
transform(bubbleScaleMode == BubbleScaleMode.SQUARE_ROOT ?
Math.sqrt(series.getZ(i).doubleValue()) :
series.getZ(i).doubleValue(), bubbleBounds).floatValue();
drawBubble(canvas, formatter, series, i, centerPoint, bubbleRadius);
}
}
}
/**
* Render a bubble onto the canvas
* @param canvas
* @param formatter
* @param series
* @param index
* @param centerPoint the x/y coords of the center of the bubble
* @param radius size of the bubble
*/
protected void drawBubble(Canvas canvas, FormatterType formatter, BubbleSeries series,
int index, PointF centerPoint, float radius) {
canvas.drawCircle(centerPoint.x, centerPoint.y, radius, formatter.getFillPaint());
canvas.drawCircle(centerPoint.x, centerPoint.y, radius, formatter.getStrokePaint());
if(series != null && formatter.hasPointLabelFormatter() && formatter.getPointLabeler() != null) {
FontUtils.drawTextVerticallyCentered(
canvas,
formatter.getPointLabeler().getLabel(series, index),
centerPoint.x,
centerPoint.y,
formatter.getPointLabelFormatter().getTextPaint());
}
}
@Override
protected void doDrawLegendIcon(Canvas canvas, RectF rect, FormatterType formatter) {
drawBubble(canvas, formatter, null, 0,
new PointF(rect.centerX(), rect.centerY()), (rect.width()/2.5f));
}
public float getMinBubbleRadius() {
return bubbleBounds.getMin().floatValue();
}
public void setMinBubbleRadius(float minBubbleRadius) {
bubbleBounds.setMin(minBubbleRadius);
}
public float getMaxBubbleRadius() {
return bubbleBounds.getMax().floatValue();
}
public void setMaxBubbleRadius(float maxBubbleRadius) {
bubbleBounds.setMax(maxBubbleRadius);
}
public BubbleScaleMode getBubbleScaleMode() {
return bubbleScaleMode;
}
public void setBubbleScaleMode(BubbleScaleMode bubbleScaleMode) {
this.bubbleScaleMode = bubbleScaleMode;
}
protected Region calculateBounds() {
Region bounds = new Region();
for(SeriesAndFormatter f : getSeriesAndFormatterList()) {
SeriesUtils.minMax(bounds, f.getSeries().getZVals());
}
if(bounds.getMax() != null && bounds.getMax().doubleValue() > 0) {
if(bubbleScaleMode == BubbleScaleMode.SQUARE_ROOT) {
// scale for easier visual interpretation. see:
// https://en.wikipedia.org/wiki/Bubble_chart#Choosing_bubble_sizes_correctly
bounds.setMax(Math.sqrt(bounds.getMax().doubleValue()));
}
} else {
// no non-null, greater than zero vals so bounds are undefined
return null;
}
if(bounds.getMin().doubleValue() > 0) {
if(bubbleScaleMode == BubbleScaleMode.SQUARE_ROOT) {
// scale for easier visual interpretation. see:
// https://en.wikipedia.org/wiki/Bubble_chart#Choosing_bubble_sizes_correctly
bounds.setMin(Math.sqrt(bounds.getMin().doubleValue()));
}
} else {
// if the smallest value is negative, use zero instead since those vals arent visible:
bounds.setMax(0);
}
return bounds;
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/BubbleSeries.java 0000664 0000000 0000000 00000002425 12773640640 0030716 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import java.util.*;
/**
* Created by halfhp on 9/17/16.
*/
public class BubbleSeries implements XYSeries {
private List xVals;
private List yVals;
private List zVals;
private String title;
public BubbleSeries(List yVals, List zVals, String title) {
this.yVals = yVals;
this.zVals = zVals;
this.title = title;
// populate x with iVals:
this.xVals = new ArrayList<>(zVals.size());
for(int i = 0; i < zVals.size(); i++) {
this.xVals.add(i);
}
}
public BubbleSeries(List xVals, List yVals, List zVals, String title) {
this.xVals = xVals;
this.yVals = yVals;
this.zVals = zVals;
this.title = title;
}
@Override
public String getTitle() {
return title;
}
@Override
public int size() {
return xVals.size();
}
@Override
public Number getX(int index) {
return xVals.get(index);
}
@Override
public Number getY(int index) {
return yVals.get(index);
}
public Number getZ(int index) {
return zVals.get(index);
}
public List getZVals() {
return zVals;
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/CandlestickFormatter.java 0000664 0000000 0000000 00000013534 12773640640 0032463 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.content.*;
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,
TRIANGULAR
}
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(Context context, int xmlCfgId) {
this();
configure(context, xmlCfgId);
}
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.2/androidplot-core/src/main/java/com/androidplot/xy/CandlestickMaker.java 0000664 0000000 0000000 00000007007 12773640640 0031555 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.2/androidplot-core/src/main/java/com/androidplot/xy/CandlestickRenderer.java 0000664 0000000 0000000 00000014324 12773640640 0032264 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 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 {
protected static final int HIGH_INDEX = 0;
protected static final int LOW_INDEX = 1;
protected static final int OPEN_INDEX = 2;
protected 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) {
final FormatterType formatter = sfList.get(0).getFormatter();
for(int i = 0; i < seriesSize; i++) {
final XYSeries highSeries = sfList.get(HIGH_INDEX).getSeries();
final XYSeries lowSeries = sfList.get(LOW_INDEX).getSeries();
final XYSeries openSeries = sfList.get(OPEN_INDEX).getSeries();
final XYSeries closeSeries = sfList.get(CLOSE_INDEX).getSeries();
// x-val for all series should be identical so just grab x from the first series:
Number x = highSeries.getX(i);
Number high = highSeries.getY(i);
Number low = lowSeries.getY(i);
Number open = openSeries.getY(i);
Number close = closeSeries.getY(i);
// draw the candlestick:
final PointF highPix = getPlot().getBounds().transformScreen(x, high, plotArea);
final PointF lowPix = getPlot().getBounds().transformScreen(x, low, plotArea);
final PointF openPix = getPlot().getBounds().transformScreen(x, open, plotArea);
final PointF closePix = getPlot().getBounds().transformScreen(x, close, plotArea);
drawWick(canvas, highPix, lowPix, formatter);
drawBody(canvas, openPix, closePix, formatter);
drawUpperCap(canvas, highPix, formatter);
drawLowerCap(canvas, lowPix, formatter);
// draw labels, if any:
final PointLabelFormatter plf = formatter.hasPointLabelFormatter()
? formatter.getPointLabelFormatter() : null;
final PointLabeler pointLabeler = formatter.getPointLabeler();
if(plf != null && pointLabeler != null) {
drawTextLabel(canvas, highPix, pointLabeler.getLabel(highSeries, i), plf);
drawTextLabel(canvas, lowPix, pointLabeler.getLabel(lowSeries, i), plf);
drawTextLabel(canvas, openPix, pointLabeler.getLabel(openSeries, i), plf);
drawTextLabel(canvas, closePix, pointLabeler.getLabel(closeSeries, i), plf);
}
}
}
protected void drawTextLabel(Canvas canvas, PointF coords, String text, PointLabelFormatter plf) {
if(text != null) {
canvas.drawText(text, coords.x + plf.hOffset, coords.y + plf.vOffset, plf.getTextPaint());
}
}
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 TRIANGULAR:
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.2/androidplot-core/src/main/java/com/androidplot/xy/CandlestickSeries.java 0000664 0000000 0000000 00000010643 12773640640 0031750 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.2/androidplot-core/src/main/java/com/androidplot/xy/CatmullRomInterpolator.java 0000664 0000000 0000000 00000024222 12773640640 0033031 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.2/androidplot-core/src/main/java/com/androidplot/xy/FastLineAndPointRenderer.java 0000664 0000000 0000000 00000013143 12773640640 0033200 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 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 = getPlot().getBounds().transformScreen(x, y, plotArea);
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);
}
}
}
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.hasLinePaint()) {
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.2/androidplot-core/src/main/java/com/androidplot/xy/FillDirection.java 0000664 0000000 0000000 00000002253 12773640640 0031076 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.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.2/androidplot-core/src/main/java/com/androidplot/xy/GroupRenderer.java 0000664 0000000 0000000 00000005730 12773640640 0031135 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, or in other
* words data with potentially more than two dimensions.
* Examples of such data are bar plot groups and candlestick charts.
* @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.2/androidplot-core/src/main/java/com/androidplot/xy/InterpolationParams.java 0000664 0000000 0000000 00000001476 12773640640 0032350 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.2/androidplot-core/src/main/java/com/androidplot/xy/Interpolator.java 0000664 0000000 0000000 00000001541 12773640640 0031030 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.2/androidplot-core/src/main/java/com/androidplot/xy/LineAndPointFormatter.java 0000664 0000000 0000000 00000014417 12773640640 0032564 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.*;
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;
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;
public LineAndPointFormatter(Context context, int xmlCfgId) {
super(context, xmlCfgId);
}
/**
* 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);
}
}
/**
*
* @return True if linePaint has been set, false otherwise.
*/
public boolean hasLinePaint() {
return linePaint != null;
}
/**
* Get the {@link Paint} used to draw lines. Will instantiate and a new default instance
* if it is currently null. To check whether or not line paint has been set, use
* {@link #hasLinePaint()}.
* @return
*/
public Paint getLinePaint() {
if(linePaint == null) {
initLinePaint(Color.TRANSPARENT);
}
return linePaint;
}
public void setLinePaint(Paint linePaint) {
this.linePaint = linePaint;
}
/**
*
* @return True if vertexPaint has been set, false otherwise.
*/
public boolean hasVertexPaint() {
return vertexPaint != null;
}
/**
* Get the {@link Paint} used to draw vertices (points). Will instantiate and a new default instance
* if it is currently null. To check whether or not vertex paint has been set, use
* {@link #hasVertexPaint()}.
* @return
*/
public Paint getVertexPaint() {
if(vertexPaint == null) {
initVertexPaint(Color.TRANSPARENT);
}
return vertexPaint;
}
public void setVertexPaint(Paint vertexPaint) {
this.vertexPaint = vertexPaint;
}
/**
*
* @return True if fillPaint has been set, false otherwise.
*/
public boolean hasFillPaint() {
return fillPaint != null;
}
/**
* Get the {@link Paint} used to fill series areas. Will instantiate and a new default instance
* if it is currently null. To check whether or not fill paint has been set, use
* {@link #hasFillPaint()}.
* @return
*/
public Paint getFillPaint() {
if(fillPaint == null) {
initFillPaint(Color.TRANSPARENT);
}
return fillPaint;
}
public void setFillPaint(Paint fillPaint) {
this.fillPaint = fillPaint;
}
public InterpolationParams getInterpolationParams() {
return interpolationParams;
}
public void setInterpolationParams(InterpolationParams params) {
this.interpolationParams = params;
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/LineAndPointRenderer.java 0000664 0000000 0000000 00000023236 12773640640 0032366 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 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.hasLinePaint()) {
canvas.drawLine(rect.left, rect.bottom, rect.right, rect.top, formatter.getLinePaint());
}
if(formatter.hasVertexPaint()) {
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 = getPlot().getBounds().transformScreen(x, y, plotArea);
points.add(thisPoint);
} else {
thisPoint = null;
}
// don't need to do any of this if the line isnt going to be drawn:
if(formatter.hasLinePaint() && 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(formatter.hasLinePaint()) {
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 getPlot().getBounds().transformScreen(coord, plotArea);
}
protected void renderPoints(Canvas canvas, RectF plotArea, XYSeries series, List points,
LineAndPointFormatter formatter) {
//PointLabelFormatter plf = formatter.getPointLabelFormatter();
if (formatter.hasVertexPaint() || formatter.hasPointLabelFormatter()) {
int i = 0;
for (PointF p : points) {
PointLabeler pointLabeler = formatter.getPointLabeler();
// if vertexPaint is available, draw vertex:
if (formatter.hasVertexPaint()) {
canvas.drawPoint(p.x, p.y, formatter.getVertexPaint());
}
// if textPaint and pointLabeler are available, draw point's text label:
if (formatter.hasPointLabelFormatter() && pointLabeler != null) {
final PointLabelFormatter plf = formatter.getPointLabelFormatter();
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) getPlot().getBounds().getxRegion()
.transform(getPlot().getRangeOrigin()
.doubleValue(), plotArea.top, plotArea.bottom, true);
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());
}
final RectRegion bounds = getPlot().getBounds();
final RectRegion plotRegion = new RectRegion(plotArea);
// draw each region:
for (RectRegion thisRegion : bounds.intersects(formatter.getRegions().elements())) {
XYRegionFormatter regionFormatter = formatter.getRegionFormatter(thisRegion);
RectRegion thisRegionTransformed = bounds
.transform(thisRegion, plotRegion, false, true);
thisRegionTransformed.clip(plotRegion);
RectF thisRegionRectF = thisRegionTransformed.asRectF();
if (thisRegionRectF != null) {
try {
canvas.save(Canvas.ALL_SAVE_FLAG);
canvas.clipPath(path);
canvas.drawRect(thisRegionRectF, regionFormatter.getPaint());
} finally {
canvas.restore();
}
}
}
// finally we draw the outline path on top of everything else:
if(formatter.hasLinePaint()) {
canvas.drawPath(outlinePath, formatter.getLinePaint());
}
path.rewind();
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/PanZoom.java 0000664 0000000 0000000 00000036401 12773640640 0027734 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 {
final RectRegion bounds = plot.getBounds();
minXLimit = lowerBoundaryMode == BoundaryMode.FIXED ?
lowerBoundary.floatValue() : bounds.getMinX().floatValue();
maxXLimit = upperBoundaryMode == BoundaryMode.FIXED ?
upperBoundary.floatValue() : bounds.getMaxX().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 {
final RectRegion bounds = plot.getBounds();
minYLimit = lowerBoundaryMode == BoundaryMode.FIXED ?
lowerBoundary.floatValue() : bounds.getMinY().floatValue();
maxYLimit = upperBoundaryMode == BoundaryMode.FIXED ?
upperBoundary.floatValue() : bounds.getMaxY().floatValue();
lastMinY = minYLimit;
lastMaxY = maxYLimit;
}
}
protected void setDomainBoundaries(final Number lowerBoundary,
final Number upperBoundary, final BoundaryMode mode) {
plot.setDomainBoundaries(lowerBoundary, mode, upperBoundary, mode);
}
protected synchronized void setRangeBoundaries(final Number lowerBoundary,
final Number upperBoundary, final BoundaryMode mode) {
plot.setRangeBoundaries(lowerBoundary, mode, upperBoundary, mode);
}
@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.getBounds().getMinX().floatValue();
lastMinX = minXLimit;
}
return minXLimit;
}
protected float getMaxXLimit() {
if(maxXLimit == Float.MAX_VALUE) {
maxXLimit = plot.getBounds().getMaxX().floatValue();
lastMaxX = maxXLimit;
}
return maxXLimit;
}
protected float getMinYLimit() {
if(minYLimit == Float.MAX_VALUE) {
minYLimit = plot.getBounds().getMinY().floatValue();
lastMinY = minYLimit;
}
return minYLimit;
}
protected float getMaxYLimit() {
if(maxYLimit == Float.MAX_VALUE) {
maxYLimit = plot.getBounds().getMaxY().floatValue();
lastMaxY = maxYLimit;
}
return maxYLimit;
}
protected float getLastMinX() {
if(lastMinX == Float.MAX_VALUE) {
lastMinX = plot.getBounds().getMinX().floatValue();
}
return lastMinX;
}
protected float getLastMaxX() {
if(lastMaxX == Float.MAX_VALUE) {
lastMaxX = plot.getBounds().getMaxX().floatValue();
}
return lastMaxX;
}
protected float getLastMinY() {
if(lastMinY == Float.MAX_VALUE) {
lastMinY = plot.getBounds().getMinY().floatValue();
}
return lastMinY;
}
private float getLastMaxY() {
if(lastMaxY == Float.MAX_VALUE) {
lastMaxY = plot.getBounds().getMaxY().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.2/androidplot-core/src/main/java/com/androidplot/xy/PointLabelFormatter.java 0000664 0000000 0000000 00000005120 12773640640 0032260 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.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 boolean hasTextPaint() {
return textPaint != null;
}
public Paint getTextPaint() {
if(textPaint == null) {
initTextPaint(Color.TRANSPARENT);
}
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.2/androidplot-core/src/main/java/com/androidplot/xy/PointLabeler.java 0000664 0000000 0000000 00000001403 12773640640 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;
public interface PointLabeler {
String getLabel(SeriesType series, int index);
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/RectRegion.java 0000664 0000000 0000000 00000026343 12773640640 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.xy;
import android.graphics.PointF;
import android.graphics.RectF;
import com.androidplot.Region;
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 {
Region xRegion;
Region yRegion;
private String label;
public RectRegion() {
xRegion = new Region();
yRegion = new Region();
}
public static RectRegion withDefaults(RectRegion defaults) {
if(defaults == null || !defaults.isFullyDefined()) {
throw new IllegalArgumentException("When specifying defaults, RectRegion param must contain no null values.");
}
RectRegion r = new RectRegion();
r.xRegion = Region.withDefaults(defaults.getxRegion());
r.yRegion = Region.withDefaults(defaults.getyRegion());
return r;
}
public RectRegion(XYCoords min, XYCoords max) {
this(min.x, max.x, min.y, max.y);
}
/**
* @param minX
* @param maxX
* @param minY
* @param maxY
*/
public RectRegion(Number minX, Number maxX, Number minY, Number maxY, String label) {
xRegion = new Region(minX, maxX);
yRegion = new Region(minY, maxY);
this.setLabel(label);
}
public RectRegion(RectF rect) {
this(rect.left < rect.right ? rect.left : rect.right,
rect.right > rect.left ? rect.right : rect.left,
rect.bottom < rect.top ? rect.bottom : rect.top,
rect.top > rect.bottom ? rect.top : rect.bottom);
}
@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 xRegion.contains(value);
}
public boolean containsRangeValue(Number value) {
return yRegion.contains(value);
}
public XYCoords transform(Number x, Number y, RectRegion region2, boolean flipX, boolean flipY) {
Number xx = xRegion.transform(x.doubleValue(), region2.xRegion, flipX);
Number yy = yRegion.transform(y.doubleValue(), region2.yRegion, flipY);
return new XYCoords(xx, yy);
}
public XYCoords transform(Number x, Number y, RectRegion region2) {
return transform(x, y, region2, false, false);
}
public XYCoords transform(XYCoords value, RectRegion region2) {
return transform(value.x, value.y, region2);
}
/**
* Transform a region (r) from the current region space (this) into the specified one (r2)
* @param r The region to which the transformation applies
* @param r2 The region into which r is being transformed
* @return
*/
public RectRegion transform(RectRegion r, RectRegion r2, boolean flipX, boolean flipY) {
return new RectRegion(
transform(r.getMinX(), r.getMinY(), r2, flipX, flipY),
transform(r.getMaxX(), r.getMaxY(), r2, flipX, flipY)
);
}
/**
* Convenience method to transform into screen coordinate space. Equivalent to invoking
* {@link #transform(Number, Number, RectF, boolean, boolean)} with
* flipX = false and flipY = true.
* @param x
* @param y
* @param region2
* @return
*/
public PointF transformScreen(Number x, Number y, RectF region2) {
return transform(x, y, region2, false, true);
}
public PointF transform(Number x, Number y, RectF region2, boolean flipX, boolean flipY) {
float xx = (float) xRegion.transform(x.doubleValue(), region2.left, region2.right, flipX);
float yy = (float) yRegion.transform(y.doubleValue(), region2.top, region2.bottom, flipY);
return new PointF(xx, yy);
}
public PointF transformScreen(XYCoords value, RectF region2) {
return transform(value, region2, false, true);
}
/**
* Convenience method to transform into screen coordinate space. Equivalent to invoking
* {@link #transform(XYCoords, RectF, boolean, boolean)} with flipX = false and flipY = true.
* @param value
* @param region2
* @param flipX
* @param flipY
* @return
*/
public PointF transform(XYCoords value, RectF region2, boolean flipX, boolean flipY) {
return transform(value.x, value.y, region2, flipX, flipY);
}
/**
* 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(RectRegion input) {
xRegion.union(input.xRegion);
yRegion.union(input.yRegion);
}
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 xRegion.intersects(minX, maxX) && yRegion.intersects(minY, maxY);
}
public RectF asRectF() {
return new RectF(getMinX().floatValue(), getMinY().floatValue(),
getMaxX().floatValue(), getMaxY().floatValue());
}
// public RectF getRectF(RectF plotRect, Number visMinX, Number visMaxX, Number visMinY,
// Number visMaxY) {
// PointF topLeftPoint = transform(new XYCoords(
// xRegion.getMin().doubleValue() != Double.NEGATIVE_INFINITY
// ? xRegion.getMin() : visMinX,
// yRegion.getMax().doubleValue() != Double.POSITIVE_INFINITY
// ? yRegion.getMax() : visMaxY), plotRect, false, true);
//
// PointF bottomRightPoint = transform(new XYCoords(
// xRegion.getMin().doubleValue() != Double.NEGATIVE_INFINITY
// ? xRegion.getMin() : visMaxX,
// yRegion.getMax().doubleValue() != Double.POSITIVE_INFINITY
// ? yRegion.getMax() : visMinY), plotRect, false, true);
// return new RectF(
// topLeftPoint.x,
// topLeftPoint.y,
// bottomRightPoint.x,
// bottomRightPoint.y);
// }
public void clip(RectRegion clippingBounds) {
if(getMinX().doubleValue() < clippingBounds.getMinX().doubleValue()) {
setMinX(clippingBounds.getMinX());
}
if(getMinY().doubleValue() < clippingBounds.getMinY().doubleValue()) {
setMinY(clippingBounds.getMinY());
}
if(getMaxX().doubleValue() > clippingBounds.getMaxX().doubleValue()) {
setMaxX(clippingBounds.getMaxX());
}
if(getMaxY().doubleValue() > clippingBounds.getMaxY().doubleValue()) {
setMaxY(clippingBounds.getMaxY());
}
}
/**
* 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
* @return
*/
public List intersects(List regions) {
ArrayList intersectingRegions = new ArrayList<>();
for (RectRegion r : regions) {
if (r.intersects(getMinX(), getMaxX(), getMinY(), getMaxY())) {
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 boolean isMinXSet() {
return xRegion.isMinSet();
}
public Number getMinX() {
return xRegion.getMin();
}
public void setMinX(Number minX) {
xRegion.setMin(minX);
}
public boolean isMaxXSet() {
return xRegion.isMaxSet();
}
public Number getMaxX() {
return xRegion.getMax();
}
public void setMaxX(Number maxX) {
xRegion.setMax(maxX);
}
public boolean isMinYSet() {
return yRegion.isMinSet();
}
public Number getMinY() {
return yRegion.getMin();
}
public void setMinY(Number minY) {
yRegion.setMin(minY);
}
public boolean isMaxYSet() {
return yRegion.isMaxSet();
}
public Number getMaxY() {
return yRegion.getMax();
}
public void setMaxY(Number maxY) {
yRegion.setMax(maxY);
}
public String getLabel() {
return label;
}
public void setLabel(String label) {
this.label = label;
}
public Region getxRegion() {
return xRegion;
}
public void setxRegion(Region xRegion) {
this.xRegion = xRegion;
}
public Region getyRegion() {
return yRegion;
}
public void setyRegion(Region yRegion) {
this.yRegion = yRegion;
}
/**
*
* @return True if both xRegion and yRegion are defined, false otherwise
*/
public boolean isFullyDefined() {
return xRegion.isDefined() && yRegion.isDefined();
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/SimpleXYSeries.java 0000664 0000000 0000000 00000022165 12773640640 0031240 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.2/androidplot-core/src/main/java/com/androidplot/xy/Step.java 0000664 0000000 0000000 00000003042 12773640640 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;
/**
* 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.2/androidplot-core/src/main/java/com/androidplot/xy/StepFormatter.java 0000664 0000000 0000000 00000002425 12773640640 0031147 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.SeriesRenderer;
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.2/androidplot-core/src/main/java/com/androidplot/xy/StepMode.java 0000664 0000000 0000000 00000001650 12773640640 0030067 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.2/androidplot-core/src/main/java/com/androidplot/xy/StepModel.java 0000664 0000000 0000000 00000002242 12773640640 0030241 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.2/androidplot-core/src/main/java/com/androidplot/xy/StepRenderer.java 0000664 0000000 0000000 00000002264 12773640640 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.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.2/androidplot-core/src/main/java/com/androidplot/xy/ValueMarker.java 0000664 0000000 0000000 00000007410 12773640640 0030565 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.2/androidplot-core/src/main/java/com/androidplot/xy/XValueMarker.java 0000664 0000000 0000000 00000003604 12773640640 0030716 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.2/androidplot-core/src/main/java/com/androidplot/xy/XYConstraints.java 0000664 0000000 0000000 00000011106 12773640640 0031134 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 and enabling 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.2/androidplot-core/src/main/java/com/androidplot/xy/XYCoords.java 0000664 0000000 0000000 00000001554 12773640640 0030064 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() {}
public XYCoords(Number x, Number y) {
this.x = x;
this.y = y;
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/XYFramingModel.java 0000664 0000000 0000000 00000001333 12773640640 0031172 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.2/androidplot-core/src/main/java/com/androidplot/xy/XYGraphWidget.java 0000664 0000000 0000000 00000113732 12773640640 0031042 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.Region;
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 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;
}
}
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);
}
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;
}
}
{
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);
}
/**
* 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);
AttrUtils.setColor(attrs, getBackgroundPaint(),
R.styleable.xy_XYPlot_graphBackgroundColor);
AttrUtils.setColor(attrs, getGridBackgroundPaint(),
R.styleable.xy_XYPlot_gridBackgroundColor);
}
/**
* Convenience method. Wraps getYVal(float)
*
* @param point
* @return
*/
public Number getYVal(PointF point) {
return getYVal(point.y);
}
/**
* Converts a y pixel to a y value.
*
* @param yPix
* @return
*/
public Number getYVal(float yPix) {
if (!plot.getBounds().getyRegion().isDefined()) {
return null;
}
return new Region(gridRect.top, gridRect.bottom)
.transform(yPix, plot.getBounds().getyRegion(), true);
}
/**
* Convenience method. Wraps getXVal(float)
*
* @param point
* @return
*/
public Number getXVal(PointF point) {
return getXVal(point.x);
}
/**
* Converts an x pixel into an x value.
*
* @param xPix
* @return
*/
public Number getXVal(float xPix) {
if (!plot.getBounds().xRegion.isDefined()) {
return null;
}
return new Region(gridRect.left, gridRect.right)
.transform(xPix, plot.getBounds().getxRegion());
}
@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) {
final RectRegion bounds = plot.getBounds();
if (bounds.getMinX() != null
&& bounds.getMaxX() != null
&& bounds.getMinY() != null
&& bounds.getMaxY() != null) {
if(drawGridOnTop) {
drawData(canvas);
drawGrid(canvas);
} else {
drawGrid(canvas);
drawData(canvas);
}
drawCursors(canvas);
if (isDrawMarkersEnabled()) {
drawMarkers(canvas);
}
}
}
}
protected 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);
}
protected 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) {
domainOrigin = plot.getBounds().getxRegion().transform(
plot.getDomainOrigin().doubleValue(), gridRect.left, gridRect.right, false);
} else {
// if no domain origin is set, use the leftmost value visible on the grid:
domainOrigin = gridRect.left;
}
Step domainStep = XYStepCalculator.getStep(plot, Axis.DOMAIN, gridRect);
// 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) {
rangeOrigin = plot.getBounds().getyRegion().transform(
plot.getRangeOrigin().doubleValue(), gridRect.top, gridRect.bottom, true);
} else {
// if no range origin is set, use the bottom-most value visible on the grid:
rangeOrigin = gridRect.bottom;
}
Step rangeStep = XYStepCalculator.getStep(plot, Axis.RANGE, gridRect);
// 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) {
if(plot.getYValueMarkers() != null && plot.getYValueMarkers().size() > 0) {
for (YValueMarker marker : plot.getYValueMarkers()) {
if (marker.getValue() != null) {
float yPix = (float) plot.getBounds().yRegion
.transform(marker.getValue()
.doubleValue(), gridRect.top, gridRect.bottom, true);
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);
}
}
}
}
if(plot.getXValueMarkers() != null && plot.getXValueMarkers().size() > 0) {
for (XValueMarker marker : plot.getXValueMarkers()) {
if (marker.getValue() != null) {
float xPix = (float) plot.getBounds().xRegion
.transform(marker.getValue()
.doubleValue(), gridRect.left, gridRect.right, false);
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 Number getDomainCursorVal() {
return getXVal(getDomainCursorPosition());
}
public void setDomainCursorPosition(float domainCursorPosition) {
this.domainCursorPosition = domainCursorPosition;
}
public float getRangeCursorPosition() {
return rangeCursorPosition;
}
public Number 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;
}
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;
}
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;
}
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;
}
/**
* 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);
}
}
}
/**
* 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.2/androidplot-core/src/main/java/com/androidplot/xy/XYLegendWidget.java 0000664 0000000 0000000 00000020344 12773640640 0031173 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.2/androidplot-core/src/main/java/com/androidplot/xy/XYPlot.java 0000664 0000000 0000000 00000121030 12773640640 0027541 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;
private RectRegion bounds = RectRegion.withDefaults(new RectRegion(-1, 1, -1, 1));
// 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 XYCoords calculatedOrigin = new XYCoords();
@SuppressWarnings("FieldCanBeLocal")
private Number domainOriginExtent = null;
@SuppressWarnings("FieldCanBeLocal")
private Number rangeOriginExtent = null;
private ArrayList yValueMarkers;
private ArrayList xValueMarkers;
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<>();
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 = bounds.isMinXSet() ? bounds.getMinX() : null;
prevMaxX = bounds.isMaxXSet() ? bounds.getMaxX() : null;
prevMinY = bounds.isMinYSet() ? bounds.getMinY() : null;
prevMaxY = bounds.isMaxYSet() ? bounds.getMaxY() : null;
bounds.setMinX(constraints.getMinX());
bounds.setMaxX(constraints.getMaxX());
bounds.setMinY(constraints.getMinY());
bounds.setMaxY(constraints.getMaxY());
// only calculate if we must:
if(!bounds.isFullyDefined()) {
RectRegion b = SeriesUtils.minMax(constraints, getSeriesRegistry().getSeriesList());
if(!bounds.isMinXSet()) {
bounds.setMinX(b.getMinX());
}
if(!bounds.isMaxXSet()) {
bounds.setMaxX(b.getMaxX());
}
if(!bounds.isMinYSet()) {
bounds.setMinY(b.getMinY());
}
if(!bounds.isMaxYSet()) {
bounds.setMaxY(b.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:
bounds.setMaxX(applyUserMinMax(getCalculatedUpperBoundary(
constraints.getDomainUpperBoundaryMode(), prevMaxX, bounds.getMaxX()),
domainRightMin, domainRightMax));
bounds.setMinX(applyUserMinMax(getCalculatedLowerBoundary(
constraints.getDomainLowerBoundaryMode(),
prevMinX, bounds.getMinX()),
domainLeftMin, domainLeftMax));
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) {
bounds.setMaxY(applyUserMinMax(getCalculatedUpperBoundary(
constraints.getRangeUpperBoundaryMode(),
prevMaxY, bounds.getMaxY()), rangeTopMin, rangeTopMax));
bounds.setMinY(applyUserMinMax(getCalculatedLowerBoundary(
constraints.getRangeLowerBoundaryMode(),
prevMinY, bounds.getMinY()), rangeBottomMin, rangeBottomMax));
}
break;
default:
throw new UnsupportedOperationException(
"Range Framing Model not yet supported: " + constraints.getRangeFramingModel());
}
calculatedOrigin.x = userDomainOrigin != null ?
userDomainOrigin : bounds.getMinX();
calculatedOrigin.y = this.userRangeOrigin != null ?
userRangeOrigin : bounds.getMinY();
}
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(bounds.getMaxX().doubleValue(), origin);
double minXDelta = distance(bounds.getMinX().doubleValue(), origin);
double delta = maxXDelta > minXDelta ? maxXDelta : minXDelta;
double dlb = origin - delta;
double dub = origin + delta;
switch (domainOriginBoundaryMode) {
case AUTO:
bounds.setMinX(dlb);
bounds.setMaxX(dub);
break;
// if fixed, then the value already exists within "user" vals.
case FIXED:
break;
case GROW: {
if (prevMinX == null || dlb < prevMinX.doubleValue()) {
bounds.setMinX(dlb);
} else {
bounds.setMinX(prevMinX);
}
if (prevMaxX == null || dub > prevMaxX.doubleValue()) {
bounds.setMaxX(dub);
} else {
bounds.setMaxX(prevMaxX);
}
}
break;
case SHRINK:
if (prevMinX == null || dlb > prevMinX.doubleValue()) {
bounds.setMinX(dlb);
} else {
bounds.setMinX(prevMinX);
}
if (prevMaxX == null || dub < prevMaxX.doubleValue()) {
bounds.setMaxX(dub);
} else {
bounds.setMaxX(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(bounds.getMaxY().doubleValue(), origin);
double minYDelta = distance(bounds.getMinY().doubleValue(), origin);
if (maxYDelta > minYDelta) {
bounds.setMinY(origin - maxYDelta);
bounds.setMaxY(origin + maxYDelta);
} else {
bounds.setMinY(origin - minYDelta);
bounds.setMaxY(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 XYCoords getOrigin() {
return calculatedOrigin;
}
public Number getDomainOrigin() {
return calculatedOrigin.x;
}
public Number getRangeOrigin() {
return calculatedOrigin.y;
}
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);
}
/**
*
* @return The current min/max values for real domain and range that fall within the visible
* graph space.
*/
public RectRegion getBounds() {
return bounds;
}
/**
* 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.2/androidplot-core/src/main/java/com/androidplot/xy/XYRegionFormatter.java 0000664 0000000 0000000 00000003574 12773640640 0031746 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.halfhp.fig.*;
/**
* 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)) {
Fig.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.2/androidplot-core/src/main/java/com/androidplot/xy/XYSeries.java 0000664 0000000 0000000 00000002562 12773640640 0030065 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.2/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesFormatter.java 0000664 0000000 0000000 00000005400 12773640640 0031743 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.*;
import com.androidplot.ui.Formatter;
import com.androidplot.util.LayerHash;
import com.androidplot.util.Layerable;
public abstract class XYSeriesFormatter extends Formatter {
// instantiate a default implementation prints point's yVal:
private PointLabeler pointLabeler = new PointLabeler() {
@Override
public String getLabel(XYSeries series, int index) {
return series.getY(index) + "";
}
};
private PointLabelFormatter pointLabelFormatter;
LayerHash regions;
{
regions = new LayerHash<>();
}
public XYSeriesFormatter() {}
public XYSeriesFormatter(Context context, int xmlCfgId) {
super(context, xmlCfgId);
}
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);
}
public PointLabeler getPointLabeler() {
return pointLabeler;
}
public void setPointLabeler(PointLabeler pointLabeler) {
this.pointLabeler = pointLabeler;
}
public boolean hasPointLabelFormatter() {
return pointLabelFormatter != null;
}
public PointLabelFormatter getPointLabelFormatter() {
if(pointLabelFormatter == null) {
pointLabelFormatter = new PointLabelFormatter();
}
return pointLabelFormatter;
}
public void setPointLabelFormatter(PointLabelFormatter pointLabelFormatter) {
this.pointLabelFormatter = pointLabelFormatter;
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesRenderer.java 0000664 0000000 0000000 00000003623 12773640640 0031553 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.2/androidplot-core/src/main/java/com/androidplot/xy/XYStepCalculator.java 0000664 0000000 0000000 00000005471 12773640640 0031562 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.*;
/**
* 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 pixRect
* @return
*/
public static Step getStep(XYPlot plot, Axis axisType, RectF pixRect) {
Step step = null;
switch(axisType) {
case DOMAIN:
step = getStep(plot.getDomainStepMode(),
plot.getDomainStepValue(),
plot.getBounds().getxRegion(),
new Region(pixRect.left, pixRect.right));
break;
case RANGE:
step = getStep(plot.getRangeStepMode(),
plot.getRangeStepValue(),
plot.getBounds().getyRegion(),
new Region(pixRect.top, pixRect.bottom));
break;
}
return step;
}
public static Step getStep(StepMode typeXY, double stepValue, Region realBounds, Region pixelBounds) {
double stepVal = 0;
double stepPix = 0;
double stepCount = 0;
switch(typeXY) {
case INCREMENT_BY_VAL:
stepVal = stepValue;
stepPix = stepValue / realBounds.ratio(pixelBounds).doubleValue();
stepCount = pixelBounds.length().doubleValue() / stepPix;
break;
case INCREMENT_BY_PIXELS:
stepPix = stepValue;
stepVal = realBounds.ratio(pixelBounds).doubleValue() * stepPix;
stepCount = pixelBounds.length().doubleValue() / stepPix;
break;
case SUBDIVIDE:
stepCount = stepValue;
stepPix = pixelBounds.length().doubleValue() / (stepCount - 1);
stepVal = realBounds.ratio(pixelBounds).doubleValue() * stepPix;
break;
}
return new Step(stepCount, stepPix, stepVal);
}
}
androidplot-1.2.2/androidplot-core/src/main/java/com/androidplot/xy/YValueMarker.java 0000664 0000000 0000000 00000003623 12773640640 0030720 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.2/androidplot-core/src/main/java/com/androidplot/xy/package-info.java 0000664 0000000 0000000 00000000176 12773640640 0030675 0 ustar 00root root 0000000 0000000 /**
* Classes involved in the creation and presentation of {@link com.androidplot.xy.XYPlot}.
*/
package com.androidplot.xy; androidplot-1.2.2/androidplot-core/src/main/res/ 0000775 0000000 0000000 00000000000 12773640640 0021615 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/main/res/values/ 0000775 0000000 0000000 00000000000 12773640640 0023114 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/main/res/values/attrs.xml 0000664 0000000 0000000 00000043435 12773640640 0025004 0 ustar 00root root 0000000 0000000
androidplot-1.2.2/androidplot-core/src/main/res/values/color.xml 0000664 0000000 0000000 00000001742 12773640640 0024760 0 ustar 00root root 0000000 0000000
#00000000
#000
#111
#FFF
#EEE
#888
androidplot-1.2.2/androidplot-core/src/main/res/values/style.xml 0000664 0000000 0000000 00000015436 12773640640 0025007 0 ustar 00root root 0000000 0000000
androidplot-1.2.2/androidplot-core/src/test/ 0000775 0000000 0000000 00000000000 12773640640 0021057 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/test/java/ 0000775 0000000 0000000 00000000000 12773640640 0022000 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/test/java/com/ 0000775 0000000 0000000 00000000000 12773640640 0022556 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/ 0000775 0000000 0000000 00000000000 12773640640 0025075 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/PlotTest.java 0000664 0000000 0000000 00000027534 12773640640 0027531 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.SeriesRenderer;
import com.androidplot.ui.Formatter;
import com.halfhp.fig.*;
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);
Fig.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.2/androidplot-core/src/test/java/com/androidplot/RegionTest.java 0000664 0000000 0000000 00000007017 12773640640 0030030 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static junit.framework.Assert.fail;
import static org.junit.Assert.assertEquals;
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 testConstructor() throws Exception {
Region lr = new Region(0d, 0d);
assertEquals(0d, lr.getMin());
assertEquals(0d, lr.getMax());
lr = new Region(1.5d, -2d);
assertEquals(-2d, lr.getMin());
assertEquals(1.5d, lr.getMax());
lr = new Region(10d, 20d);
assertEquals(10d, lr.getMin());
assertEquals(20d, lr.getMax());
}
@Test
public void testContains() throws Exception {
}
@Test
public void testIntersects() throws Exception {
Region line1 = new Region(1, 10);
Region line2 = new Region(11, 20);
assertFalse(line1.intersects(line2));
line1.setMax(15);
assertTrue(line1.intersects(line2));
//l1end = 30;
line1.setMax(30);
assertTrue(line1.intersects(line2));
//l1start = 21;
line1.setMin(21);
assertFalse(line1.intersects(line2));
}
@Test
public void testLength() throws Exception {
Region lr = new Region(0, 10);
assertEquals(10d, lr.length().doubleValue(), 0);
lr = new Region(-5, 5);
assertEquals(10d, lr.length().doubleValue(), 0);
}
@Test
public void testCenter() throws Exception {
Region r1 = new Region(1, 2);
assertEquals(1.5, r1.center());
Region r2 = new Region(-10, 10);
assertEquals(0.0, r2.center());
Region r3 = new Region(-2, -1);
assertEquals(-1.5, r3.center());
}
@Test
public void testTransform() throws Exception {
Region r1 = new Region(1, 2);
Region r2 = new Region(0, 10);
assertEquals(5.0, r1.transform(1.5, r2));
assertEquals(0.0, r1.transform(1, r2));
assertEquals(10.0, r1.transform(2, r2));
Region r3 = new Region(-10, 10);
assertEquals(-10.0, r1.transform(1, r3));
}
@Test
public void testTransformWithFlip() throws Exception {
Region r1 = new Region(1, 2);
Region r2 = new Region(0, 10);
assertEquals(5.0, r1.transform(1.5, r2, true));
assertEquals(10.0, r1.transform(1, r2, true));
assertEquals(0.0, r1.transform(2, r2, true));
Region r3 = new Region(-10, 10);
assertEquals(10.0, r1.transform(1, r3, true));
}
@Test
public void testRatio() throws Exception {
Region r1 = new Region(1, 2);
Region r2 = new Region(0, 100);
assertEquals(0.01, r1.ratio(r2));
assertEquals(100.0, r2.ratio(r1));
}
}
androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/pie/ 0000775 0000000 0000000 00000000000 12773640640 0025652 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/pie/TestPieRenderer.java 0000664 0000000 0000000 00000005253 12773640640 0031566 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.pie;
import android.content.res.*;
import android.graphics.*;
import android.view.*;
import com.androidplot.*;
import com.androidplot.test.*;
import com.androidplot.ui.*;
import org.junit.*;
import org.mockito.*;
import static org.mockito.Mockito.*;
public class TestPieRenderer extends AndroidplotTest {
@Mock
LayoutManager layoutManager;
@Mock
PieChart pieChart;
@Mock
TypedArray typedArray;
@Mock
SeriesRegistry seriesRegistry;
@Before
public void setUp() throws Exception {
//when(xyPlot.getSeriesRegistry()).thenReturn(seriesRegistry);
}
@After
public void tearDown() throws Exception {
}
@Test
public void testDrawSegment_withoutTextPaintDoesntDrawLabel() throws Exception {
PieRenderer pieRenderer = spy(new PieRenderer(pieChart));
Segment segment = spy(new Segment("My Segment", 100));
Canvas canvas = new Canvas();
SegmentFormatter formatterWithoutTextPaint = new SegmentFormatter(Color.GREEN);
formatterWithoutTextPaint.setLabelPaint(null);
pieRenderer.drawSegment(
new Canvas(),
new RectF(0, 0, 100, 100),
segment,
formatterWithoutTextPaint,
100, 100, 100);
SegmentFormatter formatterWithTextPaint = new SegmentFormatter(Color.GREEN);
pieRenderer.drawSegment(
canvas,
new RectF(0, 0, 100, 100),
segment,
formatterWithTextPaint,
100, 100, 100);
verify(pieRenderer, times(0))
.drawSegmentLabel(
any(Canvas.class),
any(PointF.class),
any(Segment.class),
eq(formatterWithoutTextPaint));
verify(pieRenderer, times(1))
.drawSegmentLabel(
eq(canvas),
any(PointF.class),
eq(segment),
eq(formatterWithTextPaint));
}
}
androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/test/ 0000775 0000000 0000000 00000000000 12773640640 0026054 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/test/AndroidplotTest.java 0000664 0000000 0000000 00000003131 12773640640 0032034 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 com.androidplot.util.*;
import org.junit.*;
import org.junit.runner.RunWith;
import org.mockito.junit.*;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.*;
/**
* Base class for all Androidplot tests that make use of Android platform classes.
*/
@RunWith(MyTestRunner.class)
@Config(manifest=Config.NONE)
public abstract class AndroidplotTest {
/**
* Enable mockito without requiring usage of {@link org.mockito.runners.MockitoJUnitRunner}.
* See: http://site.mockito.org/mockito/docs/current/org/mockito/junit/MockitoRule.html
*/
@Rule
public MockitoRule rule = MockitoJUnit.rule();
{
PixelUtils.init(getContext());
}
/**
* Convience method - to access the application context.
* @return
*/
protected Context getContext() {
return RuntimeEnvironment.application;
}
}
androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/test/MyTestRunner.java 0000664 0000000 0000000 00000000624 12773640640 0031340 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.2/androidplot-core/src/test/java/com/androidplot/ui/ 0000775 0000000 0000000 00000000000 12773640640 0025512 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/ui/DynamicTableModelTest.java 0000664 0000000 0000000 00000017753 12773640640 0032547 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.2/androidplot-core/src/test/java/com/androidplot/ui/FixedTableModelTest.java 0000664 0000000 0000000 00000020016 12773640640 0032204 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.2/androidplot-core/src/test/java/com/androidplot/util/ 0000775 0000000 0000000 00000000000 12773640640 0026052 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/util/LayerHashTest.java 0000664 0000000 0000000 00000006573 12773640640 0031450 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.*;
import static junit.framework.Assert.assertEquals;
public class LayerHashTest {
Object obj1 = new Object();
Object obj2 = new Object();
Object obj3 = new Object();
LayerHash layerHash;
@Before
public void setUp() throws Exception {
layerHash = new LayerHash<>();
layerHash.addToBottom(obj1, obj1);
layerHash.addToBottom(obj2, obj2);
layerHash.addToBottom(obj3, obj3);
assertEquals(obj3, layerHash.getKeysAsList().get(0));
assertEquals(obj2, layerHash.getKeysAsList().get(1));
assertEquals(obj1, layerHash.getKeysAsList().get(2));
}
// "top" == last element in the list:
@Test
public void testMoveUp() throws Exception {
layerHash.moveUp(obj3);
assertEquals(obj2, layerHash.getKeysAsList().get(0));
assertEquals(obj3, layerHash.getKeysAsList().get(1));
assertEquals(obj1, layerHash.getKeysAsList().get(2));
layerHash.moveUp(obj3);
assertEquals(obj2, layerHash.getKeysAsList().get(0));
assertEquals(obj1, layerHash.getKeysAsList().get(1));
assertEquals(obj3, layerHash.getKeysAsList().get(2));
layerHash.moveUp(obj3);
assertEquals(obj2, layerHash.getKeysAsList().get(0));
assertEquals(obj1, layerHash.getKeysAsList().get(1));
assertEquals(obj3, layerHash.getKeysAsList().get(2));
}
// "bottom" == first element in the list:
@Test
public void testMoveDown() throws Exception {
layerHash.moveDown(obj1);
assertEquals(obj3, layerHash.getKeysAsList().get(0));
assertEquals(obj1, layerHash.getKeysAsList().get(1));
assertEquals(obj2, layerHash.getKeysAsList().get(2));
layerHash.moveDown(obj1);
assertEquals(obj1, layerHash.getKeysAsList().get(0));
assertEquals(obj3, layerHash.getKeysAsList().get(1));
assertEquals(obj2, layerHash.getKeysAsList().get(2));
layerHash.moveDown(obj1);
assertEquals(obj1, layerHash.getKeysAsList().get(0));
assertEquals(obj3, layerHash.getKeysAsList().get(1));
assertEquals(obj2, layerHash.getKeysAsList().get(2));
}
@Test
public void testMoveAbove() throws Exception {
layerHash.moveAbove(obj2, obj1);
assertEquals(obj3, layerHash.getKeysAsList().get(0));
assertEquals(obj1, layerHash.getKeysAsList().get(1));
assertEquals(obj2, layerHash.getKeysAsList().get(2));
}
@Test
public void testMoveBeneath() throws Exception {
layerHash.moveBeneath(obj1, obj2);
assertEquals(obj3, layerHash.getKeysAsList().get(0));
assertEquals(obj1, layerHash.getKeysAsList().get(1));
assertEquals(obj2, layerHash.getKeysAsList().get(2));
}
}
LinkedLayerListOrganizerTest.java 0000664 0000000 0000000 00000004002 12773640640 0034412 0 ustar 00root root 0000000 0000000 androidplot-1.2.2/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.2/androidplot-core/src/test/java/com/androidplot/util/PixelUtilsTest.java 0000664 0000000 0000000 00000002325 12773640640 0031661 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.2/androidplot-core/src/test/java/com/androidplot/util/SeriesUtilsTest.java 0000664 0000000 0000000 00000011412 12773640640 0032027 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.*;
import com.androidplot.xy.*;
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);
RectRegion 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() {
Region 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.2/androidplot-core/src/test/java/com/androidplot/xy/ 0000775 0000000 0000000 00000000000 12773640640 0025535 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/xy/CandlestickSeriesTest.java 0000664 0000000 0000000 00000004156 12773640640 0032645 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 12773640640 0034016 0 ustar 00root root 0000000 0000000 androidplot-1.2.2/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.2/androidplot-core/src/test/java/com/androidplot/xy/LineAndPointRendererTest.java 0000664 0000000 0000000 00000010317 12773640640 0033255 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.*;
import org.junit.*;
import org.junit.runner.*;
import org.mockito.*;
import java.util.*;
import static junit.framework.Assert.assertEquals;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.*;
public class LineAndPointRendererTest extends AndroidplotTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
/**
* Sanity check to make sure that at the end of the day, points are being drawn at the expected
* screen-coords.
* @throws Exception
*/
@Test
public void testRenderPoints() throws Exception {
// 100x100 plot space:
RectF plotArea = new RectF(0, 0, 99, 99);
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, 3, 4, 5, 6, 7, 8, 9, 10);
LineAndPointRenderer renderer = Mockito.spy(new LineAndPointRenderer(plot));
plot.addSeries(series, formatter);
Canvas canvas = new Canvas();
plot.calculateMinMaxVals();
renderer.onRender(canvas, plotArea, series, formatter, null);
PointF[] expectedPoints = new PointF[] {
new PointF(0, 99),
new PointF(11, 88),
new PointF(22, 77),
new PointF(33, 66),
new PointF(44, 55),
new PointF(55, 44),
new PointF(66, 33),
new PointF(77, 22),
new PointF(88, 11),
new PointF(99, 0)
};
ArgumentCaptor capturedPoints= ArgumentCaptor.forClass(List.class);
verify(renderer, times(1)).renderPoints(
eq(canvas),
eq(plotArea),
eq(series),
capturedPoints.capture(),
eq(formatter));
List pList = capturedPoints.getValue();
// {0, 1}
assertEquals(expectedPoints[0].x, pList.get(0).x);
assertEquals(expectedPoints[0].y, pList.get(0).y);
// {1, 2}
assertEquals(expectedPoints[1].x, pList.get(1).x);
assertEquals(expectedPoints[1].y, pList.get(1).y);
// {2, 3}
assertEquals(expectedPoints[2].x, pList.get(2).x);
assertEquals(expectedPoints[2].y, pList.get(2).y);
// {3, 4}
assertEquals(expectedPoints[3].x, pList.get(3).x);
assertEquals(expectedPoints[3].y, pList.get(3).y);
// {4, 5}
assertEquals(expectedPoints[4].x, pList.get(4).x);
assertEquals(expectedPoints[4].y, pList.get(4).y);
// {5, 6}
assertEquals(expectedPoints[5].x, pList.get(5).x);
assertEquals(expectedPoints[5].y, pList.get(5).y);
// {6, 7}
assertEquals(expectedPoints[6].x, pList.get(6).x);
assertEquals(expectedPoints[6].y, pList.get(6).y);
// {7, 8}
assertEquals(expectedPoints[7].x, pList.get(7).x);
assertEquals(expectedPoints[7].y, pList.get(7).y);
// {8, 9}
assertEquals(expectedPoints[8].x, pList.get(8).x);
assertEquals(expectedPoints[8].y, pList.get(8).y);
// {9, 10}
assertEquals(expectedPoints[9].x, pList.get(9).x);
assertEquals(expectedPoints[9].y, pList.get(9).y);
}
}
androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/xy/PanZoomTest.java 0000664 0000000 0000000 00000005105 12773640640 0030624 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 android.view.*;
import com.androidplot.*;
import com.androidplot.test.*;
import com.androidplot.ui.*;
import org.junit.*;
import org.mockito.*;
import static org.mockito.Mockito.*;
public class PanZoomTest extends AndroidplotTest {
@Mock
LayoutManager layoutManager;
@Mock
XYPlot xyPlot;
@Mock
TypedArray typedArray;
@Mock
SeriesRegistry seriesRegistry;
@Before
public void setUp() throws Exception {
when(xyPlot.getSeriesRegistry()).thenReturn(seriesRegistry);
}
@After
public void tearDown() throws Exception {
}
@Test
public void testOnTouch_notifiesOnTouchListener() throws Exception {
PanZoom panZoom = new PanZoom(xyPlot, PanZoom.Pan.BOTH, PanZoom.Zoom.SCALE);
View.OnTouchListener listener = mock(View.OnTouchListener.class);
panZoom.setDelegate(listener);
MotionEvent motionEvent = mock(MotionEvent.class);
panZoom.onTouch(xyPlot, motionEvent);
verify(listener, times(1)).onTouch(xyPlot, motionEvent);
}
@Test
public void testOnTouch_oneFingerMovePansButDoesNotZoom() throws Exception {
PanZoom panZoom = spy(new PanZoom(xyPlot, PanZoom.Pan.BOTH, PanZoom.Zoom.SCALE));
View.OnTouchListener listener = mock(View.OnTouchListener.class);
panZoom.setDelegate(listener);
MotionEvent moveEvent = mock(MotionEvent.class);
doNothing().when(panZoom).calculatePan(
any(PointF.class), any(PointF.class), anyBoolean());
when(moveEvent.getAction())
.thenReturn(MotionEvent.ACTION_DOWN)
.thenReturn(MotionEvent.ACTION_MOVE);
panZoom.onTouch(xyPlot, moveEvent); // fires ACTION_DOWN
panZoom.onTouch(xyPlot, moveEvent); // fires ACTION_MOVE
verify(panZoom, times(1)).pan(moveEvent);
verify(panZoom, times(0)).zoom(moveEvent);
}
}
androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/xy/RectRegionTest.java 0000664 0000000 0000000 00000007113 12773640640 0031303 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 org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static junit.framework.Assert.assertEquals;
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));
}
@Test
public void testTransform() throws Exception {
RectRegion r1 = new RectRegion(1, 2, 0, 10);
RectRegion r2 = new RectRegion(2, 4, 10, 20);
final XYCoords trans1 = r1.transform(new XYCoords(1.5, 5), r2);
assertEquals(3.0, trans1.x);
assertEquals(15.0, trans1.y);
// try a screen transform:
RectF screen = new RectF(0, 0, 100, 100);
PointF result = r1.transform(2, 10, screen, false, true);
assertEquals(100f, result.x);
assertEquals(0f, result.y);
// now transform back to real:
RectRegion screenRegion = new RectRegion(screen);
XYCoords result2 = screenRegion.transform(result.x, result.y, r1, false, true);
assertEquals(2d, result2.x);
assertEquals(10d, result2.y);
}
@Test
public void testIntersects() throws Exception {
RectRegion r1 = new RectRegion(0, 10, 0, 10);
RectRegion r2 = new RectRegion(5, 15, 5, 15);
RectRegion r3 = new RectRegion(11, 21, 11, 21);
assertTrue(r1.intersects(r2));
assertTrue(r2.intersects(r1));
assertFalse(r1.intersects(r3));
assertFalse(r3.intersects(r1));
assertTrue(r2.intersects(r3));
assertTrue(r3.intersects(r2));
}
}
androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/xy/SimpleXYSeriesTest.java 0000664 0000000 0000000 00000010574 12773640640 0032134 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.2/androidplot-core/src/test/java/com/androidplot/xy/StepCalculatorTest.java 0000664 0000000 0000000 00000004546 12773640640 0032176 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.*;
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;
Region pixBounds = new Region(0, 100);
Region realBounds = new Region(0, 100);
Step step = XYStepCalculator.getStep(StepMode.SUBDIVIDE,numSegments, realBounds, pixBounds);
assertEquals(pixBounds.length().doubleValue()/(numSegments-1), step.getStepPix());
// make sure large values dont break anything:
realBounds.setMin(1000000000);
realBounds.setMax(2000000000);
step = XYStepCalculator.getStep(StepMode.SUBDIVIDE,
numSegments, realBounds, pixBounds);
assertEquals(pixBounds.length().doubleValue()/(numSegments-1), step.getStepPix());
}
@Test
public void testIncrementByVal() throws Exception {
Region pixBounds = new Region(50, 150);
Region realBounds = new Region(100, 200);
Step step = XYStepCalculator.getStep(StepMode.INCREMENT_BY_VAL, 1, realBounds, pixBounds);
assertEquals(1.0, step.getStepPix());
}
@Test
public void testIncrementByPixels() throws Exception {
Region pixBounds = new Region(50, 150);
Region realBounds = new Region(100, 200);
Step step = XYStepCalculator.getStep(StepMode.INCREMENT_BY_PIXELS, 1, realBounds, pixBounds);
assertEquals(1.0, step.getStepPix());
}
}
androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/xy/XYGraphWidgetTest.java 0000664 0000000 0000000 00000010246 12773640640 0031731 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.test.*;
import com.androidplot.ui.*;
import org.junit.*;
import org.mockito.*;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyDouble;
import static org.mockito.Matchers.anyFloat;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class XYGraphWidgetTest extends AndroidplotTest {
@Mock
LayoutManager layoutManager;
XYPlot xyPlot;
@Mock
TypedArray typedArray;
@Mock
SeriesRegistry seriesRegistry;
RectRegion bounds = new RectRegion(0, 100, 0, 100);
@Mock
Canvas canvas;
@Before
public void setUp() throws Exception {
xyPlot = spy(new XYPlot(getContext(), "XYPlot"));
when(xyPlot.getSeriesRegistry()).thenReturn(seriesRegistry);
when(xyPlot.getBounds()).thenReturn(bounds);
when(xyPlot.getDomainOrigin()).thenReturn(0);
when(xyPlot.getRangeOrigin()).thenReturn(0);
xyPlot.setDomainStep(StepMode.INCREMENT_BY_VAL, 1);
xyPlot.setRangeStep(StepMode.INCREMENT_BY_VAL, 1);
}
@After
public void tearDown() throws Exception {
}
@Test
public void testProcessAttrs() throws Exception {
Size size = new Size(100, SizeMode.ABSOLUTE, 100, SizeMode.ABSOLUTE);
XYGraphWidget graphWidget = spy(new XYGraphWidget(layoutManager, xyPlot, size));
graphWidget.processAttrs(typedArray);
verify(graphWidget, times(1)).setGridClippingEnabled(false);
}
@Test
public void testDrawMarkers() throws Exception {
Size size = new Size(100, SizeMode.ABSOLUTE, 100, SizeMode.ABSOLUTE);
XYGraphWidget graphWidget = spy(new XYGraphWidget(layoutManager, xyPlot, size));
graphWidget.setGridRect(new RectF(0, 0, 100, 100));
xyPlot.addMarker(new XValueMarker(1, "x"));
xyPlot.addMarker(new YValueMarker(-1, "y"));
graphWidget.drawMarkers(canvas);
// TODO: verifications
verify(canvas, times(2))
.drawLine(anyFloat(), anyFloat(), anyFloat(), anyFloat(), any(Paint.class));
}
@Test
public void testDrawGrid() throws Exception {
Size size = new Size(100, SizeMode.ABSOLUTE, 100, SizeMode.ABSOLUTE);
XYGraphWidget graphWidget = spy(new XYGraphWidget(layoutManager, xyPlot, size));
graphWidget.setLabelRect(new RectF(0, 0, 100, 100));
doNothing().when(graphWidget).
drawDomainLine(any(Canvas.class), anyFloat(), any(Number.class), any(Paint.class), anyBoolean());
doNothing().when(graphWidget).
drawRangeLine(any(Canvas.class), anyFloat(), any(Number.class), any(Paint.class), anyBoolean());
graphWidget.setGridRect(new RectF(0, 0, 100, 100));
xyPlot.setRangeBoundaries(0, 100, BoundaryMode.FIXED);
xyPlot.setDomainBoundaries(0, 100, BoundaryMode.FIXED);
graphWidget.drawGrid(canvas);
// expecting a 100x100 grid to be drawn:
verify(graphWidget, times(100))
.drawDomainLine(eq(canvas), anyFloat(), anyFloat(), any(Paint.class), eq(false));
verify(graphWidget, times(100))
.drawRangeLine(eq(canvas), anyFloat(), anyFloat(), any(Paint.class), eq(false));
}
}
androidplot-1.2.2/androidplot-core/src/test/java/com/androidplot/xy/XYLegendWidgetTest.java 0000664 0000000 0000000 00000004677 12773640640 0032101 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.2/androidplot-core/src/test/java/com/androidplot/xy/XYPlotTest.java 0000664 0000000 0000000 00000036042 12773640640 0030444 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.halfhp.fig.*;
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.getBounds().getMinX());
assertEquals(7.0, plot.getBounds().getMaxX());
}
@Test
public void testOriginAutoMode() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.centerOnDomainOrigin(5);
plot.calculateMinMaxVals();
assertEquals(10.0, plot.getBounds().getMaxX()); // symmetry is @ 10, not 9
assertEquals(0.0, plot.getBounds().getMinX());
plot.centerOnRangeOrigin(50);
plot.calculateMinMaxVals();
assertEquals(100.0, plot.getBounds().getMaxY());
assertEquals(0.0, plot.getBounds().getMinY());
}
@Test
public void testOriginGrowMode() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.centerOnDomainOrigin(5, null, BoundaryMode.GROW);
plot.calculateMinMaxVals();
assertEquals(0.0, plot.getBounds().getMinX());
assertEquals(10.0, plot.getBounds().getMaxX());
// introduce a larger domain set. boundaries should change
series1.setModel(numList2, SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
assertEquals(-1.0, plot.getBounds().getMinX());
assertEquals(11.0, plot.getBounds().getMaxX());
// 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.getBounds().getMinX());
assertEquals(11.0, plot.getBounds().getMaxX());
}
@Test
public void testOriginShrinkMode() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.centerOnDomainOrigin(5, null, BoundaryMode.SHRINK);
plot.calculateMinMaxVals();
assertEquals(0.0, plot.getBounds().getMinX());
assertEquals(10.0, plot.getBounds().getMaxX());
// update with more extreme values...nothing should change in shrink mode:
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
assertEquals(0.0, plot.getBounds().getMinX());
assertEquals(10.0, plot.getBounds().getMaxX());
}
// 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.getBounds().getMinX());
assertEquals(9, plot.getBounds().getMaxX());
plot.setDomainBoundaries(2, BoundaryMode.FIXED, 8, BoundaryMode.FIXED);
plot.calculateMinMaxVals();
// fixed
assertEquals(2, plot.getBounds().getMinX());
assertEquals(8, plot.getBounds().getMaxX());
// back to auto
plot.setDomainBoundaries(2, BoundaryMode.AUTO, 8, BoundaryMode.AUTO);
plot.calculateMinMaxVals();
// check again
assertEquals(0, plot.getBounds().getMinX());
assertEquals(9, plot.getBounds().getMaxX());
// 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.getBounds().getMinX());
assertEquals(9, plot.getBounds().getMaxX());
// update with more extreme values...
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// after growing
assertEquals(0, plot.getBounds().getMinX());
assertEquals(11, plot.getBounds().getMaxX());
// back to previous
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// should not of changed.
assertEquals(0, plot.getBounds().getMinX());
assertEquals(11, plot.getBounds().getMaxX());
// 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.getBounds().getMinX());
assertEquals(11, plot.getBounds().getMaxX());
// now small
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// after shrinking
assertEquals(0, plot.getBounds().getMinX());
assertEquals(9, plot.getBounds().getMaxX());
// back to previous
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// should not of changed.
assertEquals(0, plot.getBounds().getMinX());
assertEquals(9, plot.getBounds().getMaxX());
// back to auto
plot.setDomainBoundaries(2, BoundaryMode.AUTO, 8, BoundaryMode.AUTO);
plot.calculateMinMaxVals();
// should of changed.
assertEquals(0, plot.getBounds().getMinX());
assertEquals(11, plot.getBounds().getMaxX());
}
@Test
public void testsetRangeBoundaries() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.calculateMinMaxVals();
// default to auto so check them
assertEquals(0, plot.getBounds().getMinY());
assertEquals(100, plot.getBounds().getMaxY());
plot.setRangeBoundaries(5, BoundaryMode.FIXED, 80, BoundaryMode.FIXED);
plot.calculateMinMaxVals();
// fixed
assertEquals(5, plot.getBounds().getMinY());
assertEquals(80, plot.getBounds().getMaxY());
// back to auto
plot.setRangeBoundaries(2, BoundaryMode.AUTO, 8, BoundaryMode.AUTO);
plot.calculateMinMaxVals();
// check again
assertEquals(0, plot.getBounds().getMinY());
assertEquals(100, plot.getBounds().getMaxY());
// try grow
plot.setRangeBoundaries(2, BoundaryMode.GROW, 8, BoundaryMode.GROW);
plot.calculateMinMaxVals();
// check inital
assertEquals(0, plot.getBounds().getMinY());
assertEquals(100, plot.getBounds().getMaxY());
// update with more extreme values...
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// after growing
assertEquals(-100, plot.getBounds().getMinY());
assertEquals(200, plot.getBounds().getMaxY());
// back to previous
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// should not of changed.
assertEquals(-100, plot.getBounds().getMinY());
assertEquals(200, plot.getBounds().getMaxY());
// 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.getBounds().getMinY());
assertEquals(200, plot.getBounds().getMaxY());
// now small
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// after shrinking
assertEquals(0, plot.getBounds().getMinY());
assertEquals(100, plot.getBounds().getMaxY());
// back to previous
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// should not of changed.
assertEquals(0, plot.getBounds().getMinY());
assertEquals(100, plot.getBounds().getMaxY());
// back to auto
plot.setRangeBoundaries(2, BoundaryMode.AUTO, 8, BoundaryMode.AUTO);
plot.calculateMinMaxVals();
// should of changed.
assertEquals(-100, plot.getBounds().getMinY());
assertEquals(200, plot.getBounds().getMaxY());
}
@Test
public void testSetDomainRightMinMax() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.calculateMinMaxVals();
// default to auto so check them
assertEquals(0, plot.getBounds().getMinX());
assertEquals(9, plot.getBounds().getMaxX());
plot.setDomainRightMax(10);
plot.calculateMinMaxVals();
// same values.
assertEquals(0, plot.getBounds().getMinX());
assertEquals(9, plot.getBounds().getMaxX());
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// on RightMax
assertEquals(0, plot.getBounds().getMinX());
assertEquals(10, plot.getBounds().getMaxX());
plot.setDomainRightMax(null);
plot.calculateMinMaxVals();
// back to full
assertEquals(0, plot.getBounds().getMinX());
assertEquals(11, plot.getBounds().getMaxX());
// now the RightMin
plot.setDomainRightMin(10);
plot.calculateMinMaxVals();
// still to full
assertEquals(0, plot.getBounds().getMinX());
assertEquals(11, plot.getBounds().getMaxX());
// small list
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// on RightMin
assertEquals(0, plot.getBounds().getMinX());
assertEquals(10, plot.getBounds().getMaxX());
// now off again
plot.setDomainRightMin(null);
plot.calculateMinMaxVals();
// small values.
assertEquals(0, plot.getBounds().getMinX());
assertEquals(9, plot.getBounds().getMaxX());
}
@Test
public void testSetRangeTopBottomMinMax() throws Exception {
plot.addSeries(series1, new LineAndPointFormatter());
plot.calculateMinMaxVals();
// default to auto so check them
assertEquals(0, plot.getBounds().getMinY());
assertEquals(100, plot.getBounds().getMaxY());
plot.setRangeTopMax(110);
plot.setRangeBottomMin(-50);
plot.calculateMinMaxVals();
// same values.
assertEquals(0, plot.getBounds().getMinY());
assertEquals(100, plot.getBounds().getMaxY());
series1.setModel(numList2,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// on Limits
assertEquals(-50, plot.getBounds().getMinY());
assertEquals(110, plot.getBounds().getMaxY());
plot.setRangeTopMax(null);
plot.setRangeBottomMin(null);
plot.calculateMinMaxVals();
// back to full
assertEquals(-100, plot.getBounds().getMinY());
assertEquals(200, plot.getBounds().getMaxY());
// now the Min
plot.setRangeTopMin(150);
plot.setRangeBottomMax(-60);
plot.calculateMinMaxVals();
// still to full
assertEquals(-100, plot.getBounds().getMinY());
assertEquals(200, plot.getBounds().getMaxY());
// small list
series1.setModel(numList1,SimpleXYSeries.ArrayFormat.Y_VALS_ONLY);
plot.calculateMinMaxVals();
// on Limits
assertEquals(-60, plot.getBounds().getMinY());
assertEquals(150, plot.getBounds().getMaxY());
// now off again
plot.setRangeTopMin(null);
plot.setRangeBottomMax(null);
plot.calculateMinMaxVals();
// small values.
assertEquals(0, plot.getBounds().getMinY());
assertEquals(100, plot.getBounds().getMaxY());
}
@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);
Fig.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.2/androidplot-core/src/test/java/com/androidplot/xy/XYSeriesRendererTest.java 0000664 0000000 0000000 00000004326 12773640640 0032447 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.*;
import com.androidplot.test.AndroidplotTest;
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);
Region xBounds = new Region(0, 9);
int x = 0;
double val = xBounds.transform(x, gridRect.left, gridRect.right, false);
assertEquals(val, (domainStep.getStepPix()*x) + gridRect.left);
x = 1;
val = xBounds.transform(x, gridRect.left, gridRect.right, false);
assertEquals(val, (domainStep.getStepPix()*x) + gridRect.left);
x = 9;
val = xBounds.transform(x, gridRect.left, gridRect.right, false);
assertEquals(val, (domainStep.getStepPix()*x) + gridRect.left);
}
}
androidplot-1.2.2/build.gradle 0000664 0000000 0000000 00000002703 12773640640 0016325 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'
allprojects {
repositories {
jcenter()
}
}
ext {
theBuildToolsVersion = '24.0.2'
theCompileSdkVersion = 24
theTargetSdkVersion = 24
theMinSdkVersion = 5
theVersionName = '1.2.2'
theVersionCode = 21
}
buildscript {
repositories {
mavenCentral()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.2.0'
classpath 'com.github.dcendents:android-maven-gradle-plugin:1.5'
classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.7'
classpath 'com.vanniktech:gradle-android-junit-jacoco-plugin:0.5.0'
classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.6.3'
}
}
allprojects {
repositories {
mavenCentral()
}
}
task wrapper(type: Wrapper) {
gradleVersion = '2.14.1'
} androidplot-1.2.2/circle.yml 0000664 0000000 0000000 00000003615 12773640640 0016035 0 ustar 00root root 0000000 0000000
machine:
environment:
KEYSTORE: ${HOME}/${CIRCLE_PROJECT_REPONAME}/sigining.keystore
PUBLISHER_ACCT_JSON_FILE: ${HOME}/${CIRCLE_PROJECT_REPONAME}/publisher_profile.json
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"
- bash ./misc/download_keystore.sh
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/ \;
# code coverage:
- ./gradlew jacocoTestReportDebug
- mkdir -p $CIRCLE_TEST_REPORTS/jacoco/
- cp -r ${HOME}/${CIRCLE_PROJECT_REPONAME}/androidplot-core/build/reports/jacoco/debug/. $CIRCLE_TEST_REPORTS/jacoco
- bash <(curl -s https://codecov.io/bash)
deployment:
master:
branch: master
commands:
- (./gradlew bintrayUpload):
timeout: 360
- bash ./misc/download_google_publisher_json.sh
- ./gradlew publishApkRelease
androidplot-1.2.2/demoapp-wearable/ 0000775 0000000 0000000 00000000000 12773640640 0017251 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/demoapp-wearable/.gitignore 0000664 0000000 0000000 00000000007 12773640640 0021236 0 ustar 00root root 0000000 0000000 /build
androidplot-1.2.2/demoapp-wearable/build.gradle 0000664 0000000 0000000 00000003163 12773640640 0021533 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.2/demoapp-wearable/proguard-rules.pro 0000664 0000000 0000000 00000001215 12773640640 0022745 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.2/demoapp-wearable/src/ 0000775 0000000 0000000 00000000000 12773640640 0020040 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/demoapp-wearable/src/main/ 0000775 0000000 0000000 00000000000 12773640640 0020764 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/demoapp-wearable/src/main/AndroidManifest.xml 0000664 0000000 0000000 00000002617 12773640640 0024563 0 ustar 00root root 0000000 0000000
**Features:**
* Line Charts
* Scatter Charts
* Bar Charts
* Pie Charts
* Step Charts
* Candlestick Charts
* Bubble Charts
* Dynamic plots
* Pan & Zoom
# Usage
* **[Quickstart](docs/quickstart.md)** :star:
* [Full Documentation](docs/index.md)
# Links
* [Website](http://androidplot.com)
* [Github Repo](https://github.com/halfhp/androidplot)
* [Bitbucket Repo](https://bitbucket.org/androidplot/androidplot)
* [Demo App (Google Play Store)](https://play.google.com/store/apps/details?id=com.androidplot.demos&hl=en)
* [Demo App Soure Code](https://bitbucket.org/androidplot/androidplot/src/1538c5dfa56aed0d2cfdcbc7cdc6173e605543cd/demoapp/?at=master)
* [Bugs](https://github.com/halfhp/androidplot/issues) :ant:
* [Contributing Source Code](http://androidplot.com/docs/working-with-androidplot-source/)
# Help
Technical questions should be posted using the [androidplot tag](http://stackoverflow.com/questions/tagged/androidplot) on Stack Overflow. For everything else use the [Google Groups forum](https://groups.google.com/d/forum/androidplot).
# License
Androidplot has been made available under the Apache 2.0 license:
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.
androidplot-1.2.2/androidplot-core/ 0000775 0000000 0000000 00000000000 12773640640 0017311 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/build.gradle 0000664 0000000 0000000 00000010201 12773640640 0021562 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.library'
apply plugin: 'com.github.dcendents.android-maven'
apply plugin: 'com.jfrog.bintray'
apply plugin: 'com.vanniktech.android.junit.jacoco'
apply plugin: 'com.github.kt3k.coveralls'
android {
compileSdkVersion theCompileSdkVersion
buildToolsVersion theBuildToolsVersion
defaultConfig {
versionCode theVersionCode
versionName theVersionName
minSdkVersion theMinSdkVersion
targetSdkVersion theTargetSdkVersion
testApplicationId "com.androidplot.test"
}
/**
* TODO: enable and address lint issues.
*/
lintOptions {
abortOnError false
}
}
group = 'com.androidplot'
version = theVersionName
def siteUrl = 'http://androidplot.com'
def gitUrl = 'https://github.com/halfhp/androidplot.git'
dependencies {
compile 'com.halfhp.fig:figlib:1.0.3'
testCompile "org.mockito:mockito-core:1.10.19"
testCompile group: 'junit', name: 'junit', version: '4.12'
testCompile "org.robolectric:robolectric:3.1"
// temp fix for:
// https://github.com/robolectric/robolectric/issues/1932
testCompile 'org.khronos:opengl-api:gl1.1-android-2.1_r1'
}
task javadoc(type: Javadoc) {
source = android.sourceSets.main.java.srcDirs
classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
failOnError false
options {
links "http://docs.oracle.com/javase/7/docs/api/"
linksOffline "http://d.android.com/reference","${android.sdkDirectory}/docs/reference"
}
exclude '**/BuildConfig.java'
exclude '**/R.java'
}
task javadocJar(type: Jar, dependsOn: javadoc) {
classifier = 'javadoc'
from javadoc.destinationDir
}
task sourcesJar(type: Jar) {
classifier = 'sources'
from android.sourceSets.main.java.srcDirs
}
install {
repositories.mavenInstaller {
pom {
project {
packaging 'aar'
name 'Androidplot Core Library'
description = "Androidplot is a library for creating dynamic and static charts within your Android application."
url siteUrl
licenses {
license {
name 'The Apache Software License, Version 2.0'
url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
}
}
developers {
developer {
id 'halfhp'
name 'Nick Fellows'
email 'halfhp@gmail.com'
}
}
scm {
connection gitUrl
developerConnection gitUrl
url siteUrl
}
}
}
}
}
bintray {
// these environment vars must be set when deploying to bintray.
// note: BINTRAY_PASSWORD is actually the api key, but naming it 'password'
// tells the CI environment to obfuscate the value in public logs.
user = System.getenv('BINTRAY_USER')
key = System.getenv('BINTRAY_PASSWORD')
configurations = ['archives']
pkg {
version {
name = theVersionName
}
repo = "androidplot"
name = "com.androidplot:androidplot-core"
issueTrackerUrl = "https://github.com/halfhp/androidplot/issues"
websiteUrl = siteUrl
vcsUrl = gitUrl
licenses = ["Apache-2.0"]
}
}
javadoc {
options.overview = "src/main/java/overview.html"
}
artifacts {
archives javadocJar
archives sourcesJar
}
androidplot-1.2.2/androidplot-core/src/ 0000775 0000000 0000000 00000000000 12773640640 0020100 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/main/ 0000775 0000000 0000000 00000000000 12773640640 0021024 5 ustar 00root root 0000000 0000000 androidplot-1.2.2/androidplot-core/src/main/AndroidManifest.xml 0000664 0000000 0000000 00000001565 12773640640 0024624 0 ustar 00root root 0000000 0000000