{
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.4.2/androidplot-core/src/main/java/com/androidplot/ui/Formatter.java 0000664 0000000 0000000 00000005430 13065526371 0030270 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 {
private boolean isLegendIconEnabled = true;
public Formatter() {}
public Formatter(Context ctx, int xmlCfgId) {
configure(ctx, xmlCfgId);
}
public void configure(Context ctx, int xmlCfgId) {
Fig.configure(ctx, this, xmlCfgId);
}
/**
*
* @param plot
* @param
* @return @return An instance of SeriesRenderer constructed with the specified plot.
*/
public T getRendererInstance(PlotType plot) {
return (T) doGetRendererInstance(plot);
}
/**
*
* @return The Class of SeriesRenderer that should be used when rendering series associated
* with instances of this formatter.
*/
public abstract Class getRendererClass();
/**
*
* @return An instance of SeriesRenderer constructed with the specified plot.
*/
protected abstract SeriesRenderer doGetRendererInstance(PlotType plot);
public boolean isLegendIconEnabled() {
return isLegendIconEnabled;
}
/**
* Sets whether or not a legend icon should be drawn for the series associated with this formatter.
* @param legendIconEnabled
*/
public void setLegendIconEnabled(boolean legendIconEnabled) {
this.isLegendIconEnabled = legendIconEnabled;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/ui/HorizontalPosition.java 0000664 0000000 0000000 00000005124 13065526371 0032203 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/HorizontalPositioning.java 0000664 0000000 0000000 00000001506 13065526371 0032701 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
public enum HorizontalPositioning {
ABSOLUTE_FROM_LEFT,
ABSOLUTE_FROM_RIGHT,
ABSOLUTE_FROM_CENTER,
RELATIVE_TO_LEFT,
RELATIVE_TO_RIGHT,
RELATIVE_TO_CENTER
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/ui/Insets.java 0000664 0000000 0000000 00000003025 13065526371 0027570 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/LayoutManager.java 0000664 0000000 0000000 00000020766 13065526371 0031106 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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()) {
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.4.2/androidplot-core/src/main/java/com/androidplot/ui/LayoutMetric.java 0000664 0000000 0000000 00000003721 13065526371 0030747 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/PositionMetric.java 0000664 0000000 0000000 00000005357 13065526371 0031305 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/PositionMetrics.java 0000664 0000000 0000000 00000004133 13065526371 0031457 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/RenderBundle.java 0000664 0000000 0000000 00000002747 13065526371 0030706 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/RenderStack.java 0000664 0000000 0000000 00000006467 13065526371 0030545 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 SeriesBundle seriesBundle;
private boolean isEnabled = true;
public StackElement(SeriesBundle seriesBundle) {
set(seriesBundle);
}
public SeriesBundle get() {
return seriesBundle;
}
public void set(SeriesBundle seriesBundle) {
this.seriesBundle = seriesBundle;
}
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.getRegistry().size());
}
/**
* Syncs the stack structure with plot's current state. Should be called before
* rendering series data to an XYGraphWidget.
*/
public void sync() {
getElements().clear();
List> pairList
= plot.getRegistry().getSeriesAndFormatterList();
for(SeriesBundle 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/Resizable.java 0000664 0000000 0000000 00000003025 13065526371 0030243 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/SeriesBundle.java 0000664 0000000 0000000 00000002622 13065526371 0030711 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 a relationship between a Series instance and other elements needed to unique render that instance
* such as a Formatter etc.
*/
public class SeriesBundle {
private final SeriesType series;
private final FormatterType formatter;
public SeriesBundle(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.4.2/androidplot-core/src/main/java/com/androidplot/ui/SeriesRenderer.java 0000664 0000000 0000000 00000010040 13065526371 0031237 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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, SeriesBundle 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 SeriesBundle} instances currently associated
* with this Renderer.
*/
public List> getSeriesAndFormatterList() {
List> results = new ArrayList<>();
List sfList = getPlot().getRegistry().getSeriesAndFormatterList();
for(SeriesBundle thisPair : sfList) {
if(thisPair.rendersWith(this)) {
results.add(thisPair);
}
}
return results;
}
/**
*
* @return
* @since 0.9.7
*/
public List getSeriesList() {
List results = new ArrayList<>();
List sfList = getPlot().getRegistry().getSeriesAndFormatterList();
for(SeriesBundle thisPair : sfList) {
if(thisPair.rendersWith(this)) {
results.add(thisPair.getSeries());
}
}
return results;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/ui/Size.java 0000664 0000000 0000000 00000005335 13065526371 0027243 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/SizeMetric.java 0000664 0000000 0000000 00000003774 13065526371 0030414 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/SizeMode.java 0000664 0000000 0000000 00000002533 13065526371 0030045 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/TableModel.java 0000664 0000000 0000000 00000002501 13065526371 0030331 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/TableOrder.java 0000664 0000000 0000000 00000001370 13065526371 0030347 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/TableSizingMethod.java 0000664 0000000 0000000 00000001742 13065526371 0031703 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/TextOrientation.java 0000664 0000000 0000000 00000001360 13065526371 0031463 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/VerticalPosition.java 0000664 0000000 0000000 00000005036 13065526371 0031625 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/VerticalPositioning.java 0000664 0000000 0000000 00000001503 13065526371 0032316 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/widget/ 0000775 0000000 0000000 00000000000 13065526371 0026743 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/ui/widget/EmptyWidget.java 0000664 0000000 0000000 00000002227 13065526371 0032053 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/widget/TextLabelWidget.java 0000664 0000000 0000000 00000013032 13065526371 0032635 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 run
// 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.4.2/androidplot-core/src/main/java/com/androidplot/ui/widget/Widget.java 0000664 0000000 0000000 00000035653 13065526371 0031045 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.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;
private Rotation rotation = Rotation.NONE;
public enum Rotation {
NINETY_DEGREES,
NEGATIVE_NINETY_DEGREES,
ONE_HUNDRED_EIGHTY_DEGREES,
NONE,
}
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 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);
}
canvas.save();
final RectF paddedRect = applyRotation(canvas, widgetDimensions.paddedRect);
doOnDraw(canvas, paddedRect);
canvas.restore();
if (borderPaint != null) {
drawBorder(canvas, paddedRect);
}
}
}
protected RectF applyRotation(Canvas canvas, RectF rect) {
float rotationDegs = 0;
final float cx = widgetDimensions.paddedRect.centerX();
final float cy = widgetDimensions.paddedRect.centerY();
final float halfHeight = widgetDimensions.paddedRect.height() / 2;
final float halfWidth = widgetDimensions.paddedRect.width() / 2;
switch (rotation) {
case NINETY_DEGREES:
rotationDegs = 90;
rect = new RectF(
cx - halfHeight,
cy - halfWidth,
cx + halfHeight,
cy + halfWidth);
break;
case NEGATIVE_NINETY_DEGREES:
rotationDegs = -90;
rect = new RectF(
cx - halfHeight,
cy - halfWidth,
cx + halfHeight,
cy + halfWidth);
break;
case ONE_HUNDRED_EIGHTY_DEGREES:
rotationDegs = 180;
// fall through
case NONE:
break;
default:
throw new UnsupportedOperationException("Not yet implemented.");
}
if(rotation != Rotation.NONE) {
canvas.rotate(rotationDegs, cx, cy);
}
return rect;
}
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;
}
public Rotation getRotation() {
return rotation;
}
public void setRotation(Rotation rotation) {
this.rotation = rotation;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/util/ 0000775 0000000 0000000 00000000000 13065526371 0026020 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/util/APTrace.java 0000664 0000000 0000000 00000001133 13065526371 0030140 0 ustar 00root root 0000000 0000000 package com.androidplot.util;
import android.os.*;
/**
* Wraps {@link Trace} to provide API-safe methods as well as an easy target for runtime removal
* via obfuscation.
*/
public abstract class APTrace {
public static void begin(final String sectionName) {
if(Build.VERSION.SDK_INT >= 18) {
Trace.beginSection(sectionName);
} else {
// TODO: alternate impl?
}
}
public static void end() {
if(Build.VERSION.SDK_INT >= 18) {
Trace.endSection();
} else {
// TODO: alternate impl?
}
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/util/AttrUtils.java 0000664 0000000 0000000 00000025677 13065526371 0030637 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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()));
}
}
public static void configureWidgetRotation(TypedArray attrs, Widget widget, int rotationAttr) {
if(attrs != null) {
widget.setRotation(getWidgetRotation(attrs, rotationAttr, Widget.Rotation.NONE));
}
}
/**
* 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 Widget.Rotation getWidgetRotation(TypedArray attrs, int attr, Widget.Rotation defaultValue) {
return Widget.Rotation.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.4.2/androidplot-core/src/main/java/com/androidplot/util/DisplayDimensions.java 0000664 0000000 0000000 00000002744 13065526371 0032330 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/util/FastNumber.java 0000664 0000000 0000000 00000003372 13065526371 0030736 0 ustar 00root root 0000000 0000000 package com.androidplot.util;
/**
* An extension of {@link Number} optimized for speed at the cost of memory.
*/
public class FastNumber extends Number {
private Number number;
private boolean hasDoublePrimitive;
private boolean hasFloatPrimitive;
private boolean hasIntPrimitive;
private double doublePrimitive;
private float floatPrimitive;
private int intPrimitive;
public FastNumber(Number number) {
// avoid nested instances of FastNumber :
if(number instanceof FastNumber) {
FastNumber rhs = (FastNumber) number;
this.number = rhs.number;
this.hasDoublePrimitive = rhs.hasDoublePrimitive;
this.hasFloatPrimitive = rhs.hasFloatPrimitive;
this.hasIntPrimitive = rhs.hasIntPrimitive;
this.doublePrimitive = rhs.doublePrimitive;
this.floatPrimitive = rhs.floatPrimitive;
this.intPrimitive = rhs.intPrimitive;
} else {
this.number = number;
}
}
@Override
public int intValue() {
if(!hasIntPrimitive) {
intPrimitive = number.intValue();
hasIntPrimitive = true;
}
return intPrimitive;
}
@Override
public long longValue() {
// TODO: optimize me!
return number.longValue();
}
@Override
public float floatValue() {
if(!hasFloatPrimitive) {
floatPrimitive = number.floatValue();
hasFloatPrimitive = true;
}
return floatPrimitive;
}
@Override
public double doubleValue() {
if(!hasDoublePrimitive) {
doublePrimitive = number.doubleValue();
hasDoublePrimitive = true;
}
return doublePrimitive;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/util/FontUtils.java 0000664 0000000 0000000 00000005155 13065526371 0030620 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/util/LayerHash.java 0000664 0000000 0000000 00000010365 13065526371 0030550 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/util/LayerListOrganizer.java 0000664 0000000 0000000 00000006447 13065526371 0032467 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/util/Layerable.java 0000664 0000000 0000000 00000004137 13065526371 0030570 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.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.4.2/androidplot-core/src/main/java/com/androidplot/util/LinkedLayerList.java 0000664 0000000 0000000 00000003664 13065526371 0031733 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/util/Mapping.java 0000664 0000000 0000000 00000002045 13065526371 0030257 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/util/PixelUtils.java 0000664 0000000 0000000 00000012110 13065526371 0030760 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 run 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.4.2/androidplot-core/src/main/java/com/androidplot/util/PlotStatistics.java 0000664 0000000 0000000 00000007362 13065526371 0031664 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.util;
import 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.4.2/androidplot-core/src/main/java/com/androidplot/util/RectFUtils.java 0000664 0000000 0000000 00000005367 13065526371 0030722 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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;
}
}
/**
* Generates a RectF from two height and two width values; the h and w values will
* be passed into the RectF constructor such that RectF.left <= RectF.right and
* RectF.top <= RectF.bottom.
* @param w1 width1
* @param h1 height1
* @param w2 width2
* @param h2 height2
* @return
*/
public static RectF createFromEdges(float w1, float h1, float w2, float h2) {
final boolean w1IsLeft = w1 <= w2;
final boolean h1IsTop = h1 <= h2;
return new RectF(
w1IsLeft ? w1 : w2,
h1IsTop ? h1 : h2,
w1IsLeft ? w2 : w1,
h1IsTop ? h2 : h1);
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/util/Redrawer.java 0000664 0000000 0000000 00000010204 13065526371 0030433 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.
*/
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.4.2/androidplot-core/src/main/java/com/androidplot/util/SeriesUtils.java 0000664 0000000 0000000 00000025247 13065526371 0031150 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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);
}
public static Region minMaxX(XYSeries... seriesList) {
final Region bounds = new Region();
for (XYSeries series : seriesList) {
for (int i = 0; i < series.size(); i++) {
bounds.union(series.getX(i));
}
}
return bounds;
}
public static Region minMaxY(XYSeries... seriesList) {
final Region bounds = new Region();
for (XYSeries series : seriesList) {
for (int i = 0; i < series.size(); i++) {
bounds.union(series.getY(i));
}
}
return bounds;
}
/**
* @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 this is an advanced xy series then minMax have already been calculated for us:
if(series instanceof FastXYSeries) {
final RectRegion b = ((FastXYSeries) series).minMax();
if(constraints == null) {
bounds.union(b);
} else {
if(constraints.contains(b.getMinX(), b.getMinY())) {
bounds.union(b.getMinX(), b.getMinY());
}
if(constraints.contains(b.getMaxX(), b.getMaxY())) {
bounds.union(b.getMaxX(), b.getMaxY());
}
}
} else 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)) {
bounds.union(xi, 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) {
bounds.union(i);
}
}
return bounds;
}
/**
* Compute the range of visible i-vals in the specified series. Assumes that x-vals are
* in strict ascending order; behavior is undefined otherwise.
* @param series
* @param visibleBounds The visible constraints of the plot
* @return
*/
public static Region iBounds(XYSeries series, RectRegion visibleBounds) {
final float step = series.size() >= 200 ? 50 : 1;
final int iBoundsMin = iBoundsMin(series, visibleBounds.getMinX().doubleValue(), step);
final int iBoundsMax = iBoundsMax(series, visibleBounds.getMaxX().doubleValue(), step);
return new Region(iBoundsMin, iBoundsMax);
}
/**
* TODO: This is a poor alternative to a true binary search implementation. Unfortunately writing
* TODO a binary search algorithm that also supports nulls is not trivial and would not likely
* TODO result in any noticeable performance increase here. It's a task for another day!
* @param series
* @param visibleMax
* @param step
* @return The index of the smallest non-null value that is greater than visibleMax, or the index
* of the last element if no such value exists.
*/
protected static int iBoundsMax(XYSeries series, double visibleMax, float step) {
int max = series.size() - 1;
final int seriesSize = series.size();
final int steps = (int) Math.ceil(seriesSize / step);
for (int stepIndex = steps; stepIndex >= 0; stepIndex--) {
final int i = stepIndex * (int) step;
for (int ii = 0; ii < step; ii++) {
final int iii = i + ii;
if(iii < seriesSize) {
final Number thisX = series.getX(iii);
if (thisX != null) {
final double thisDouble = thisX.doubleValue();
if (thisDouble > visibleMax) {
// this is the smallest non-null value in this block, so skip
// to the next block:
max = iii;
break;
} else if (thisDouble == visibleMax) {
return iii;
} else {
return max;
}
}
}
}
}
return max;
}
/**
* TODO: This is a poor alternative to a true binary search implementation. Unfortunately writing
* TODO a binary search algorithm that also supports nulls is not trivial and would not likely
* TODO result in any noticeable performance increase here. It's a task for another day!
* @param series
* @param visibleMin
* @param step
* @return The index of the largest non-null value that is less than visible, or 0
* (the first element index) if no such value exists.
*/
protected static int iBoundsMin(XYSeries series, double visibleMin, float step) {
int min = 0;
final int steps = (int) Math.ceil(series.size() / step);
for (int stepIndex = 1; stepIndex <= steps; stepIndex++) {
final int i = stepIndex * (int) step;
for (int ii = 1; ii <= step; ii++) {
final int iii = i - ii;
if(iii < 0) {
break;
}
if(iii < series.size()) {
final Number thisX = series.getX(iii);
if (thisX != null) {
if (thisX.doubleValue() < visibleMin) {
// this is the largest non-null value in this block, so skip
// to the next block:
min = iii;
break;
} else if (thisX.doubleValue() == visibleMin) {
return iii;
} else {
return min;
}
}
}
}
}
return min;
}
/**
* Determine the minMax iVals of the xVals surrounding a range of one or more null values.
* @param series
* @param index index of the null value in question
* @return The iVals of the non-null values surrounding the null range. If the null range is unbounded on
* either side then either or both min and max values will also be null.
*/
protected static Region getNullRegion(XYSeries series, int index) {
Region region = new Region();
if(series.getX(index) != null) {
throw new IllegalArgumentException("Attempt to find null region for non null index: " + index);
}
for(int i = index - 1; i >= 0; i--) {
Number val = series.getX(i);
if(val != null) {
region.setMin(i);
break;
}
}
for(int i = index + 1; i < series.size(); i++) {
Number val = series.getX(i);
if(val != null) {
region.setMax(i);
break;
}
}
return region;
}
/**
* @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.");
}
/**
* Determine the XVal order of an XYSeries. If series does not implement {@link OrderedXYSeries}
* then {@link com.androidplot.xy.OrderedXYSeries.XOrder#NONE} is assumed.
* @param series
* @return The {@link com.androidplot.xy.OrderedXYSeries.XOrder} of the series.
*/
public static OrderedXYSeries.XOrder getXYOrder(XYSeries series) {
return series instanceof OrderedXYSeries ?
((OrderedXYSeries) series).getXOrder() : OrderedXYSeries.XOrder.NONE;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/ 0000775 0000000 0000000 00000000000 13065526371 0025503 5 ustar 00root root 0000000 0000000 AdvancedLineAndPointRenderer.java 0000664 0000000 0000000 00000010545 13065526371 0033735 0 ustar 00root root 0000000 0000000 androidplot-1.4.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 AdvancedLineAndPointRenderer doGetRendererInstance(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.4.2/androidplot-core/src/main/java/com/androidplot/xy/Axis.java 0000664 0000000 0000000 00000001273 13065526371 0027255 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/BarFormatter.java 0000664 0000000 0000000 00000005647 13065526371 0030752 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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;
private float marginTop;
private float marginBottom;
private float marginLeft;
private float marginRight;
/**
* 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 doGetRendererInstance(XYPlot plot) {
return new BarRenderer(plot);
}
public float getMarginTop() {
return marginTop;
}
public void setMarginTop(float marginTop) {
this.marginTop = marginTop;
}
public float getMarginBottom() {
return marginBottom;
}
public void setMarginBottom(float marginBottom) {
this.marginBottom = marginBottom;
}
public float getMarginLeft() {
return marginLeft;
}
public void setMarginLeft(float marginLeft) {
this.marginLeft = marginLeft;
}
public float getMarginRight() {
return marginRight;
}
public void setMarginRight(float marginRight) {
this.marginRight = marginRight;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/BarRenderer.java 0000664 0000000 0000000 00000033602 13065526371 0030545 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 android.graphics.Canvas;
import android.graphics.RectF;
import com.androidplot.ui.RenderStack;
import com.androidplot.ui.SeriesBundle;
import com.androidplot.util.PixelUtils;
import com.androidplot.util.RectFUtils;
/**
* Renders the points in an XYSeries as bars. See {@link BarOrientation} javadoc for details on supported
* presentation styles.
*
*/
public class BarRenderer extends GroupRenderer {
private BarOrientation barOrientation = BarOrientation.OVERLAID; // default Render Style
private BarGroupWidthMode barGroupWidthMode = BarGroupWidthMode.FIXED_WIDTH; // default Width Style
/**
* Represents the size in pixels of either bar width or bar gap width, depending on the current
* value of barWidthMode.
*/
private float width = PixelUtils.dpToPix(3);
/**
* How bars should be laid out when in a group of 2 or more series.
*/
public enum BarOrientation {
/**
* Bars are drawn "overlapping" one another, with taller bars being drawn behind
* the shorter ones.
*/
OVERLAID, // bars are overlaid in descending y-val order (largest val in back)
/**
* Bars are stacked on top of one another so that the sum of their yVals produces the final
* height of that bar.
*/
STACKED, // bars are drawn stacked vertically on top of each other
/**
* Bars are drawn next to one another, grouped by iVal
*/
SIDE_BY_SIDE // bars are drawn horizontally next to each-other
}
/**
* Mode with which to calculate the width of each bar.
*/
public enum BarGroupWidthMode {
FIXED_WIDTH, // bar width is always barWidth
FIXED_GAP // bar width is calculated relative to a fixed gap width between each bar
}
public BarRenderer(XYPlot plot) {
super(plot);
}
public void setBarOrientation(BarOrientation renderBarOrientation) {
this.barOrientation = renderBarOrientation;
}
public BarOrientation getBarOrientation() {
return this.barOrientation;
}
public BarGroupWidthMode getBarGroupWidthMode() {
return this.barGroupWidthMode;
}
public float getBarGroupWidth() {
return this.width;
}
public void setBarGroupWidth(BarGroupWidthMode mode, float width) {
this.barGroupWidthMode = mode;
this.width = width;
}
protected BarComparator getBarComparator(float rangeOriginPx) {
return new BarComparator(getBarOrientation(), rangeOriginPx);
}
@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) {
List barGroups = new ArrayList<>();
/*
* 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(int i = 0; i < seriesSize; i++) {
final BarGroup group = new BarGroup(i, 0, plotArea);
int seriesOrder = 0;
for(SeriesBundle bundle : sfList) {
// TODO: is this null check really necessary?
if(bundle.getSeries().getX(i) != null) {
Bar bar = new Bar(getPlot(), bundle.getSeries(),
bundle.getFormatter(), seriesOrder, i, plotArea);
group.addBar(bar);
group.centerPix = bar.xPix;
}
seriesOrder++;
}
barGroups.add(group);
}
/*
* Calculate the dimensions of each barGroup and then draw each bar within it according to
* the Render Style and Width Style.
*/
final int groupCount = barGroups.size();
for(BarGroup barGroup : barGroups) {
// Determine the exact left and right X for the Bar Group
switch (barGroupWidthMode) {
case FIXED_WIDTH:
barGroup.leftPix = barGroup.centerPix - (width / 2);
barGroup.rightPix = barGroup.leftPix + width;
break;
case FIXED_GAP:
float barWidth = plotArea.width();
if(groupCount > 1) {
barWidth = (barGroups.get(1).centerPix - barGroups.get(0).centerPix) - width;
}
final float halfWidth = barWidth / 2;
barGroup.leftPix = barGroup.centerPix - halfWidth;
barGroup.rightPix = barGroup.centerPix + halfWidth;
break;
default:
break;
}
/*
* Draw the bars within the barGroup area.
*/
double rangeOrigin = getPlot().getRangeOrigin().doubleValue();
float rangeOriginPx = (float) getPlot().getBounds().yRegion
.transform(rangeOrigin, plotArea.top, plotArea.bottom, true);
final BarComparator comparator = getBarComparator(rangeOriginPx);
switch (barOrientation) {
case OVERLAID:
Collections.sort(barGroup.bars, comparator);
for (Bar bar : barGroup.bars) {
drawBar(canvas, bar, createBarRect(
bar.barGroup.leftPix,
bar.yPix,
bar.barGroup.rightPix,
rangeOriginPx, bar.formatter));
}
break;
case SIDE_BY_SIDE:
final float width = barGroup.getWidth() / barGroup.bars.size();
float leftX = barGroup.leftPix;
Collections.sort(barGroup.bars, comparator);
for (Bar bar : barGroup.bars) {
drawBar(canvas, bar, createBarRect(
leftX, bar.yPix,
leftX + width, rangeOriginPx,
bar.formatter));
leftX = leftX + width;
}
break;
case STACKED:
float bottom = (int) barGroup.plotArea.bottom;
Collections.sort(barGroup.bars, comparator);
for (Bar bar : barGroup.bars) {
// TODO: handling sub range-origin values for the purpose of labeling
final float height = (int) bar.barGroup.plotArea.bottom - bar.yPix;
final float top = bottom - height;
drawBar(canvas, bar, createBarRect(
bar.barGroup.leftPix, top,
bar.barGroup.rightPix, bottom,
bar.formatter));
bottom = top;
}
break;
default:
throw new UnsupportedOperationException("Unexpected BarOrientation: " + barOrientation);
}
}
}
protected RectF createBarRect(float w1, float h1, float w2, float h2, BarFormatter formatter) {
final RectF result = RectFUtils.createFromEdges(w1, h1,w2, h2);
result.left += formatter.getMarginLeft();
result.right -= formatter.getMarginRight();
result.top += formatter.getMarginTop();
result.bottom -= formatter.getMarginBottom();
return result;
}
protected void drawBar(Canvas canvas, Bar bar, RectF rect) {
// null yVals are skipped:
if(bar.getY() == null) {
return;
}
BarFormatter formatter = getFormatter(bar.i, bar.series);
if(formatter == null) {
formatter = bar.formatter;
}
if(rect.height() > 0 && rect.width() > 0) {
if (formatter.hasFillPaint()) {
canvas.drawRect(rect.left, rect.top, rect.right, rect.bottom,
formatter.getFillPaint());
}
if (formatter.hasLinePaint()) {
canvas.drawRect(rect.left, rect.top, rect.right, rect.bottom,
formatter.getBorderPaint());
}
}
PointLabelFormatter plf =
formatter.hasPointLabelFormatter() ? formatter.getPointLabelFormatter() : null;
PointLabeler pointLabeler =
formatter != null ? formatter.getPointLabeler() : null;
if (plf != null && plf.hasTextPaint() && pointLabeler != null) {
canvas.drawText(pointLabeler.getLabel(bar.series, bar.i),
rect.centerX() + plf.hOffset, bar.yPix + plf.vOffset,
plf.getTextPaint());
}
}
/**
*
* @param
*/
public static class Bar {
public final XYSeries series;
public final FormatterType formatter;
public final int i;
public final int seriesOrder;
public final float xPix;
public final float yPix;
protected BarGroup barGroup;
// TODO: factor out plot param
public Bar(XYPlot plot, XYSeries series, FormatterType formatter, int seriesOrder, int i, RectF plotArea) {
this.series = series;
this.formatter = formatter;
this.i = i;
this.seriesOrder = seriesOrder;
final double xVal = series.getX(i).doubleValue();
xPix = (float) plot.getBounds().getxRegion()
.transform(xVal, plotArea.left, plotArea.right, false);
if (series.getY(i) != null) {
final double yVal = series.getY(i).doubleValue();
this.yPix = (float) plot.getBounds().yRegion
.transform(yVal, plotArea.top, plotArea.bottom, true);
} else {
this.yPix = 0;
}
}
public Number getY() {
return series.getY(i);
}
}
/**
* A collection of one or more {@Bar} instances sharing a common iVal.
*/
private static class BarGroup {
public ArrayList bars;
public int i;
public float centerPix;
public float leftPix;
public float rightPix;
public RectF plotArea;
public BarGroup(int i, float centerPix, RectF plotArea) {
// Setup the TreeMap with the required comparator
this.bars = new ArrayList<>(); // create a comparator that compares series title given the index.
this.centerPix = centerPix;
this.plotArea = plotArea;
this.i = i;
}
public void addBar(Bar bar) {
bar.barGroup = this;
this.bars.add(bar);
}
protected float getWidth() {
return rightPix - leftPix;
}
}
/**
* Used to determine the order in which bars of the same group will be drawn.
*/
@SuppressWarnings("WeakerAccess")
public static class BarComparator implements Comparator {
private final BarOrientation barOrientation;
private final float rangeOriginPx;
public BarComparator(BarOrientation barOrientation, float rangeOriginPx) {
this.rangeOriginPx = rangeOriginPx;
this.barOrientation = barOrientation;
}
@Override
public int compare(Bar bar1, Bar bar2) {
switch (barOrientation) {
case OVERLAID:
if(bar1.yPix > rangeOriginPx && bar2.yPix > rangeOriginPx) {
return Float.valueOf(bar2.yPix).compareTo(bar1.yPix);
} else {
return Float.valueOf(bar1.yPix).compareTo(bar2.yPix);
}
case SIDE_BY_SIDE:
case STACKED:
default:
return Integer.valueOf(bar1.seriesOrder).compareTo(bar2.seriesOrder);
}
}
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/BoundaryMode.java 0000664 0000000 0000000 00000001363 13065526371 0030741 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/BubbleFormatter.java 0000664 0000000 0000000 00000005252 13065526371 0031431 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 static final int DEFAULT_STROKE_COLOR = Color.BLACK;
private static final int DEFAULT_FILL_COLOR = Color.YELLOW;
private Paint strokePaint;
private Paint fillPaint;
{
strokePaint = new Paint();
strokePaint.setAntiAlias(true);
strokePaint.setStrokeWidth(PixelUtils.dpToPix(DEFAULT_STROKE_PIX));
strokePaint.setStyle(Paint.Style.STROKE);
strokePaint.setColor(DEFAULT_STROKE_COLOR);
fillPaint = new Paint();
fillPaint.setAntiAlias(true);
fillPaint.setColor(DEFAULT_FILL_COLOR);
// 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() {}
public BubbleFormatter(Context context, int xmlCfgId) {
this();
configure(context, xmlCfgId);
}
public BubbleFormatter(int fillColor, int strokeColor) {
fillPaint.setColor(fillColor);
strokePaint.setColor(strokeColor);
}
@Override
public Class getRendererClass() {
return BubbleRenderer.class;
}
@Override
public BubbleRenderer doGetRendererInstance(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.4.2/androidplot-core/src/main/java/com/androidplot/xy/BubbleRenderer.java 0000664 0000000 0000000 00000012673 13065526371 0031241 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(SeriesBundle 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/BubbleSeries.java 0000664 0000000 0000000 00000003731 13065526371 0030720 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;
/**
*
* @param interleavedValues Interleaved values ordered as x, y, z; total size must be a multiple of 3.
*/
public BubbleSeries(Number... interleavedValues) {
if(interleavedValues == null || interleavedValues.length % 3 > 0) {
throw new RuntimeException("BubbleSeries interleave array length must be a non-zero multiple of 3.");
}
xVals = new ArrayList<>();
yVals = new ArrayList<>();
zVals = new ArrayList<>();
for(int i = 0; i < interleavedValues.length; i+=3) {
xVals.add(interleavedValues[i]);
yVals.add(interleavedValues[i+1]);
zVals.add(interleavedValues[i+2]);
}
}
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.4.2/androidplot-core/src/main/java/com/androidplot/xy/CandlestickFormatter.java 0000664 0000000 0000000 00000013536 13065526371 0032466 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 doGetRendererInstance(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.4.2/androidplot-core/src/main/java/com/androidplot/xy/CandlestickMaker.java 0000664 0000000 0000000 00000007007 13065526371 0031556 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/CandlestickRenderer.java 0000664 0000000 0000000 00000014314 13065526371 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.SeriesBundle;
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.4.2/androidplot-core/src/main/java/com/androidplot/xy/CandlestickSeries.java 0000664 0000000 0000000 00000010643 13065526371 0031751 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/CatmullRomInterpolator.java 0000664 0000000 0000000 00000024222 13065526371 0033032 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/EditableXYSeries.java 0000664 0000000 0000000 00000002063 13065526371 0031514 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 {@link XYSeries} that exposes methods to set values and resize
*/
public interface EditableXYSeries extends XYSeries {
void setX(Number x, int index);
void setY(Number y, int index);
/**
* Resize to accommodate the specified number of x/y pairs. If elements must be droped, those
* at the highest iVal should be removed first.
* @param size
*/
void resize(int size);
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/Estimator.java 0000664 0000000 0000000 00000000267 13065526371 0030322 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
/**
* Base for all estimation management schemes.
*/
public abstract class Estimator {
public abstract void run(XYPlot plot, XYSeriesBundle sf);
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/FastLineAndPointRenderer.java 0000664 0000000 0000000 00000012225 13065526371 0033201 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
* - Does not support null values
* @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];
}
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, PointLabelFormatter plf) {
super(lineColor, vertexColor, null, plf);
}
@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 doGetRendererInstance(XYPlot plot) {
return new FastLineAndPointRenderer(plot);
}
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/FastXYSeries.java 0000664 0000000 0000000 00000001046 13065526371 0030700 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
/**
* An implementation of {@link XYSeries} that defines additional methods to speed up rendering by
* giving a hint to the renderer about the min/max values contained in the series.
*/
public interface FastXYSeries extends XYSeries {
/**
* TIP: You can use {@link RectRegion#union(Number, Number)} during
* to keep a running tally of min/max values when iterating.
* @return A {@link RectRegion} representing the min/max values that currently exist this series.
*/
RectRegion minMax();
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/FillDirection.java 0000664 0000000 0000000 00000002253 13065526371 0031077 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/FixedSizeEditableXYSeries.java 0000664 0000000 0000000 00000003756 13065526371 0033341 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import com.androidplot.util.*;
import java.util.*;
/**
* An efficient implementation of {@link EditableXYSeries} intended for use cases where
* the total number of points visible is known ahead of time and is fairly static.
*
* {@link #resize(int)} may be used to resize the series when necessary, however it is a slow
* operation and should be avoided as much as possible.
*
*/
public class FixedSizeEditableXYSeries implements EditableXYSeries {
private List xVals = new ArrayList<>();
private List yVals = new ArrayList<>();
private String title;
public FixedSizeEditableXYSeries(String title, int size) {
setTitle(title);
resize(size);
}
@Override
public void setX(Number x, int index) {
xVals.set(index, new FastNumber(x));
}
@Override
public void setY(Number y, int index) {
yVals.set(index, new FastNumber(y));
}
/**
* May be used to dynamically resize the series. This is a relatively slow operation, especially
* as size increases so care should be taken to avoid unnecessary usage.
* @param size
*/
@Override
public void resize(int size) {
resize(xVals, size);
resize(yVals, size);
}
protected void resize(List list, int size) {
if (size > list.size()) {
while (list.size() < size) {
list.add(null);
}
} else if (size < list.size()) {
while (list.size() > size) {
list.remove(list.size() - 1);
}
}
}
@Override
public String getTitle() {
return this.title;
}
public void setTitle(String title) {
this.title = 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);
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/GroupRenderer.java 0000664 0000000 0000000 00000005712 13065526371 0031136 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.SeriesBundle;
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.4.2/androidplot-core/src/main/java/com/androidplot/xy/InterpolationParams.java 0000664 0000000 0000000 00000001476 13065526371 0032351 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/Interpolator.java 0000664 0000000 0000000 00000001541 13065526371 0031031 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/LTTBSampler.java 0000664 0000000 0000000 00000010654 13065526371 0030445 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import android.util.*;
/**
* Adapted from:
* https://github.com/drcrane/downsample
*
* Note that this implementation does not yet support null values.
*
* Basic usage example:
*
* {@code
* // An instance of any implementation of XYSeries; SimpleXYSeries, etc:
* XYSeries origalSeries = ...;
*
* // Sampled series with half the resolution of the
* EditableXYSeries sampledSeries = new FixedSizeEditableXYSeries(
* origalSeries.getTitle(), origalSeries.size() / 2);
*
* // does the actual sampling:
* new LTTBSampler().run(origalSeries, sampledSeries);
* }
*
*/
public class LTTBSampler implements Sampler {
public RectRegion run(XYSeries rawData, EditableXYSeries sampled) {
RectRegion bounds = new RectRegion();
final int threshold = sampled.size();
final int dataLength = rawData.size();
final int startIndex = 0;
if (threshold >= dataLength || threshold == 0) {
//return data; // Nothing to do
// TODO: set flag to return raw data
throw new RuntimeException("Shouldnt be here!");
}
int sampledIndex = 0;
// Bucket size. Leave room for start and end data points
final double bucketSize = (double) (dataLength - 2) / (threshold - 2);
int a = 0; // Initially a is the first point in the triangle
int nextA = 0;
setSample(rawData, sampled, a + startIndex, sampledIndex, bounds);
sampledIndex++;
for (int i = 0; i < threshold - 2; i++) {
// Calculate point average for next bucket (containing c)
double pointCX = 0;
double pointCY = 0;
int pointCStart = (int) Math.floor((i + 1) * bucketSize) + 1;
int pointCEnd = (int) Math.floor((i + 2) * bucketSize) + 1;
pointCEnd = pointCEnd < dataLength ? pointCEnd : dataLength;
final int pointCSize = pointCEnd - pointCStart;
for (; pointCStart < pointCEnd; pointCStart++) {
if(rawData.getX(pointCStart + startIndex) != null) {
pointCX += rawData.getX(pointCStart + startIndex).doubleValue();
}
if(rawData.getY(pointCStart + startIndex) != null) {
pointCY += rawData.getY(pointCStart + startIndex).doubleValue();
}
}
pointCX /= pointCSize;
pointCY /= pointCSize;
double pointAX = rawData.getX(a + startIndex).doubleValue();
double pointAY = rawData.getY(a + startIndex).doubleValue();
// Get the range for bucket b
int pointBStart = (int) Math.floor((i + 0) * bucketSize) + 1;
final int pointBEnd = (int) Math.floor((i + 1) * bucketSize) + 1;
double maxArea = -1;
XYCoords maxAreaPoint = null;
for (; pointBStart < pointBEnd; pointBStart++) {
final double area = Math.abs((pointAX - pointCX) * (rawData.getY(pointBStart + startIndex)
.doubleValue() - pointAY) - (pointAX - rawData.getX(pointBStart + startIndex)
.doubleValue())
* (pointCY - pointAY)) * 0.5;
if (area > maxArea) {
if(rawData.getY(pointBStart + startIndex) == null) {
Log.i("LTTB", "Null value encountered in raw data at index: " + pointBStart);
}
maxArea = area;
maxAreaPoint = new XYCoords(rawData.getX(pointBStart + startIndex),
rawData.getY(pointBStart + startIndex));
nextA = pointBStart; // Next a is this b
}
}
setSample(sampled, maxAreaPoint.x, maxAreaPoint.y, sampledIndex, bounds);
sampledIndex++;
a = nextA; // This a is the next a (chosen b)
}
setSample(rawData, sampled, (dataLength + startIndex) - 1, sampledIndex, bounds);
sampledIndex++;
return bounds;
}
protected void setSample(XYSeries raw, EditableXYSeries sampled, int rawIndex, int sampleIndex, RectRegion bounds) {
setSample(sampled, raw.getX(rawIndex), raw.getY(rawIndex), sampleIndex, bounds);
}
protected void setSample(EditableXYSeries sampled, Number x, Number y, int sampleIndex, RectRegion bounds) {
bounds.union(x, y);
sampled.setX(x, sampleIndex);
sampled.setY(y, sampleIndex);
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/LineAndPointFormatter.java 0000664 0000000 0000000 00000014413 13065526371 0032561 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 doGetRendererInstance(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 run 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 run 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 run 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/LineAndPointRenderer.java 0000664 0000000 0000000 00000031357 13065526371 0032372 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.Paint;
import android.graphics.Path;
import android.graphics.PointF;
import android.graphics.RectF;
import com.androidplot.Plot;
import com.androidplot.PlotListener;
import com.androidplot.Region;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.ui.RenderStack;
import com.androidplot.util.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
/**
* 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;
private final Path path = new Path();
protected final ConcurrentHashMap> pointsCaches
= new ConcurrentHashMap<>(2, 0.75f, 2);
public LineAndPointRenderer(XYPlot plot) {
super(plot);
plot.addListener(new PlotListener() {
@Override
public void onBeforeDraw(Plot source, Canvas canvas) {
cullPointsCache();
}
@Override
public void onAfterDraw(Plot source, Canvas canvas) {
}
});
}
@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);
}
/**
* Retrieves or initializes a list for storing calculated screen-coords to render as points.
* Also handles automatic resizing and culling of unused caches.
* Should only be called once per render cycle.
* @param series
* @return
*/
protected ArrayList getPointsCache(XYSeries series) {
ArrayList pointsCache = pointsCaches.get(series);
final int seriesSize = series.size();
if(pointsCache == null) {
pointsCache = new ArrayList<>(seriesSize);
pointsCaches.put(series, pointsCache);
}
if(pointsCache.size() < seriesSize) {
while(pointsCache.size() < seriesSize) {
pointsCache.add(null);
}
} else if(pointsCache.size() > seriesSize) {
while(pointsCache.size() > seriesSize) {
pointsCache.remove(0);
}
}
return pointsCache;
}
protected void cullPointsCache() {
for(XYSeries series : pointsCaches.keySet()) {
if(!getPlot().getRegistry().contains(series, LineAndPointFormatter.class)) {
//pointsCaches.put(series, null);
pointsCaches.remove(series);
}
}
}
protected void drawSeries(Canvas canvas, RectF plotArea, XYSeries series, LineAndPointFormatter formatter) {
PointF thisPoint;
PointF lastPoint = null;
PointF firstPoint = null;
path.reset();
final List points = getPointsCache(series);
int iStart = 0;
int iEnd = series.size();
if(SeriesUtils.getXYOrder(series) == OrderedXYSeries.XOrder.ASCENDING) {
final Region iBounds = SeriesUtils.iBounds(series, getPlot().getBounds());
iStart = iBounds.getMin().intValue();
if(iStart > 0) {
iStart--;
}
iEnd = iBounds.getMax().intValue() + 1;
if(iEnd < series.size() - 1) {
iEnd++;
}
}
for (int i = iStart; i < iEnd; i++) {
final Number y = series.getY(i);
final Number x = series.getX(i);
PointF iPoint = points.get(i);
if (y != null && x != null) {
if(iPoint == null) {
iPoint = new PointF();
points.set(i, iPoint);
}
thisPoint = iPoint;
getPlot().getBounds().transformScreen(thisPoint, x, y, plotArea);
} else {
thisPoint = null;
iPoint = null;
points.set(i, iPoint);
}
// 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.reset();
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.reset();
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, iStart, iEnd, 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, int iStart, int iEnd, List points,
LineAndPointFormatter formatter) {
if (formatter.hasVertexPaint() || formatter.hasPointLabelFormatter()) {
final Paint vertexPaint = formatter.hasVertexPaint() ? formatter.getVertexPaint() : null;
final boolean hasPointLabelFormatter = formatter.hasPointLabelFormatter();
final PointLabelFormatter plf = hasPointLabelFormatter ? formatter.getPointLabelFormatter() : null;
final PointLabeler pointLabeler = hasPointLabelFormatter ? formatter.getPointLabeler() : null;
for(int i = iStart; i < iEnd; i++) {
PointF p = points.get(i);
if(p != null) {
// if vertexPaint is available, draw vertex:
if (vertexPaint != null) {
canvas.drawPoint(p.x, p.y, vertexPaint);
}
// if textPaint and pointLabeler are available, draw point's text label:
if (pointLabeler != null) {
canvas.drawText(pointLabeler.getLabel(series, i),
p.x + plf.hOffset, p.y + plf.vOffset, plf.getTextPaint());
}
}
}
}
}
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.intersect(plotRegion);
if(thisRegion.isFullyDefined()) {
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.4.2/androidplot-core/src/main/java/com/androidplot/xy/NormedXYSeries.java 0000664 0000000 0000000 00000010472 13065526371 0031232 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import com.androidplot.Region;
import com.androidplot.util.SeriesUtils;
/**
* Wrapper implementation of {@link XYSeries} that wraps another XYSeries, normalizing values in the range of 0 to 1.
* Note that it's possible to push normed values outside of the standard 0, 1 range by applying
* a sufficiently large offset.
*/
public class NormedXYSeries implements XYSeries {
private XYSeries rawData;
private Region minMaxX;
private Region minMaxY;
private Region transformX;
private Region transformY;
public static class Norm {
final Region minMax;
final double offset;
final boolean useOffsetCompression;
public Norm(Region minMax) {
this(minMax, 0, false);
}
/**
*
* @param minMax Boundary to use when calculating the norm coefficient. Set to null to let
* Androidplot auto calculate the bounds. (Very inefficient)
* @param offset An extra offset to apply, generally within the range of -1 and 1.
* This value is useful for adjusting the positioning of a series relative to another normalized series.
* @param useOffsetCompression If true, the offset value will result in further scaling down
* of the series data in order to ensure that all points within the specified bounds remain
* visible on the screen. If set to true, the specified offset MUST be > -1 and < 1. Will be
* ignored if bounds != null.
*/
public Norm(Region minMax, double offset, boolean useOffsetCompression) {
this.minMax = minMax;
this.offset = offset;
this.useOffsetCompression = useOffsetCompression;
if (useOffsetCompression && (offset <= -1 || offset >= 1)) {
throw new IllegalArgumentException(
"When useOffsetCompression is true, offset must be > -1 and < 1.");
}
}
}
/**
* Normalizes yVals only, auto calculating min/max.
* @param rawData
*/
public NormedXYSeries(XYSeries rawData) {
this(rawData, null, new Norm(null, 0, false));
}
/**
*
* @param rawData The XYSeries to be normalized.
* @param x Normalization to apply to xVals. Set to null to disable normalization on the x axis.
* @param y Normalization to apply to yVals. Set to null to disable normalization on the y axis.
*/
public NormedXYSeries(XYSeries rawData, Norm x, Norm y) {
this.rawData = rawData;
normalize(x, y);
}
protected void normalize(Norm x, Norm y) {
if( x != null) {
this.minMaxX = x.minMax != null ? x.minMax : SeriesUtils.minMaxX(rawData);
this.transformX = calculateTransform(x);
}
if( y != null) {
this.minMaxY = y.minMax != null ? y.minMax : SeriesUtils.minMaxY(rawData);
this.transformY = calculateTransform(y);
}
}
protected Region calculateTransform(Norm norm) {
if(norm.useOffsetCompression) {
return new Region(
norm.offset > 0 ? norm.offset : 0,
norm.offset < 0 ? 1 + norm.offset : 1);
} else {
return new Region(0 + norm.offset, 1 + norm.offset);
}
}
@Override
public String getTitle() {
return rawData.getTitle();
}
@Override
public int size() {
return rawData.size();
}
public Number denormalizeXVal(Number xVal) {
if(xVal != null) {
return transformX.transform(xVal.doubleValue(), minMaxX);
}
return null;
}
public Number denormalizeYVal(Number yVal) {
if(yVal != null) {
return transformY.transform(yVal.doubleValue(), minMaxY);
}
return null;
}
@Override
public Number getX(int index) {
final Number xVal = rawData.getX(index);
if(xVal != null && transformX != null) {
return minMaxX.transform(xVal.doubleValue(), transformX);
}
return xVal;
}
@Override
public Number getY(int index) {
final Number yVal = rawData.getY(index);
if(yVal != null && transformY != null) {
return minMaxY.transform(yVal.doubleValue(), transformY);
}
return yVal;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/OrderedXYSeries.java 0000664 0000000 0000000 00000001304 13065526371 0031364 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
/**
* An implementation of {@link XYSeries} that gives hints to it's renderer about the order
* of the data being rendered.
*/
public interface OrderedXYSeries extends XYSeries {
enum XOrder {
/**
* XVals are in strict ascending order such that:
* x(i) > x(i+1) == true
*/
ASCENDING,
/**
* XVals are in strict descending order such that:
* x(i) < x(i+1) == true
*/
DESCENDING,
/**
* XVals appear in no particular order.
*/
NONE
}
/**
* The order of XVals as they appear in this series.
* @return
*/
XOrder getXOrder();
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/PanZoom.java 0000664 0000000 0000000 00000040404 13065526371 0027733 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import android.graphics.RectF;
import android.graphics.PointF;
import android.view.*;
import com.androidplot.*;
import com.androidplot.util.*;
import java.util.*;
/**
* Enables basic pan/zoom touch behavior for an {@link XYPlot}.
* By default boundaries there are no boundaries imposed on scrolling and zooming. You can provide these boundaries
* on your {@link XYPlot} using {@link XYPlot#getOuterLimits()}.
* TODO: zoom using dynamic center point
* TODO: stretch both mode
*/
public class PanZoom implements View.OnTouchListener {
protected static final float MIN_DIST_2_FING = 5f;
protected static final int FIRST_FINGER = 0;
protected static final int SECOND_FINGER = 1;
private XYPlot plot;
private Pan pan;
private Zoom zoom;
private ZoomLimit zoomLimit;
private boolean isEnabled = true;
private DragState dragState = DragState.NONE;
private PointF firstFingerPos;
// rectangle created by the space between two fingers
protected RectF fingersRect;
private View.OnTouchListener delegate;
// Definition of the touch states
protected enum DragState {
NONE,
ONE_FINGER,
TWO_FINGERS
}
public enum Pan {
NONE,
HORIZONTAL,
VERTICAL,
BOTH
}
public enum Zoom {
/**
* Comletely disable panning
*/
NONE,
/**
* 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
}
/**
* Limits imposed on the zoom.
*/
public enum ZoomLimit {
/**
* Do not zoom outside the plots outer bounds, if they are defined.
*/
OUTER,
/**
* Additionally to the outer bounds if plot.StepModel defines a value based increment
* make sure at least one tick is visible by not zooming in further.
*/
MIN_TICKS
}
protected PanZoom(XYPlot plot, Pan pan, Zoom zoom) {
this.plot = plot;
this.pan = pan;
this.zoom = zoom;
this.zoomLimit = ZoomLimit.OUTER;
}
// additional constructor not to break api
protected PanZoom(XYPlot plot, Pan pan, Zoom zoom, ZoomLimit limit) {
this.plot = plot;
this.pan = pan;
this.zoom = zoom;
this.zoomLimit = limit;
}
/**
* 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, ZoomLimit)} for finer grain control of this behavior.
* @param plot
* @return
*/
public static PanZoom attach(XYPlot plot) {
return attach(plot, Pan.BOTH, Zoom.SCALE);
}
/**
* Old method for enabling pan/zoom behavior on an instance of {@link XYPlot}, using
* the default behavior of {@link ZoomLimit#OUTER}.
* Use {@link PanZoom#attach(XYPlot, Pan, Zoom, ZoomLimit)} for finer grain control of this behavior.
* @param plot
* @param pan
* @param zoom
* @return
*/
public static PanZoom attach(XYPlot plot, Pan pan, Zoom zoom) {
return attach(plot,pan,zoom, ZoomLimit.OUTER);
}
/**
* New method for enabling pan/zoom behavior on an instance of {@link XYPlot}.
* @param plot
* @param pan
* @param zoom
* @param limit
* @return
*/
public static PanZoom attach(XYPlot plot, Pan pan, Zoom zoom, ZoomLimit limit) {
PanZoom pz = new PanZoom(plot, pan, zoom, limit);
plot.setOnTouchListener(pz);
return pz;
}
public boolean isEnabled() {
return isEnabled;
}
public void setEnabled(boolean enabled) {
isEnabled = enabled;
}
@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
{
setFingersRect(fingerDistance(event));
// the distance run is done to avoid false alarms
if (getFingersRect().width() > MIN_DIST_2_FING || getFingersRect().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;
case MotionEvent.ACTION_UP:
reset();
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 firstFingerX
* @param firstFingerY
* @param secondFingerX
* @param secondFingerY
* @return
*/
protected RectF fingerDistance(float firstFingerX, float firstFingerY, float secondFingerX, float secondFingerY) {
final float left = firstFingerX > secondFingerX ? secondFingerX : firstFingerX;
final float right = firstFingerX > secondFingerX ? firstFingerX : secondFingerX;
final float top = firstFingerY > secondFingerY ? secondFingerY : firstFingerY;
final float bottom = firstFingerY > secondFingerY ? firstFingerY : secondFingerY;
return new RectF(left, top, right, bottom);
}
/**
* Calculates the distance between two finger motion events.
* @param evt
* @return
*/
protected RectF fingerDistance(final MotionEvent evt) {
return fingerDistance(
evt.getX(FIRST_FINGER),
evt.getY(FIRST_FINGER),
evt.getX(SECOND_FINGER),
evt.getY(SECOND_FINGER));
}
protected void pan(final MotionEvent motionEvent) {
if (pan == Pan.NONE) {
return;
}
final PointF oldFirstFinger = firstFingerPos; //save old position of finger
firstFingerPos = new PointF(motionEvent.getX(), motionEvent.getY()); //update finger position
if (EnumSet.of(Pan.HORIZONTAL, Pan.BOTH).contains(pan)) {
Region newBounds = new Region();
calculatePan(oldFirstFinger, newBounds, true);
plot.setDomainBoundaries(newBounds.getMin(), newBounds.getMax(), BoundaryMode.FIXED);
}
if (EnumSet.of(Pan.VERTICAL, Pan.BOTH).contains(pan)) {
Region newBounds = new Region();
calculatePan(oldFirstFinger, newBounds, false);
plot.setRangeBoundaries(newBounds.getMin(), newBounds.getMax(), BoundaryMode.FIXED);
}
plot.redraw();
}
protected void calculatePan(final PointF oldFirstFinger, Region bounds, 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) {
bounds.setMinMax(plot.getBounds().getxRegion());
offset = (oldFirstFinger.x - firstFingerPos.x) *
((bounds.getMax().floatValue() - bounds.getMin().floatValue()) / plot.getWidth());
} else {
bounds.setMinMax(plot.getBounds().getyRegion());
offset = -(oldFirstFinger.y - firstFingerPos.y) *
((bounds.getMax().floatValue() - bounds.getMin().floatValue()) / plot.getHeight());
}
// move the calculated offset
bounds.setMin(bounds.getMin().floatValue() + offset);
bounds.setMax(bounds.getMax().floatValue() + offset);
//get the distance between max and min
final float diff = bounds.length().floatValue();
//run if we reached the limit of panning
if (horizontal && plot.getOuterLimits().getxRegion().isDefined()) {
if (bounds.getMin().floatValue() < plot.getOuterLimits().getMinX().floatValue()) {
bounds.setMin(plot.getOuterLimits().getMinX());
bounds.setMax(bounds.getMin().floatValue() + diff);
}
if (bounds.getMax().floatValue() > plot.getOuterLimits().getMaxX().floatValue()) {
bounds.setMax(plot.getOuterLimits().getMaxX());
bounds.setMin(bounds.getMax().floatValue() - diff);
}
} else if(plot.getOuterLimits().getyRegion().isDefined()) {
if (bounds.getMin().floatValue() < plot.getOuterLimits().getMinY().floatValue()) {
bounds.setMin(plot.getOuterLimits().getMinY());
bounds.setMax(bounds.getMin().floatValue() + diff);
}
if (bounds.getMax().floatValue() > plot.getOuterLimits().getMaxY().floatValue()) {
bounds.setMax(plot.getOuterLimits().getMaxY());
bounds.setMin(bounds.getMax().floatValue() - 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) {
if (zoom == Zoom.NONE) {
return;
}
final RectF oldFingersRect = getFingersRect();
final RectF newFingersRect = fingerDistance(motionEvent);
setFingersRect(newFingersRect);
if(oldFingersRect == null || RectFUtils.areIdentical(oldFingersRect, newFingersRect)) {
// zooming gesture has not happened yet so skip:
return;
}
RectF newRect = new RectF();
float scaleX = 1;
float scaleY = 1;
switch (zoom) {
case STRETCH_HORIZONTAL:
scaleX = oldFingersRect.width() / getFingersRect().width();
if (!isValidScale(scaleX)) {
return;
}
break;
case STRETCH_VERTICAL:
scaleY = oldFingersRect.height() / getFingersRect().height();
if (!isValidScale(scaleY)) {
return;
}
break;
case STRETCH_BOTH:
scaleX = oldFingersRect.width() / getFingersRect().width();
scaleY = oldFingersRect.height() / getFingersRect().height();
if (!isValidScale(scaleX) || !isValidScale(scaleY)) {
return;
}
break;
case SCALE:
float sc1 = (float) Math.hypot(oldFingersRect.height(), oldFingersRect.width());
float sc2 = (float) Math.hypot(getFingersRect().height(), getFingersRect().width());
float sc = sc1 / sc2;
scaleX = sc;
scaleY = sc;
if (!isValidScale(scaleX) || !isValidScale(scaleY)) {
return;
}
break;
}
if (EnumSet.of(
Zoom.STRETCH_HORIZONTAL,
Zoom.STRETCH_BOTH,
Zoom.SCALE).contains(zoom)) {
calculateZoom(newRect, scaleX, true);
plot.setDomainBoundaries(newRect.left, newRect.right, BoundaryMode.FIXED);
}
if (EnumSet.of(
Zoom.STRETCH_VERTICAL,
Zoom.STRETCH_BOTH,
Zoom.SCALE).contains(zoom)) {
calculateZoom(newRect, scaleY, false);
plot.setRangeBoundaries(newRect.top, newRect.bottom, BoundaryMode.FIXED);
}
plot.redraw();
}
/**
*
* @param newRect RectF into which zoom calculation results should be placed.
* @param scale
* @param isHorizontal
*/
protected void calculateZoom(RectF newRect, float scale, boolean isHorizontal) {
final float calcMax;
final float span;
final RectRegion bounds = plot.getBounds();
if (isHorizontal) {
calcMax = bounds.getMaxX().floatValue();
span = calcMax - bounds.getMinX().floatValue();
} else {
calcMax = bounds.getMaxY().floatValue();
span = calcMax - bounds.getMinY().floatValue();
}
final float midPoint = calcMax - (span / 2.0f);
float offset = span * scale / 2.0f;
final RectRegion limits = plot.getOuterLimits();
if (isHorizontal ) {
// zoom limited and increment by value StepMode?
if (zoomLimit == ZoomLimit.MIN_TICKS) {
// make sure we do not zoom in too far (there should be at least one grid line visible)
if (plot.getDomainStepValue() > (scale*span)) {
offset = (float)(plot.getDomainStepValue() / 2.0f);
}
}
newRect.left = midPoint - offset;
newRect.right = midPoint + offset;
if(limits.isFullyDefined()) {
if (newRect.left < limits.getMinX().floatValue()) {
newRect.left = limits.getMinX().floatValue();
}
if (newRect.right > limits.getMaxX().floatValue()) {
newRect.right = limits.getMaxX().floatValue();
}
}
} else {
// zoom limited and increment by value StepMode?
if (zoomLimit == ZoomLimit.MIN_TICKS) {
// make sure we do not zoom in too far (there should be at least one grid line visible)
if (plot.getRangeStepValue() > (scale*span)) {
offset = (float)(plot.getRangeStepValue() / 2.0f);
}
}
newRect.top = midPoint - offset;
newRect.bottom = midPoint + offset;
if(limits.isFullyDefined()) {
if (newRect.top < limits.getMinY().floatValue()) {
newRect.top = limits.getMinY().floatValue();
}
if (newRect.bottom > limits.getMaxY().floatValue()) {
newRect.bottom = limits.getMaxY().floatValue();
}
}
}
}
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 ZoomLimit getZoomLimit() {
return zoomLimit;
}
public void setZoomLimit(ZoomLimit zoomLimit) {
this.zoomLimit = zoomLimit;
}
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;
}
public void reset() {
this.firstFingerPos = null;
setFingersRect(null);
this.setFingersRect(null);
}
protected RectF getFingersRect() {
return fingersRect;
}
protected void setFingersRect(RectF fingersRect) {
this.fingersRect = fingersRect;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/PointLabelFormatter.java 0000664 0000000 0000000 00000005120 13065526371 0032261 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/PointLabeler.java 0000664 0000000 0000000 00000001403 13065526371 0030724 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/RectRegion.java 0000664 0000000 0000000 00000030752 13065526371 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 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 void transformScreen(PointF result, Number x, Number y, RectF region2) {
transform(result, x, y, region2, false, true);
}
public void transform(PointF result, Number x, Number y, RectF region2, boolean flipX, boolean flipY) {
result.x = (float) xRegion.transform(x.doubleValue(), region2.left, region2.right, flipX);
result.y = (float) yRegion.transform(y.doubleValue(), region2.top, region2.bottom, flipY);
}
public PointF transform(Number x, Number y, RectF region2, boolean flipX, boolean flipY) {
PointF result = new PointF();
transform(result, x, y, region2, flipX, flipY);
return result;
}
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);
}
public void union(Number x, Number y) {
xRegion.union(x);
yRegion.union(y);
}
/**
* 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
*
* The result will always have equal or greater area than the inputs.
* @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());
}
/**
* The result of an intersect is always a RectRegion with an equal or smaller area.
* @param clippingBounds
*/
public void intersect(RectRegion clippingBounds) {
if(intersects(clippingBounds)) {
xRegion.intersect(clippingBounds.xRegion);
yRegion.intersect(clippingBounds.yRegion);
} else {
setMinY(null);
setMaxY(null);
setMinX(null);
setMaxX(null);
}
}
/**
* 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 void set(Number minX, Number maxX, Number minY, Number maxY) {
setMinX(minX);
setMaxX(maxX);
setMinY(minY);
setMaxY(maxY);
}
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();
}
/**
* True if this region contains the specified coordinates.
* @param x
* @param y
* @return
*/
public boolean contains(Number x, Number y) {
return getxRegion().contains(x) && getyRegion().contains(y);
}
/**
* Checks to see whether the specified line. Note that this implementation will return
* true even if the line is completely enclosed by this RectRegion.
* WARNING: this implementation has problems. See associated unit test for details.
* @param x1 x-coord of the line beginning
* @param y1 y-coord of the line beginning
* @param x2 x-coord of the line end
* @param y2 y-coord of the line end
* @return True if this RectRegion overlaps any part of the specified line.
*/
public boolean intersectsWithLine(Number x1, Number y1, Number x2, Number y2) {
if(contains(x1, y1) || contains(x2, y2)) {
return true;
}
// if true, it means that these points exist on different sides of the rect's edges
final boolean x1MinRelation = x1.doubleValue() < getMinX().doubleValue();
final boolean x2MinRelation = x2.doubleValue() < getMinX().doubleValue();
final boolean xMinRelation = x1MinRelation &! x2MinRelation;
final boolean x1MaxRelation = x1.doubleValue() < getMaxX().doubleValue();
final boolean x2MaxRelation = x2.doubleValue() < getMaxX().doubleValue();
final boolean xMaxRelation = x1MaxRelation &! x2MaxRelation;
final boolean y1MinRelation = y1.doubleValue() < getMinY().doubleValue();
final boolean y2MinRelation = y2.doubleValue() < getMinY().doubleValue();
final boolean yMinRelation = y1MinRelation &! y2MinRelation;
final boolean y1MaxRelation = y1.doubleValue() < getMaxY().doubleValue();
final boolean y2MaxRelation = y2.doubleValue() < getMaxY().doubleValue();
final boolean yMaxRelation = y1MaxRelation &! y2MaxRelation;
return ((xMinRelation | xMaxRelation) || getxRegion().contains(x1) & (yMinRelation | yMaxRelation) || getyRegion().contains(y1));
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/SampledXYSeries.java 0000664 0000000 0000000 00000015172 13065526371 0031375 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import com.androidplot.*;
import com.androidplot.util.SeriesUtils;
import java.util.*;
/**
* An implementation of {@link FastXYSeries} that samples its self into multiple levels to
* achieve faster rendering / zoom behavior. By default, uses {@link LTTBSampler} as
* it's sampling algorithm. Note that this algorithm does not yet support null values.
*
* Sampling behavior is controlled by two values:
* Ratio: A value greater than 1; controls the sampling ratio of each successive series. For example,
* a step of 2 would mean that each successive series contains 2x fewer points than the previous.
*
* Threshold: A value < the original series size; controls the lower limit at which point sampling should stop.
* For example, sampling a series with size 1000 given a ratio of 2 and a threshold of 100,
* three sampled resolutions will be generated:
*
* 500 - 2x sampling
* 250 - 4x sampling
* 125 - 8x sampling
*
*/
public class SampledXYSeries implements FastXYSeries, OrderedXYSeries {
private int threshold;
private Sampler algorithm = new LTTBSampler();
private XYSeries rawData;
private List zoomLevels;
private XYSeries activeSeries;
private RectRegion bounds;
private Exception lastResamplingException;
private final XOrder xOrder;
private float ratio;
/**
*
* @param rawData
* @param xOrder If your data is in ascending or descending order, specifying it here speed up
* optimize render times.
* @param ratio The ratio used to determine the size of each new sampled series. Must be > 1.
* downsampled series until threshold is reached.
* @param threshold The desired size of the smallest sample series. Must be < rawData.size.
*/
public SampledXYSeries(XYSeries rawData, XOrder xOrder, float ratio, int threshold) {
this.rawData = rawData;
this.xOrder = xOrder;
this.setRatio(ratio);
this.setThreshold(threshold);
resample();
}
/**
* Generate a SampledXYSeries from the input series.
* @param rawData The original series to be downsampled
* @param ratio The ratio used to determine the size of each new sampled series. Must be > 1.
* downsampled series until threshold is reached.
* @param threshold The desired size of the smallest sample series. Must be < rawData.size.
*/
public SampledXYSeries(XYSeries rawData, float ratio, int threshold) {
this(rawData, SeriesUtils.getXYOrder(rawData), ratio, threshold);
}
public void resample() {
bounds = null;
zoomLevels = new ArrayList<>();
int t = (int) Math.ceil(rawData.size() / getRatio());
List threads = new ArrayList<>(zoomLevels.size());
while (t > threshold) {
final int thisThreshold = t;
final EditableXYSeries thisSeries = new FixedSizeEditableXYSeries(getTitle(), thisThreshold);
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
// TODO: make bounds a param to prevent calculating on each setZoomFactor level:
RectRegion b = getAlgorithm()
.run(rawData, thisSeries);
if (bounds == null) {
bounds = b;
}
} catch(Exception ex) {
lastResamplingException = ex;
}
}
});
getZoomLevels().add(thisSeries);
threads.add(thread);
thread.start();
t = (int) Math.ceil(t / getRatio());
}
for(Thread thread : threads) {
try {
thread.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
if(lastResamplingException != null) {
throw new RuntimeException("Exception encountered during resampling", lastResamplingException);
}
}
protected List getZoomLevels() {
return this.zoomLevels;
}
/**
* Set zoom factor; 2.5 = 2.5x zoom, 10.0 = 10x zoom etc. This method will set the zoom level
* to the closest available factor to the specified factor; a specified factor of 4.5x may result
* in an actual factor of 4x.
* @param factor
*/
public void setZoomFactor(double factor) {
if(factor <= 1) {
activeSeries = rawData;
} else {
//int i = (int) Math.round(Math.sqrt(factor) - 1);
int i = getZoomIndex(factor, getRatio());
if (i < zoomLevels.size()) {
activeSeries = zoomLevels.get(i);
} else {
activeSeries = zoomLevels.get(zoomLevels.size() - 1);
}
}
}
protected static int getZoomIndex(double zoomFactor, double ratio) {
final double lhs = Math.log(zoomFactor);
final double rhs = Math.log(ratio);
final double log = lhs / rhs;
final int index = (int) Math.round(log);
return index > 0 ? index - 1 : 0;
}
public double getMaxZoomFactor() {
return Math.pow(getRatio(), zoomLevels.size());
}
public Sampler getAlgorithm() {
return algorithm;
}
public void setAlgorithm(Sampler algorithm) {
this.algorithm = algorithm;
resample();
}
@Override
public String getTitle() {
return rawData.getTitle();
}
@Override
public int size() {
return activeSeries.size();
}
@Override
public Number getX(int index) {
return activeSeries.getX(index);
}
@Override
public Number getY(int index) {
return activeSeries.getY(index);
}
public int getThreshold() {
return threshold;
}
public void setThreshold(int threshold) {
if(threshold >= rawData.size()) {
throw new IllegalArgumentException("Threshold must be < original series size.");
}
this.threshold = threshold;
}
public RectRegion getBounds() {
return bounds;
}
public void setBounds(RectRegion bounds) {
this.bounds = bounds;
}
@Override
public RectRegion minMax() {
return bounds;
}
@Override
public XOrder getXOrder() {
return xOrder;
}
public float getRatio() {
return ratio;
}
public void setRatio(float ratio) {
if(ratio <= 1) {
throw new IllegalArgumentException("Ratio must be greater than 1");
}
this.ratio = ratio;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/Sampler.java 0000664 0000000 0000000 00000000742 13065526371 0027754 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
/**
* An algorithm used to to resample a larger set of data into a smaller set.
*/
public interface Sampler {
/**
*
* @param input The original unsampled series
* @param output The destination series to contain sampled result.
* This series size should be set to the desired sampled size.
* @return min/max values encountered while processing input.
*/
RectRegion run(XYSeries input, EditableXYSeries output);
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/ScalingXYSeries.java 0000664 0000000 0000000 00000003004 13065526371 0031357 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
/**
* Wraps an existing {@link XYSeries} allowing easy scaling of that series' xy values.
*/
public class ScalingXYSeries implements XYSeries {
private double scale;
private XYSeries series;
private Mode mode;
public enum Mode {
X_ONLY,
Y_ONLY,
X_AND_Y
}
/**
*
* @param series The {@link XYSeries} to be scaled
* @param scale The initial scale to be applied
* @param mode Determines which axis (or both) to which scaling will be applied.
*/
public ScalingXYSeries(XYSeries series, double scale, Mode mode) {
this.series = series;
this.scale = scale;
this.mode = mode;
}
@Override
public String getTitle() {
return series.getTitle();
}
@Override
public int size() {
return series.size();
}
@Override
public Number getX(int index) {
Number x = series.getX(index);
if(mode == Mode.X_ONLY || mode == Mode.X_AND_Y) {
return x == null ? null : x.doubleValue() * scale;
} else {
return x;
}
}
@Override
public Number getY(int index) {
Number y = series.getY(index);
if(mode == Mode.Y_ONLY || mode == Mode.X_AND_Y) {
return y == null ? null : y.doubleValue() * scale;
} else {
return y;
}
}
public double getScale() {
return scale;
}
public void setScale(double scale) {
this.scale = scale;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/SimpleXYSeries.java 0000664 0000000 0000000 00000024576 13065526371 0031251 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 EditableXYSeries, OrderedXYSeries, PlotListener {
private static final String TAG = SimpleXYSeries.class.getName();
private volatile LinkedList xVals = new LinkedList<>();
private volatile LinkedList yVals = new LinkedList<>();
private volatile String title = null;
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
private XOrder xOrder = XOrder.NONE;
public enum ArrayFormat {
Y_VALS_ONLY,
XY_VALS_INTERLEAVED
}
public SimpleXYSeries(String title) {
this.title = title;
}
public SimpleXYSeries(ArrayFormat format, String title, Number... model) {
this(asNumberList(model), format, title);
}
/**
* Retrieve the current x-ordering specified for this series. Default is
* {@link com.androidplot.xy.OrderedXYSeries.XOrder#NONE}.
* @return
*/
@Override
public XOrder getXOrder() {
return xOrder;
}
/**
* If XVals are in strict ascending order, use this method to set
* {@link com.androidplot.xy.OrderedXYSeries.XOrder#ASCENDING} to provide an optimization
* hint to the renderer.
* @param xOrder
*/
public void setXOrder(XOrder xOrder) {
this.xOrder = xOrder;
}
@Override
public void onBeforeDraw(Plot source, Canvas canvas) {
lock.readLock().lock();
}
@Override
public void onAfterDraw(Plot source, Canvas canvas) {
lock.readLock().unlock();
}
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();
}
}
@Override
public void resize(int size) {
try {
lock.writeLock().lock();
if (xVals.size() < size) {
for (int i = xVals.size(); i < size; i++) {
xVals.add(null);
yVals.add(null);
}
} else if(xVals.size() > size) {
for(int i = xVals.size(); i > size; i--) {
xVals.removeLast();
yVals.removeLast();
}
}
} 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 {
if (xVals != null) {
xVals.clear();
}
yVals.clear();
} finally {
lock.writeLock().unlock();
}
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/Step.java 0000664 0000000 0000000 00000003042 13065526371 0027260 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/StepFormatter.java 0000664 0000000 0000000 00000002427 13065526371 0031152 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 doGetRendererInstance(XYPlot plot) {
return new StepRenderer(plot);
}
} androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/StepMode.java 0000664 0000000 0000000 00000002002 13065526371 0030060 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.
* INCREMENT_BY_FIT choose increment from a list of possible values
*/
public enum StepMode {
SUBDIVIDE, // default
INCREMENT_BY_VAL,
INCREMENT_BY_PIXELS,
INCREMENT_BY_FIT
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/StepModel.java 0000664 0000000 0000000 00000002242 13065526371 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.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.4.2/androidplot-core/src/main/java/com/androidplot/xy/StepModelFit.java 0000664 0000000 0000000 00000004453 13065526371 0030713 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import com.androidplot.Region;
import java.util.Arrays;
/**
* Subclass of StepModel that chooses from predefined step values. Depending on the currently
* displayed range (by value) choose increment so that the number of lines
* is closest to StepModel.value
*/
public class StepModelFit extends StepModel {
private double[] steps; // list of steps to choose from
private Region scale; // axis region on display
public StepModelFit(Region axisRegion, double[] increments, double numLines) {
super(StepMode.INCREMENT_BY_FIT, numLines);
setSteps(increments);
setScale(axisRegion);
}
public double[] getSteps() {
return steps;
}
public void setSteps(double[] steps) {
// sanity checks: no null, 0 or negative
if (steps == null || steps.length == 0)
return;
for (double step : steps) {
if (step <= 0.0d)
return;
}
this.steps = steps;
}
public Region getScale() {
return scale;
}
public void setScale(Region scale) {
this.scale = scale;
}
// does not return StepModel.value instead calculates best fit
@Override
public double getValue() {
// no possible increments where supplied
// or no region defined
if (steps == null || scale == null || !scale.isDefined())
return super.getValue();
double curStep = steps[0];
double oldDistance = Math.abs((scale.length().doubleValue() / curStep)-super.getValue() );
// determine which step size comes closest to the desired number of steps
// since steps[] is a small array brute force search is ok
for (double step : steps) {
double newDistance = Math.abs((scale.length().doubleValue() / step)-super.getValue() );
// closer than previous stepping?
if (newDistance < oldDistance){
curStep = step;
oldDistance = newDistance;
}
}
return curStep;
}
@Override
public String toString() {
return "StepModelFit{" +
"steps=" + Arrays.toString(steps) +
", scale=" + scale +
", current stepping=" + getValue() +
'}';
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/StepRenderer.java 0000664 0000000 0000000 00000002264 13065526371 0030754 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
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.4.2/androidplot-core/src/main/java/com/androidplot/xy/ValueMarker.java 0000664 0000000 0000000 00000007410 13065526371 0030566 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XValueMarker.java 0000664 0000000 0000000 00000003604 13065526371 0030717 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYConstraints.java 0000664 0000000 0000000 00000011106 13065526371 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;
/**
* 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYCoords.java 0000664 0000000 0000000 00000001554 13065526371 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;
/**
* 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYFramingModel.java 0000664 0000000 0000000 00000001333 13065526371 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;
public enum XYFramingModel {
ORIGIN,
EDGE,
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYGraphWidget.java 0000664 0000000 0000000 00000121114 13065526371 0031034 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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);
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 {
NONE(0),
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);
// rotation
AttrUtils.configureWidgetRotation(attrs, this, R.styleable.xy_XYPlot_graphRotation);
// padding & margin
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 screenToSeriesY(float)
* This is a relatively slow operation and should not be used for operations that are a part of
* the main render loop of a dynamic plot.
*
* @param point
* @return
*/
protected XYCoords screenToSeries(PointF point) {
if(!plot.getBounds().isFullyDefined()) {
return null;
}
return new RectRegion(gridRect)
.transform(point.x, point.y, plot.getBounds(), false, true);
}
/**
* Convenience method. Wraps screenToSeriesX(float)
* This is a relatively slow operation and should not be used for operations that are a part of
* the main render loop of a dynamic plot.
*
* @param point
* @return
*/
protected Number screenToSeriesX(PointF point) {
return screenToSeriesX(point.x);
}
/**
* Convenience method. Wraps screenToSeriesY(float)
* This is a relatively slow operation and should not be used for operations that are a part of
* the main render loop of a dynamic plot.
*
* @param point
* @return
*/
protected Number screenToSeriesY(PointF point) {
return screenToSeriesY(point.y);
}
/**
* Converts an x pixel into an x value.
* This is a relatively slow operation and should not be used for operations that are a part of
* the main render loop of a dynamic plot.
*
* @param xPix
* @return
*/
protected Number screenToSeriesX(float xPix) {
if (!plot.getBounds().xRegion.isDefined()) {
return null;
}
return new Region(gridRect.left, gridRect.right)
.transform(xPix, plot.getBounds().getxRegion());
}
/**
* Converts a y pixel to a y value.
* This is a relatively slow operation and should not be used for operations that are a part of
* the main render loop of a dynamic plot.
* @param yPix
* @return
*/
protected Number screenToSeriesY(float yPix) {
if (!plot.getBounds().getyRegion().isDefined()) {
return null;
}
return new Region(gridRect.top, gridRect.bottom)
.transform(yPix, plot.getBounds().getyRegion(), true);
}
protected PointF seriesToScreen(XYCoords xy) {
if(!plot.getBounds().isFullyDefined()) {
return null;
}
return plot.getBounds().transform(xy, gridRect, false, true);
}
protected float seriesToScreenX(Number x) {
return (float) plot.getBounds().getxRegion().
transform(x.doubleValue(), gridRect.left, gridRect.right, false);
}
protected float seriesToScreenY(Number y) {
return (float) plot.getBounds().getyRegion().
transform(y.doubleValue(), gridRect.left, gridRect.right, true);
}
@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 grid and domain/range labels for the plot.
*
* @param canvas
*/
protected void drawGrid(Canvas canvas) {
if(!drawGridOnTop) {
drawGridBackground(canvas);
}
Number domainOrigin = plot.getDomainOrigin();
double domainOriginPix;
if (domainOrigin != null) {
domainOriginPix = 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:
domainOriginPix = gridRect.left;
domainOrigin=plot.getBounds().getMinX();
}
Step domainStep = XYStepCalculator.getStep(plot, Axis.DOMAIN, gridRect);
// draw domain origin:
if (domainOriginPix >= gridRect.left
&& domainOriginPix <= gridRect.right) {
drawDomainLine(canvas, (float) domainOriginPix,
domainOrigin, domainOriginLinePaint, true);
}
// draw lines LEFT of origin:
double xPix = domainOriginPix - domainStep.getStepPix();
for (int i = ONE; xPix >= gridRect.left - FUDGE; xPix = domainOriginPix
- (i * domainStep.getStepPix())) {
double xVal = domainOrigin.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 = domainOriginPix + domainStep.getStepPix();
for (int i = ONE; xPix <= gridRect.right + FUDGE; xPix = domainOriginPix
+ (i * domainStep.getStepPix())) {
double xVal = domainOrigin.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++;
}
Number rangeOrigin = plot.getRangeOrigin();
double rangeOriginPix;
if (rangeOrigin != null) {
rangeOriginPix = plot.getBounds().getyRegion().transform(
rangeOrigin.doubleValue(), gridRect.top, gridRect.bottom, true);
} else {
// if no range origin is set, use the bottom-most value visible on the grid:
rangeOriginPix = gridRect.bottom;
rangeOrigin = plot.getBounds().getMinY();
}
Step rangeStep = XYStepCalculator.getStep(plot, Axis.RANGE, gridRect);
// draw range origin:
if (rangeOriginPix >= gridRect.top && rangeOriginPix <= gridRect.bottom) {
drawRangeLine(canvas, (float) rangeOriginPix,
rangeOrigin, rangeOriginLinePaint, true);
}
final double rangeStepPix = rangeStep.getStepPix();
// draw lines ABOVE origin:
double yPix = rangeOriginPix - rangeStep.getStepPix();
for (int i = ONE; yPix >= gridRect.top - FUDGE; yPix = rangeOriginPix - (i * rangeStepPix)) {
double yVal = rangeOrigin.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 = rangeOriginPix + rangeStep.getStepPix();
for (int i = ONE; yPix <= gridRect.bottom + FUDGE; yPix = rangeOriginPix + (i * rangeStepPix)) {
double yVal = rangeOrigin.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 != 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 != null
&& rangeCursorPosition >= gridRect.top
&& rangeCursorPosition <= gridRect.bottom) {
hasRangeCursor = true;
canvas.drawLine(gridRect.left, rangeCursorPosition,
gridRect.right, rangeCursorPosition, rangeCursorPaint);
}
if(getCursorLabelFormatter() != null && hasRangeCursor && hasDomainCursor) {
drawCursorLabel(canvas);
}
}
protected void drawCursorLabel(Canvas canvas) {
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;
}
/**
* Set domain and range cursor position using screen coordinates
* @param x
* @param y
*/
public void setCursorPosition(Float x, Float y) {
setDomainCursorPosition(x);
setRangeCursorPosition(y);
}
/**
* Set domain and range cursor position using screen coordinates
* @param point
*/
public void setCursorPosition(PointF point) {
setCursorPosition(point.x, point.y);
}
public Float getDomainCursorPosition() {
return domainCursorPosition;
}
public Number getDomainCursorVal() {
return screenToSeriesX(getDomainCursorPosition());
}
/**
* Set domain cursor position using screen coordinates
* @param domainCursorPosition
*/
public void setDomainCursorPosition(Float domainCursorPosition) {
this.domainCursorPosition = domainCursorPosition;
}
public Float getRangeCursorPosition() {
return rangeCursorPosition;
}
public Number getRangeCursorVal() {
return screenToSeriesY(getRangeCursorPosition());
}
/**
* Set range cursor position using screen coordinates
* @param rangeCursorPosition
*/
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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYLegendWidget.java 0000664 0000000 0000000 00000021655 13065526371 0031202 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.*;
import com.androidplot.ui.LayoutManager;
import com.androidplot.ui.SeriesBundle;
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);
}
// protected List> getLegendEnabledSeriesAndFormatterList() {
// List> sfList = new ArrayList<>();
// ListIterator> it = plot.getSeriesRegistry().listIterator();
// while(it.hasNext()) {
// SeriesAndFormatter thisSf = it.next();
// if(thisSf.getFormatter().isLegendIconEnabled()) {
// sfList.add(thisSf);
// }
// }
// return sfList;
// }
@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.getRegistry().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(SeriesBundle sfPair : plot.getRegistry().getLegendEnabledItems()) {
//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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYPlot.java 0000664 0000000 0000000 00000120066 13065526371 0027552 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.*;
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();
// min/max used for displaying data
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;
/**
* The inner and outer limits define a kind of picture-frame shape area that is used as the valid
* region for setting domain/range boundaries. If the set boundaries exceed one of these limits
* then the limit value is used instead of the boundary. This is most commonly used to constrain
* panning & zooming to a specific range on both axes.
*/
private final RectRegion innerLimits = new RectRegion();
private final RectRegion outerLimits = new RectRegion();
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);
calculateMinMaxVals();
// 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.
getRegistry().estimate(this); // TODO: clean this mechanism up!!!
}
/**
* 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);
}
/**
* Convert a screen xVal into a series xVal.
* @param xPix
* @return
* @deprecated Use {@link #screenToSeriesY(float)}.
*/
@Deprecated
public Number getXVal(float xPix) {
return getGraph().screenToSeriesX(xPix);
}
/**
* Convert a screen yVal into a series yVal.
* @param yPix
* @return
* @deprecated Use {@link #screenToSeriesY(float)}.
*/
public Number getYVal(float yPix) {
return getGraph().screenToSeriesY(yPix);
}
/**
* Convert the y coord of a PointF into a series yVal.
* @param point
* @return
* @deprecated Use {@link #screenToSeriesY(float)}.
*/
@Deprecated
public Number getYVal(PointF point) {
return getGraph().screenToSeriesY(point);
}
/**
* Convert the x coord of a PointF into a series xVal.
* @param point
* @return
* @deprecated Use {@link #screenToSeriesY(float)}.
*/
@Deprecated
public Number getXVal(PointF point) {
return getGraph().screenToSeriesX(point);
}
public Number screenToSeriesX(float x) {
return getGraph().screenToSeriesX(x);
}
public Number screenToSeriesY(float y) {
return getGraph().screenToSeriesY(y);
}
/**
* Convert a series xVal into a screen x coord
* @param x
* @return
*/
public float seriesToScreenX(Number x) {
return getGraph().seriesToScreenX(x);
}
/**
* Convert a series yVal into a screen y coord
* @param y
* @return
*/
public float seriesToScreenY(Number y) {
return getGraph().seriesToScreenY(y);
}
/**
* Convert a series xy value into a screen point.
* @param xy
* @return
*/
public PointF seriesToScreen(XYCoords xy) {
return getGraph().seriesToScreen(xy);
}
/**
* Convert a screen point into a series xy value.
* @param point
* @return
*/
public XYCoords screentoSeries(PointF point) {
return getGraph().screenToSeries(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, getRegistry().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()),
innerLimits.getMaxX(), outerLimits.getMaxX()));
bounds.setMinX(applyUserMinMax(getCalculatedLowerBoundary(
constraints.getDomainLowerBoundaryMode(),
prevMinX, bounds.getMinX()),
outerLimits.getMinX(), innerLimits.getMinX()));
break;
default:
throw new UnsupportedOperationException(
"Domain Framing Model not yet supported: " + constraints.getDomainFramingModel());
}
switch (constraints.getRangeFramingModel()) {
case ORIGIN:
updateRangeMinMaxForOriginModel();
break;
case EDGE:
if (getRegistry().size() > 0) {
bounds.setMaxY(applyUserMinMax(getCalculatedUpperBoundary(
constraints.getRangeUpperBoundaryMode(),
prevMaxY, bounds.getMaxY()), innerLimits.getMaxY(), outerLimits.getMaxY()));
bounds.setMinY(applyUserMinMax(getCalculatedLowerBoundary(
constraints.getRangeLowerBoundaryMode(),
prevMinY, bounds.getMinY()), outerLimits.getMinY(), innerLimits.getMinY()));
}
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 getInnerLimits() {
return innerLimits;
}
public RectRegion getOuterLimits() {
return outerLimits;
}
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;
}
@Override
protected XYSeriesRegistry getRegistryInstance() {
XYSeriesRegistry registry = new XYSeriesRegistry();
return registry;
}
} androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYRegionFormatter.java 0000664 0000000 0000000 00000003574 13065526371 0031747 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYSeries.java 0000664 0000000 0000000 00000002561 13065526371 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesBundle.java 0000664 0000000 0000000 00000000451 13065526371 0031213 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import com.androidplot.ui.*;
/**
* Created by halfhp on 10/6/16.
*/
public class XYSeriesBundle extends SeriesBundle {
public XYSeriesBundle(XYSeries series, XYSeriesFormatter formatter) {
super(series, formatter);
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesFormatter.java 0000664 0000000 0000000 00000005400 13065526371 0031744 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesRegistry.java 0000664 0000000 0000000 00000001654 13065526371 0031620 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
import com.androidplot.*;
/**
* Maintains the "registry" of mappings of XYSeries instances and their associated formatters.
*/
public class XYSeriesRegistry extends SeriesRegistry {
private Estimator estimator;
public void estimate(XYPlot plot) {
if(estimator != null) {
for (XYSeriesBundle sf : getSeriesAndFormatterList()) {
getEstimator().run(plot, sf);
}
}
}
@Override
protected XYSeriesBundle newSeriesBundle(XYSeries series, XYSeriesFormatter formatter) {
return new XYSeriesBundle(series, formatter);
}
/**
*
* @return The currently active Estimator, or null if none is set.
*/
public Estimator getEstimator() {
return estimator;
}
public void setEstimator(Estimator estimator) {
this.estimator = estimator;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYSeriesRenderer.java 0000664 0000000 0000000 00000003607 13065526371 0031556 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import com.androidplot.ui.SeriesBundle;
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(SeriesBundle 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.4.2/androidplot-core/src/main/java/com/androidplot/xy/XYStepCalculator.java 0000664 0000000 0000000 00000005535 13065526371 0031564 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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:
case INCREMENT_BY_FIT:
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.4.2/androidplot-core/src/main/java/com/androidplot/xy/YValueMarker.java 0000664 0000000 0000000 00000003623 13065526371 0030721 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.xy;
import android.graphics.Paint;
import com.androidplot.ui.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.4.2/androidplot-core/src/main/java/com/androidplot/xy/ZoomEstimator.java 0000664 0000000 0000000 00000001716 13065526371 0031167 0 ustar 00root root 0000000 0000000 package com.androidplot.xy;
/**
* Estimates optimal zoom level to be applied to a {@link SampledXYSeries} based on the current
* visible bounds of the owning {@link XYPlot}.
*/
public class ZoomEstimator extends Estimator {
@Override
public void run(XYPlot plot, XYSeriesBundle sf) {
if(sf.getSeries() instanceof SampledXYSeries) {
SampledXYSeries oxy = (SampledXYSeries) sf.getSeries();
final double factor = calculateZoom(oxy, plot.getBounds());
oxy.setZoomFactor(factor);
}
}
protected double calculateZoom(SampledXYSeries series, RectRegion visibleBounds) {
RectRegion seriesBounds = series.getBounds();
final double ratio = seriesBounds.getxRegion().ratio(visibleBounds.getxRegion()).doubleValue();
final double maxFactor = series.getMaxZoomFactor();
final double factor = Math.abs(Math.round(maxFactor / ratio));
return factor > 0 ? factor : 1;
}
}
androidplot-1.4.2/androidplot-core/src/main/java/com/androidplot/xy/package-info.java 0000664 0000000 0000000 00000000176 13065526371 0030676 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.4.2/androidplot-core/src/main/res/ 0000775 0000000 0000000 00000000000 13065526371 0021616 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/main/res/values/ 0000775 0000000 0000000 00000000000 13065526371 0023115 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/main/res/values/attrs.xml 0000664 0000000 0000000 00000044101 13065526371 0024774 0 ustar 00root root 0000000 0000000
androidplot-1.4.2/androidplot-core/src/main/res/values/color.xml 0000664 0000000 0000000 00000001742 13065526371 0024761 0 ustar 00root root 0000000 0000000
#00000000
#000
#111
#FFF
#EEE
#888
androidplot-1.4.2/androidplot-core/src/main/res/values/style.xml 0000664 0000000 0000000 00000015436 13065526371 0025010 0 ustar 00root root 0000000 0000000
androidplot-1.4.2/androidplot-core/src/test/ 0000775 0000000 0000000 00000000000 13065526371 0021060 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/test/java/ 0000775 0000000 0000000 00000000000 13065526371 0022001 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/test/java/com/ 0000775 0000000 0000000 00000000000 13065526371 0022557 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/test/java/com/androidplot/ 0000775 0000000 0000000 00000000000 13065526371 0025076 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/test/java/com/androidplot/PlotTest.java 0000664 0000000 0000000 00000031001 13065526371 0027512 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 android.util.*;
import com.androidplot.exception.PlotRenderException;
import com.androidplot.test.*;
import com.androidplot.ui.*;
import com.halfhp.fig.*;
import org.junit.Test;
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;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
public class PlotTest extends AndroidplotTest {
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 doGetRendererInstance(MockPlot plot) {
return new MockRenderer1(plot);
}
}
static class MockFormatter2 extends Formatter {
@Override
public Class getRendererClass() {
return MockRenderer2.class;
}
@Override
public SeriesRenderer doGetRendererInstance(MockPlot plot) {
return new MockRenderer2(plot);
}
}
public static class MockSeriesBundle extends SeriesBundle {
public MockSeriesBundle(MockSeries series, Formatter formatter) {
super(series, formatter);
}
}
public static class MockPlot extends Plot> {
public MockPlot(String title) {
super(RuntimeEnvironment.application, title);
}
@Override
protected SeriesRegistry getRegistryInstance() {
return new SeriesRegistry() {
@Override
protected MockSeriesBundle newSeriesBundle(
MockSeries series, Formatter formatter) {
return new MockSeriesBundle(series, formatter);
}
};
}
@Override
protected void onPreInit() {
}
@Override
protected void processAttrs(TypedArray attrs) {
}
}
@Test
public void testInit_withoutAttrs() throws Exception {
Plot plot = mock(Plot.class);
plot.init(RuntimeEnvironment.application, null, 0);
verify(plot, times(1)).onPreInit();
verify(plot, times(1)).onAfterConfig();
}
@Test
public void testInit_withAttrs() throws Exception {
Plot plot = new MockPlot("MockPlot");
AttributeSet attrs = mock(AttributeSet.class);
plot.init(RuntimeEnvironment.application, attrs, 0);
// TODO: verifications
}
@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.getRegistry().size());
// a new copy of m1 is added:
plot.addSeries(m1, new MockFormatter1());
assertEquals(1, plot.getRenderers().size());
assertEquals(2, 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 3 in the subregistry:
assertEquals(3, 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 run:
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 run:
assertEquals(2, plot.getRendererList().size());
assertEquals(6, 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(4, 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.4.2/androidplot-core/src/test/java/com/androidplot/RegionTest.java 0000664 0000000 0000000 00000010627 13065526371 0030032 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.assertNotSame;
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().doubleValue(), 0);
assertEquals(0d, lr.getMax().doubleValue(), 0);
lr = new Region(1.5d, -2d);
assertEquals(-2f, lr.getMin().floatValue(), 0);
assertEquals(1.5f, lr.getMax().floatValue(), 0);
lr = new Region(10d, 20d);
assertEquals(10l, lr.getMin().longValue(), 0);
assertEquals(20l, lr.getMax().longValue(), 0);
}
@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));
r1 = new Region(0f, 21402646f);
r2 = new Region(0, 999);
//assertTrue(r2.ratio(r1).doubleValue() > 0);
}
@Test
public void testRegionRegionUnion() throws Exception {
Region r1 = new Region(1, 2);
Region r2 = new Region(0, 100);
r1.union(r2);
assertEquals(0, r1.getMin().doubleValue(), 0);
assertEquals(100, r1.getMax().doubleValue(), 0);
}
@Test
public void testRegionPointUnion() throws Exception {
Region r1 = new Region(1, 2);
r1.union(0);
assertEquals(0, r1.getMin().doubleValue(), 0);
assertEquals(2, r1.getMax().doubleValue(), 0);
r1.union(100);
assertEquals(0, r1.getMin().doubleValue(), 0);
assertEquals(100, r1.getMax().doubleValue(), 0);
}
}
androidplot-1.4.2/androidplot-core/src/test/java/com/androidplot/SeriesRegistryTest.java 0000664 0000000 0000000 00000010221 13065526371 0031560 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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 com.androidplot.test.AndroidplotTest;
import com.androidplot.ui.Formatter;
import com.androidplot.xy.BarFormatter;
import com.androidplot.xy.LineAndPointFormatter;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.xy.XYSeriesRegistry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
public class SeriesRegistryTest extends AndroidplotTest {
SeriesRegistry seriesRegistry;
@Before
public void setUp() throws Exception {
seriesRegistry = new XYSeriesRegistry();
}
@After
public void tearDown() throws Exception {
}
@Test
public void testAdd() {
assertEquals(0, seriesRegistry.size());
seriesRegistry.add(new SimpleXYSeries("s1"), new LineAndPointFormatter());
assertEquals(1, seriesRegistry.size());
}
@Test
public void testAdd_failsOnNullArgument() throws Exception {
try {
seriesRegistry.add(null, null);
fail("IllegalArgumentException expected.");
} catch(IllegalArgumentException e) {
// expected
}
try {
seriesRegistry.add(new SimpleXYSeries("s1"), null);
fail("IllegalArgumentException expected.");
} catch(IllegalArgumentException e) {
// expected
}
try {
seriesRegistry.add(null, new LineAndPointFormatter());
fail("IllegalArgumentException expected.");
} catch(IllegalArgumentException e) {
// expected
}
}
@Test
public void testGet() {
Series s1 = new SimpleXYSeries("s1");
Formatter f1 = new LineAndPointFormatter();
Series s2 = new SimpleXYSeries("s2");
Formatter f2 = new LineAndPointFormatter();
Formatter f3 = new LineAndPointFormatter();
seriesRegistry.add(s1, f1);
seriesRegistry.add(s1, f3);
seriesRegistry.add(s2, f2);
assertEquals(2, seriesRegistry.get(s1).size());
assertEquals(1, seriesRegistry.get(s2).size());
}
@Test
public void testRemove() {
Series series = new SimpleXYSeries("s1");
seriesRegistry.add(series, new LineAndPointFormatter());
assertEquals(1, seriesRegistry.size());
seriesRegistry.remove(new SimpleXYSeries("s2"));
assertEquals(1, seriesRegistry.size());
seriesRegistry.remove(series);
assertEquals(0, seriesRegistry.size());
}
@Test
public void testClear() {
seriesRegistry.add(new SimpleXYSeries("s1"), new LineAndPointFormatter());
seriesRegistry.add(new SimpleXYSeries("s2"), new LineAndPointFormatter());
assertEquals(2, seriesRegistry.size());
seriesRegistry.clear();
assertEquals(0, seriesRegistry.size());
}
@Test
public void testContains() {
Series s1 = new SimpleXYSeries("s1");
Series s2 = new SimpleXYSeries("s1");
Series s3 = new SimpleXYSeries("s1");
seriesRegistry.add(s1, new LineAndPointFormatter());
seriesRegistry.add(s2, new LineAndPointFormatter());
assertTrue(seriesRegistry.contains(s1, LineAndPointFormatter.class));
assertFalse(seriesRegistry.contains(s1, BarFormatter.class));
assertTrue(seriesRegistry.contains(s2, LineAndPointFormatter.class));
assertFalse(seriesRegistry.contains(s3, LineAndPointFormatter.class));
}
}
androidplot-1.4.2/androidplot-core/src/test/java/com/androidplot/pie/ 0000775 0000000 0000000 00000000000 13065526371 0025653 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/test/java/com/androidplot/pie/PieRendererTest.java 0000664 0000000 0000000 00000015453 13065526371 0031572 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.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 junit.framework.Assert.assertEquals;
import static junit.framework.Assert.fail;
import static org.mockito.Mockito.*;
public class PieRendererTest extends AndroidplotTest {
RectF plotArea = new RectF(0, 0, 100, 100);
@Mock
LayoutManager layoutManager;
PieChart pieChart;
@Mock
TypedArray typedArray;
@Mock
SeriesRegistry seriesRegistry;
@Mock
RenderStack renderStack;
Canvas canvas;
@Before
public void setUp() throws Exception {
pieChart = spy(new PieChart(getContext(), "My Pie"));
canvas = spy(new Canvas());
}
@Test
public void testDrawSegment_withoutTextPaintDoesntDrawLabel() throws Exception {
PieRenderer pieRenderer = spy(new PieRenderer(pieChart));
Segment segment = spy(new Segment("My Segment", 100));
SegmentFormatter formatterWithoutTextPaint = new SegmentFormatter(Color.GREEN);
formatterWithoutTextPaint.setLabelPaint(null);
pieRenderer.drawSegment(
new Canvas(),
plotArea,
segment,
formatterWithoutTextPaint,
100, 100, 100);
SegmentFormatter formatterWithTextPaint = new SegmentFormatter(Color.GREEN);
pieRenderer.drawSegment(
canvas,
plotArea,
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));
}
@Test
public void testOnRender() throws Exception {
Segment segment = spy(new Segment("My Segment", 100));
SegmentFormatter formatter = spy(
new SegmentFormatter(Color.GREEN, Color.GREEN, Color.GREEN, Color.GREEN));
PieRenderer pr = formatter.getRendererInstance(pieChart);
PieRenderer renderer = spy(pr);
doReturn(renderer.getClass()).when(formatter).getRendererClass();
doReturn(renderer).when(formatter).getRendererInstance(any(PieChart.class));
pieChart.addSegment(segment, formatter);
renderer.onRender(canvas, plotArea, segment, formatter, renderStack);
}
@Test
public void testGetContainingSegment() throws Exception {
Segment segment1 = spy(new Segment("s1", 25));
Segment segment2 = spy(new Segment("s2", 25));
Segment segment3 = spy(new Segment("s3", 25));
Segment segment4 = spy(new Segment("s4", 25));
SegmentFormatter formatter = spy(
new SegmentFormatter(Color.GREEN, Color.GREEN, Color.GREEN, Color.GREEN));
PieRenderer renderer = formatter.getRendererInstance(pieChart);
pieChart.addSegment(segment1, formatter);
pieChart.addSegment(segment2, formatter);
pieChart.addSegment(segment3, formatter);
pieChart.addSegment(segment4, formatter);
// southeast
assertEquals(segment1, renderer.getContainingSegment(new PointF(100, 100)));
// southwest
assertEquals(segment2, renderer.getContainingSegment(new PointF(0, 100)));
// northwest
assertEquals(segment3, renderer.getContainingSegment(new PointF(0, 0)));
// northeast
assertEquals(segment4, renderer.getContainingSegment(new PointF(100, 0)));
renderer.setStartDegs(90);
// southeast
assertEquals(segment2, renderer.getContainingSegment(new PointF(100, 100)));
// southwest
assertEquals(segment3, renderer.getContainingSegment(new PointF(0, 100)));
// northwest
assertEquals(segment4, renderer.getContainingSegment(new PointF(0, 0)));
// northeast
assertEquals(segment1, renderer.getContainingSegment(new PointF(100, 0)));
}
@Test
public void testDegsToScreenDegs() throws Exception {
assertEquals(0f, PieRenderer.degsToScreenDegs(0));
assertEquals(359f, PieRenderer.degsToScreenDegs(1));
assertEquals(271f, PieRenderer.degsToScreenDegs(89));
assertEquals(270f, PieRenderer.degsToScreenDegs(90));
assertEquals(269f, PieRenderer.degsToScreenDegs(91));
assertEquals(181f, PieRenderer.degsToScreenDegs(179));
assertEquals(180f, PieRenderer.degsToScreenDegs(180));
assertEquals(179f, PieRenderer.degsToScreenDegs(181));
assertEquals(91f, PieRenderer.degsToScreenDegs(269));
assertEquals(90f, PieRenderer.degsToScreenDegs(270));
assertEquals(89f, PieRenderer.degsToScreenDegs(271));
assertEquals(1f, PieRenderer.degsToScreenDegs(359));
assertEquals(0f, PieRenderer.degsToScreenDegs(360));
}
@Test
public void testSetDonutSize() throws Exception {
Segment segment1 = spy(new Segment("s1", 25));
Segment segment2 = spy(new Segment("s2", 25));
Segment segment3 = spy(new Segment("s3", 25));
Segment segment4 = spy(new Segment("s4", 25));
SegmentFormatter formatter = spy(
new SegmentFormatter(Color.GREEN, Color.GREEN, Color.GREEN, Color.GREEN));
PieRenderer renderer = formatter.getRendererInstance(pieChart);
pieChart.addSegment(segment1, formatter);
pieChart.addSegment(segment2, formatter);
pieChart.addSegment(segment3, formatter);
pieChart.addSegment(segment4, formatter);
renderer.setDonutSize(0.25f, PieRenderer.DonutMode.PERCENT);
renderer.onRender(canvas, plotArea, segment1, formatter, renderStack);
// TODO: verify radials are drown at the correct offsets from center
//verify(canvas).drawLine(anyFloat(), anyFloat(), anyFloat(), anyFloat(), any(Paint.class));
}
}
androidplot-1.4.2/androidplot-core/src/test/java/com/androidplot/test/ 0000775 0000000 0000000 00000000000 13065526371 0026055 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/test/java/com/androidplot/test/AndroidplotTest.java 0000664 0000000 0000000 00000003131 13065526371 0032035 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/test/java/com/androidplot/test/MyTestRunner.java 0000664 0000000 0000000 00000000624 13065526371 0031341 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.4.2/androidplot-core/src/test/java/com/androidplot/test/TestUtils.java 0000664 0000000 0000000 00000003526 13065526371 0030666 0 ustar 00root root 0000000 0000000 package com.androidplot.test;
import android.annotation.*;
import android.view.*;
import com.androidplot.xy.*;
import org.robolectric.shadows.*;
import static org.robolectric.Shadows.shadowOf;
/**
* Utilities to help with unit testing
*/
public abstract class TestUtils {
public static XYSeries generateXYSeries(String title, int size) {
return generateXYSeries(title, size, 0, 1);
}
/**
* Generate a series of random numbers within a min/max range
* @param title
* @param size
* @param min
* @param max
* @return
*/
public static XYSeries generateXYSeries(String title, int size, double min, double max) {
SimpleXYSeries series = new SimpleXYSeries(title);
for(int i = 0; i < size; i++) {
series.addLast(i, Math.random() * max - min);
}
return series;
}
public static XYSeries generateXYSeriesWithNulls(String title, int size) {
SimpleXYSeries series = new SimpleXYSeries(title);
for(int i = 0; i < size; i++) {
if(Math.random() > 0.5) {
series.addLast(i, null);
} else {
series.addLast(i, Math.random());
}
}
return series;
}
/**
* Generate a two finger {@link MotionEvent}.
* @param finger1x
* @param finger1y
* @param finger2x
* @param finger2y
* @return
*/
@SuppressLint("NewApi")
public static MotionEvent newPointerDownEvent(int finger1x, int finger1y, int finger2x, int finger2y) {
MotionEvent me = MotionEvent.obtain(0, 0, 0, 0, 0, 0);
ShadowMotionEvent sme = shadowOf(me);
sme.setAction(MotionEvent.ACTION_POINTER_DOWN);
sme.setPointerIds(0, 1);
sme.setLocation(finger1x, finger1y);
sme.setPointer2(finger2x, finger2y);
return me;
}
}
androidplot-1.4.2/androidplot-core/src/test/java/com/androidplot/ui/ 0000775 0000000 0000000 00000000000 13065526371 0025513 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/test/java/com/androidplot/ui/DynamicTableModelTest.java 0000664 0000000 0000000 00000017753 13065526371 0032550 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS 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.4.2/androidplot-core/src/test/java/com/androidplot/ui/FixedTableModelTest.java 0000664 0000000 0000000 00000020016 13065526371 0032205 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.androidplot.ui;
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 
**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](docs/contributing.md)
# 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.4.2/_config.yml 0000664 0000000 0000000 00000000033 13065526371 0016170 0 ustar 00root root 0000000 0000000 theme: jekyll-theme-minimal androidplot-1.4.2/androidplot-core/ 0000775 0000000 0000000 00000000000 13065526371 0017312 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/build.gradle 0000664 0000000 0000000 00000010240 13065526371 0021566 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 AndroidPlot.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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
}
buildToolsVersion '25.0.0'
}
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.4.2/androidplot-core/src/ 0000775 0000000 0000000 00000000000 13065526371 0020101 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/main/ 0000775 0000000 0000000 00000000000 13065526371 0021025 5 ustar 00root root 0000000 0000000 androidplot-1.4.2/androidplot-core/src/main/AndroidManifest.xml 0000664 0000000 0000000 00000001565 13065526371 0024625 0 ustar 00root root 0000000 0000000