菜单和文本菜单的aChartengine图 [英] Menu and a ContextMenu for a aChartengine chart
本文介绍了菜单和文本菜单的aChartengine图的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
这可能吗？已经有人在做这之前？我不知道从哪里开始。
我大多需要的菜单，没有上下文菜单。
我的BudgetPieChart级
公共类ExpensesByCategoriesPieChart扩展AbstractChart {
私人DataToArray DTA;
@覆盖
公共字符串的getName（）{
返回MyApplication.getContext（）的getString（R.string.ExpensesByCategoriesPieChartName）。
}
@覆盖
公共字符串getDesc（）{
返回每个项目的预算，今年（饼图）的;
}
@覆盖
公共意图执行（上下文的背景下）{
DTA =新DataToArray（）;
的String []类别= dta.expenseByCategoriesToArray（）;
双[]值= dta.expensesValuesByCategoriesToArray（）;
INT []颜色= dta.getColorsArray（categories.length）;
DefaultRenderer渲染= buildCategoryRenderer（颜色）;
renderer.setZoomButtonsVisible（真正的）;
renderer.setZoomEnabled（真正的）;
renderer.setChartTitleTextSize（20）;
返回ChartFactory.getPieChartIntent（背景下，buildCategoryDataset（Wydatki kategoriami，类别，值），渲染器，Wydatki）;
}
公共CustomGraphicalView CreateView的（
CustomGraphicalView customGraphicalView）{
//我该怎么办吗？
返回null;
}
}
解决方案
行，所以在这儿呢。在我的情况CustomGraphicalView延伸org.achartengine.GraphicalView，但你可以扩展任何类，你所需要的。
私人CustomGraphicalView mGraphicalView =新BudgetPieChart（）CreateView的（这一点）。 //编辑CreateView的（）与图形输入数据
私人RelativeLayout的chart_layout =（RelativeLayout的）findViewById（R.id.chart_layout）;
android.widget.RelativeLayout.LayoutParams参数=新RelativeLayout.LayoutParams（宽，高）;
chart_layout.setGravity（Gravity.CENTER）;
chart_layout.addView（mGraphicalView，参数）;
公共CustomGraphicalView CreateView的（上下文的背景下）{
双[]值=新的双[] {10，20，30，40，50，60，70，80，90，100}; //你的期望值
INT []颜色=新INT [] {// Color.BLUE，Color.GREEN，Color.MAGENTA，Color.YELLOW，Color.CYAN（你想要的颜色）
Color.parseColor（＃ff3399ff），Color.parseColor（＃ff0066cc），Color.parseColor（＃ff613592），Color.parseColor（＃ff7d3493），Color.parseColor（＃ffe81f53）， Color.parseColor（＃ffeb5531），Color.parseColor（＃fff6bb2d），Color.parseColor（＃fff39f2f），Color.parseColor（＃ffe0d347），Color.parseColor（＃ff78c200）} ;
//记住有足够的颜色，以元件的数量从数据阵列为每个扇形匹配
DefaultRenderer渲染= buildCategoryRenderer（颜色）;
renderer.setZoomButtonsVisible（假）;
renderer.setZoomEnabled（假）;
renderer.setChartTitleTextSize（20）;
renderer.setAntialiasing（真正的）;
renderer.setApplyBackgroundColor（假）;
renderer.setBackgroundColor（Color.TRANSPARENT）;
renderer.setPanEnabled（假）;
renderer.setShowLabels（假）;
renderer.setShowLegend（假）;
返回CustomChartFactory.getPieChartView（背景下，buildCategoryDataset（项目预算，值），渲染器）;
}
@覆盖
公共意图执行（背景为arg0）{
// 不曾用过
返回null;
}
公共类CustomChartFactory {
/ **的关键图表数据。 * /
公共静态最后弦乐CHART =图表;
/ **的关键图表图形活动称号。 * /
公共静态最后弦乐TITLE =称号;
私人CustomChartFactory（）{
//空的现在
}
/ **
*创建可用于启动图形视图活性的饼图意图。
*
* @参数方面
*上下文
* @参数数据集
*类别系列数据集（不能为空）
* @参数渲染器
*该系列渲染器（不能为空）
返回：饼图视图
* @throws抛出：IllegalArgumentException
*如果数据集为空或渲染器为null，或者项目的数据集数比的系列渲染器的数量不同
* /
公共静态最终CustomGraphicalView getPieChartView（上下文的背景下，CategorySeries数据集，DefaultRenderer渲染器）{
checkParameters（数据集，渲染器）;
CustomPieChart图=新CustomPieChart（数据集，渲染器）;
返回新CustomGraphicalView（上下文，图表）;
}
/ **
*检查数据集和渲染器参数的有效性。
*
* @参数数据集
*类别系列数据集（不能为空）
* @参数渲染器
*该系列渲染器（不能为空）
* @throws抛出：IllegalArgumentException
*如果数据集为空或渲染器为null，或者项目的数据集数比的系列渲染器的数量不同
* /
私有静态无效checkParameters（CategorySeries数据集，DefaultRenderer渲染器）{
如果（数据集== NULL ||渲染== NULL || dataset.getItemCount（）！= renderer.getSeriesRendererCount（））{
抛出新抛出：IllegalArgumentException（数据集和渲染应该是不为空和物品的数据集数应等于系列渲染器数量）;
}
}
}
这应该让你与你的项目:)祝你好运走得更远！
公共类CustomGraphicalView扩展org.achartengine.GraphicalView {
/ **要绘制图表。 * /
私人最终AbstractChart mChart;
/ **图表渲染器。 * /
私人DefaultRenderer mRenderer;
/ **视图范围。 * /
私人最终矩形mRect =新的矩形（）;
/ **用户界面线程处理程序。 * /
私人最终处理程序mHandler;
/ **变焦按钮矩形。 * /
私人最终RectF mZoomR =新RectF（）;
/ **的图标缩放。 * /
私人位图zoomInImage;
/ **的缩小图标。 * /
私人位图zoomOutImage;
/ **拟合缩放图标。 * /
私人位图fitZoomImage;
/ **变焦区域大小。 * /
私人最终诠释zoomSize = 50;
/ **变焦按钮的背景颜色。 * /
私有静态最终诠释ZOOM_BUTTONS_COLOR = Color.argb（175，150，150，150）;
/ **刀具变焦。 * /
私人放大mZoomIn;
/ **缩小工具。 * /
私人放大mZoomOut;
/ **的配合缩放工具。 * /
私人FitZoom mFitZoom;
/ **绘制图表时所使用的涂料。 * /
私人最终涂料mPaint =新的油漆（）;
/ **触摸处理器。 * /
私人ITouchHandler mTouchHandler;
/ **旧的x坐标。 * /
私人浮动oldX;
/ **旧y坐标。 * /
私人浮动oldY;
公共布尔isRotating;
私人浮动MX1，MY1，PY1，PX1，MX2，MY2，PY，PX，lastAngle，angle_rotation，旋转;
/ **
*创建一个新的图形视图。
*
* @参数方面
*上下文
* @参数表
*要绘制的图表
* /
公共CustomGraphicalView（上下文的背景下，AbstractChart图）{
超（背景下，图表）;
setOnTouchListener（本）;
mChart =图;
mHandler =新的处理程序（）;
如果（mChart的instanceof XYChart）{
mRenderer =（（XYChart）mChart）.getRenderer（）;
} 其他 {
mRenderer =（（RoundChart）mChart）.getRenderer（）;
}
如果（mRenderer.isZoomButtonsVisible（））{
zoomInImage = BitmapFactory.de codeStream（CustomGraphicalView.class.getResourceAsStream（图像/ zoom_in.png））;
zoomOutImage = BitmapFactory.de codeStream（CustomGraphicalView.class.getResourceAsStream（图像/ zoom_out.png））;
fitZoomImage = BitmapFactory.de codeStream（CustomGraphicalView.class.getResourceAsStream（图像/变焦1.png））;
}
如果（（mRenderer的instanceof XYMultipleSeriesRenderer）及及（（（XYMultipleSeriesRenderer）mRenderer）.getMarginsColor（）== XYMultipleSeriesRenderer.NO_COLOR））{
（（XYMultipleSeriesRenderer）mRenderer）.setMarginsColor（mPaint.getColor（））;
}
如果（（mRenderer.isZoomEnabled（）＆安培;＆安培; mRenderer.isZoomButtonsVisible（））|| mRenderer.isExternalZoomEnabled（））{
mZoomIn =新的缩放（mChart，真实，mRenderer.getZoomRate（））;
mZoomOut =新的缩放（mChart，假的，mRenderer.getZoomRate（））;
mFitZoom =新FitZoom（mChart）;
}
INT版本= 7;
尝试 {
版本= Integer.valueOf（Build.VERSION.SDK）;
}赶上（例外五）{
// 没做什么
}
如果（版本7;）{
mTouchHandler =新TouchHandlerOld（这一点，mChart）;
} 其他 {
mTouchHandler =新TouchHandler（这一点，mChart）;
}
}
/ **
*返回当前一系列的选择对象。
*
返回：该系列选择
* /
@覆盖
公共SeriesSelection getCurrentSeriesAndPoint（）{
返回mChart.getSeriesAndPointForScreenCoordinate（新点（oldX，oldY））;
}
/ **
*变换当前选定的屏幕点到实处。
*
* @参数规模
*规模
返回：当前选定的真实点
* /
@覆盖
公共双[] toRealPoint（int标）{
如果（mChart的instanceof XYChart）{
XYChart图=（XYChart）mChart;
返回chart.toRealPoint（oldX，oldY，规模）;
}
返回null;
}
@覆盖
保护无效的OnDraw（帆布油画）{
// super.onDraw（画布）;
canvas.save（）;
canvas.getClipBounds（mRect）;
INT顶部= mRect.top;
INT左= mRect.left;
INT宽度= mRect.width（）;
INT高= mRect.height（）;
如果（mRenderer.isInScroll（））{
顶= 0;
左边= 0;
宽度= getMeasuredWidth（）;
身高= getMeasuredHeight（）;
}
mChart.draw（帆布，左，上，宽度，高度，mPaint）;
如果（（mRenderer =空）及！＆安培; mRenderer.isZoomEnabled（）＆安培;＆安培; mRenderer.isZoomButtonsVisible（））{
mPaint.setColor（ZOOM_BUTTONS_COLOR）;
// zoomSize = Math.max（zoomSize，Math.min（宽，高）/ 7）;
mZoomR.set（（左+宽） - （zoomSize * 3），（上+高） - （zoomSize * 0.775f），左+宽，顶部+高）;
canvas.drawRoundRect（mZoomR，zoomSize / 3，zoomSize / 3，mPaint）;
浮动buttonY =（上+高） - （zoomSize * 0.625f）;
canvas.drawBitmap（zoomInImage，（左+宽） - （zoomSize * 2.75f），buttonY，NULL）;
canvas.drawBitmap（zoomOutImage，（左+宽） - （zoomSize * 1.75f），buttonY，NULL）;
canvas.drawBitmap（fitZoomImage，（左+宽） - （zoomSize * 0.75f），buttonY，NULL）;
}
canvas.restore（）;
}
/ **
*设定缩放率。
*
* @参数率
*缩放率
* /
@覆盖
公共无效setZoomRate（浮动利率）{
如果（（mZoomIn = NULL）及！及（mZoomOut = NULL）！）{
mZoomIn.setZoomRate（率）;
mZoomOut.setZoomRate（率）;
}
}
/ **
*做一个图表放大]。
* /
@覆盖
公共无效zoomIn（）{
如果（mZoomIn！= NULL）{
mZoomIn.apply（）;
重画（）;
}
}
/ **
*做一个图表缩小。
* /
@覆盖
公共无效zoomOut（）{
如果（mZoomOut！= NULL）{
mZoomOut.apply（）;
重画（）;
}
}
/ **
*做一个图表变焦复位/ FIT变焦。
* /
@覆盖
公共无效zoomReset（）{
如果（mFitZoom！= NULL）{
mFitZoom.apply（）;
mZoomIn.notifyZoomResetListeners（）;
重画（）;
}
}
/ **
*增加了一个新的缩放监听器。
*
* @参数监听器
*变焦监听器
* /
@覆盖
公共无效addZoomListener（ZoomListener监听器，布尔onButtons，布尔onPinch）{
如果（onButtons）{
如果（mZoomIn！= NULL）{
mZoomIn.addZoomListener（听众）;
mZoomOut.addZoomListener（听众）;
}
如果（onPinch）{
mTouchHandler.addZoomListener（听众）;
}
}
}
/ **
*删除变焦听众。
*
* @参数监听器
*变焦监听器
* /
@覆盖
市民同步无效removeZoomListener（ZoomListener监听器）{
如果（mZoomIn！= NULL）{
mZoomIn.removeZoomListener（听众）;
mZoomOut.removeZoomListener（听众）;
}
mTouchHandler.removeZoomListener（听众）;
}
/ **
*增加了一个新的泛听众。
*
* @参数监听器
*泛监听器
* /
@覆盖
公共无效addPanListener（PanListener监听器）{
mTouchHandler.addPanListener（听众）;
}
/ **
*删除一个泛听众。
*
* @参数监听器
*泛监听器
* /
@覆盖
公共无效removePanListener（PanListener监听器）{
mTouchHandler.removePanListener（听众）;
}
@覆盖
保护RectF getZoomRectangle（）{
返回mZoomR;
}
@覆盖
公共布尔的onTouchEvent（MotionEvent事件）{
如果（event.getAction（）== MotionEvent.ACTION_DOWN）{
//保存X和Y，使他们能够在点击并长preSS使用
// 听众
oldX = event.getX（）;
oldY = event.getY（）;
}
如果（（mRenderer =空）及！及（mRenderer.isPanEnabled（）|| mRenderer.isZoomEnabled（）））{
如果（mTouchHandler.handleTouch（事件））{
返回true;
}
}
返回super.onTouchEvent（事件）;
}
/ **
*安排一个视图内容重绘。
* /
@覆盖
公共无效重新绘制（）{
mHandler.post（新的Runnable（）{
@覆盖
公共无效的run（）{
无效（）;
}
}）;
}
/ **
*安排一个视图内容重绘，在指定的矩形区域。
*
* @参数左
*在区域的左边位置重新绘制
* @参数顶部
*的区域的顶部位置重新绘制
* @参数正确
*的区域的右侧位置进行重新绘制
* @参数底部
*的区域的底部位置重新绘制
* /
@覆盖
公共无效重新绘制（最终诠释左，最终诠释顶部，最终诠释权，最终诠释底部）{
mHandler.post（新的Runnable（）{
@覆盖
公共无效的run（）{
无效（左，上，右，下）;
}
}）;
}
/ **
*保存图形视图为位图的内容。
*
返回：位图
* /
@覆盖
公共位图toBitmap（）{
setDrawingCacheEnabled（假）;
如果（！isDrawingCacheEnabled（））{
setDrawingCacheEnabled（真正的）;
}
如果（mRenderer.isApplyBackgroundColor（））{
setDrawingCacheBackgroundColor（mRenderer.getBackgroundColor（））;
}
setDrawingCacheQuality（View.DRAWING_CACHE_QUALITY_HIGH）;
返回getDrawingCache（真）;
}
}
公共类CustomPieChart扩展RoundChart {
公共静态INT半径= 115;
浮动currentAngle中;
/ **在饼图攻丝时处理返回值。 * /
私人最终PieMapper mPieMapper;
/ **
*构建一个新的饼图实例。
*
* @参数数据集
*该系列的数据集
* @参数渲染器
*系列的渲染器
* /
公共CustomPieChart（CategorySeries数据集，DefaultRenderer渲染器）{
超（数据集，渲染器）;
mPieMapper =新PieMapper（）;
}
/ **
*饼图的图形重新presentation。
*
* @参数帆布
*在画布上作画，以
* @参数x
*视图的顶部左边x值绘制到
* @参数ÿ
*视图的左上角的y值绘制到
* @参数宽度
*视图的宽度绘制到
* @参数高度
*视图的高度来绘制到
* @参数油漆
*油漆
* /
@覆盖
公共无效画（油画画布，诠释的x，INT Y，INT宽度，高度INT，油漆涂料）{
// paint.setAntiAlias（mRenderer.isAntialiasing（））;
paint.setAntiAlias（真正的）;
paint.setStyle（Style.FILL）;
paint.setTextSize（mRenderer.getLabelsTextSize（））;
INT legendSize = getLegendSize（mRenderer，高度/ 5，0）;
诠释左= X;
INT顶部= Y;
诠释正确= X +宽;
INT sLength = mDataset.getItemCount（）;
双总= 0;
的String []标题=新的String [sLength]
的for（int i = 0; I＆LT; sLength;我++）{
总+ = mDataset.getValue（ⅰ）;
标题[I] = mDataset.getCategory（ⅰ）;
}
如果（mRenderer.isFitLegend（））{
legendSize = drawLegend（帆布，mRenderer，职称，左，右，Y，宽度，高度，legendSize，油漆，真）;
}
INT底部= Y +高度 - legendSize;
drawBackground（mRenderer，帆布，X，Y，宽度，高度，油漆，假的，DefaultRenderer.NO_COLOR）;
currentAngle中= 0;
INT mRadius = Math.min（Math.abs（右 - 左），Math.abs（下 - 上））;
//半径=（int）的（mRadius * 0.35 * mRenderer.getScale（））;
如果（mCenterX == NO_VALUE）{
mCenterX =（左+右）/ 2;
}
如果（mCenterY == NO_VALUE）{
mCenterY =（底部+顶）/ 2;
}
//胡克片段检测中心后，已经计算
mPieMapper.setDimensions（mRadius，mCenterX，mCenterY）;
！布尔loadPieCfg = mPieMapper.areAllSegment present（sLength）;
如果（loadPieCfg）{
mPieMapper.clearPieSegments（）;
}
//浮动shortRadius =半径* 0.9F;
//浮动longRadius =半径* 1.1F;
RectF椭圆形=新RectF（mCenterX - 半径，mCenterY - 半径，mCenterX +半径，mCenterY +半径）;
//名单，其中，RectF＆GT; prevLabelsBounds =新的ArrayList＆LT; RectF＆GT;（）;
的for（int i = 0; I＆LT; sLength;我++）{
paint.setColor（mRenderer.getSeriesRendererAt（ⅰ）.getColor（））;
浮点值=（浮点）mDataset.getValue（我）;
浮动角=（浮点）（价值/总* 360）;
canvas.drawArc（椭圆形，currentAngle中，角度，真实，油漆）;
// drawLabel（帆布，mDataset.getCategory（I），mRenderer，prevLabelsBounds，mCenterX，mCenterY，
// shortRadius，longRadius，currentAngle中，角，左，右，油漆）;
//保存细节getSeries功能
如果（loadPieCfg）{
mPieMapper.addPieSegment（I，价值，currentAngle中，角度）;
}
currentAngle中+ =角;
}
// prevLabelsBounds.clear（）;
// drawLegend（帆布，mRenderer，职称，左，右，Y，宽度，高度，legendSize，油漆，假）;
// drawTitle（帆布，X，Y，宽度，油漆）;
}
公共静态INT getRadius（）{
返回半径;
}
@覆盖
公共SeriesSelection getSeriesAndPointForScreenCoordinate（点screenPoint）{
返回mPieMapper.getSeriesAndPointForScreenCoordinate（screenPoint）;
}
}
Is it possible? have anyone been doing this before? I don't know where to start.
I mostly need the menu, not the context menu.
My "BudgetPieChart" class
public class ExpensesByCategoriesPieChart extends AbstractChart{
private DataToArray dta;
@Override
public String getName() {
return MyApplication.getContext().getString(R.string.ExpensesByCategoriesPieChartName);
}
@Override
public String getDesc() {
return "The budget per project for this year (pie chart)";
}
@Override
public Intent execute(Context context) {
dta = new DataToArray();
String[] categories = dta.expenseByCategoriesToArray();
double[] values = dta.expensesValuesByCategoriesToArray();
int[] colors = dta.getColorsArray(categories.length);
DefaultRenderer renderer = buildCategoryRenderer(colors);
renderer.setZoomButtonsVisible(true);
renderer.setZoomEnabled(true);
renderer.setChartTitleTextSize(20);
return ChartFactory.getPieChartIntent(context, buildCategoryDataset("Wydatki kategoriami", categories, values), renderer, "Wydatki");
}
public CustomGraphicalView createView(
CustomGraphicalView customGraphicalView) {
// what do I do here?
return null;
}
}
解决方案
OK so here it is. In my case CustomGraphicalView extends org.achartengine.GraphicalView but you can extend whatever class you need.
private CustomGraphicalView mGraphicalView = new BudgetPieChart().createView(this); // you edit the createView() with your input data for the graph
private RelativeLayout chart_layout = (RelativeLayout) findViewById(R.id.chart_layout);
android.widget.RelativeLayout.LayoutParams param = new RelativeLayout.LayoutParams(width, height);
chart_layout.setGravity(Gravity.CENTER);
chart_layout.addView(mGraphicalView, param);
public CustomGraphicalView createView(Context context) {
double[] values = new double[] { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 }; //your desired values
int[] colors = new int[] { // Color.BLUE, Color.GREEN, Color.MAGENTA, Color.YELLOW, Color.CYAN (your desired colors)
Color.parseColor("#ff3399ff"), Color.parseColor("#ff0066cc"), Color.parseColor("#ff613592"), Color.parseColor("#ff7d3493"), Color.parseColor("#ffe81f53"), Color.parseColor("#ffeb5531"), Color.parseColor("#fff6bb2d"), Color.parseColor("#fff39f2f"), Color.parseColor("#ffe0d347"), Color.parseColor("#ff78c200") };
// remember to have enough colors to match the number of elements from the data array for each pie slice
DefaultRenderer renderer = buildCategoryRenderer(colors);
renderer.setZoomButtonsVisible(false);
renderer.setZoomEnabled(false);
renderer.setChartTitleTextSize(20);
renderer.setAntialiasing(true);
renderer.setApplyBackgroundColor(false);
renderer.setBackgroundColor(Color.TRANSPARENT);
renderer.setPanEnabled(false);
renderer.setShowLabels(false);
renderer.setShowLegend(false);
return CustomChartFactory.getPieChartView(context, buildCategoryDataset("Project budget", values), renderer);
}
@Override
public Intent execute(Context arg0) {
// NOT USED
return null;
}
public class CustomChartFactory {
/** The key for the chart data. */
public static final String CHART = "chart";
/** The key for the chart graphical activity title. */
public static final String TITLE = "title";
private CustomChartFactory() {
// empty for now
}
/**
* Creates a pie chart intent that can be used to start the graphical view activity.
*
* @param context
* the context
* @param dataset
* the category series dataset (cannot be null)
* @param renderer
* the series renderer (cannot be null)
* @return a pie chart view
* @throws IllegalArgumentException
* if dataset is null or renderer is null or if the dataset number of items is different than the number of series renderers
*/
public static final CustomGraphicalView getPieChartView(Context context, CategorySeries dataset, DefaultRenderer renderer) {
checkParameters(dataset, renderer);
CustomPieChart chart = new CustomPieChart(dataset, renderer);
return new CustomGraphicalView(context, chart);
}
/**
* Checks the validity of the dataset and renderer parameters.
*
* @param dataset
* the category series dataset (cannot be null)
* @param renderer
* the series renderer (cannot be null)
* @throws IllegalArgumentException
* if dataset is null or renderer is null or if the dataset number of items is different than the number of series renderers
*/
private static void checkParameters(CategorySeries dataset, DefaultRenderer renderer) {
if (dataset == null || renderer == null || dataset.getItemCount() != renderer.getSeriesRendererCount()) {
throw new IllegalArgumentException("Dataset and renderer should be not null and the dataset number of items should be equal to the number of series renderers");
}
}
}
This should get you going further with your project :) Good luck!
public class CustomGraphicalView extends org.achartengine.GraphicalView {
/** The chart to be drawn. */
private final AbstractChart mChart;
/** The chart renderer. */
private DefaultRenderer mRenderer;
/** The view bounds. */
private final Rect mRect = new Rect();
/** The user interface thread handler. */
private final Handler mHandler;
/** The zoom buttons rectangle. */
private final RectF mZoomR = new RectF();
/** The zoom in icon. */
private Bitmap zoomInImage;
/** The zoom out icon. */
private Bitmap zoomOutImage;
/** The fit zoom icon. */
private Bitmap fitZoomImage;
/** The zoom area size. */
private final int zoomSize = 50;
/** The zoom buttons background color. */
private static final int ZOOM_BUTTONS_COLOR = Color.argb(175, 150, 150, 150);
/** The zoom in tool. */
private Zoom mZoomIn;
/** The zoom out tool. */
private Zoom mZoomOut;
/** The fit zoom tool. */
private FitZoom mFitZoom;
/** The paint to be used when drawing the chart. */
private final Paint mPaint = new Paint();
/** The touch handler. */
private ITouchHandler mTouchHandler;
/** The old x coordinate. */
private float oldX;
/** The old y coordinate. */
private float oldY;
public boolean isRotating;
private float mX1, mY1, pY1, pX1, mX2, mY2, py, px, lastAngle, angle_rotation, rotation;
/**
* Creates a new graphical view.
*
* @param context
* the context
* @param chart
* the chart to be drawn
*/
public CustomGraphicalView(Context context, AbstractChart chart) {
super(context, chart);
setOnTouchListener(this);
mChart = chart;
mHandler = new Handler();
if (mChart instanceof XYChart) {
mRenderer = ((XYChart) mChart).getRenderer();
} else {
mRenderer = ((RoundChart) mChart).getRenderer();
}
if (mRenderer.isZoomButtonsVisible()) {
zoomInImage = BitmapFactory.decodeStream(CustomGraphicalView.class.getResourceAsStream("image/zoom_in.png"));
zoomOutImage = BitmapFactory.decodeStream(CustomGraphicalView.class.getResourceAsStream("image/zoom_out.png"));
fitZoomImage = BitmapFactory.decodeStream(CustomGraphicalView.class.getResourceAsStream("image/zoom-1.png"));
}
if ((mRenderer instanceof XYMultipleSeriesRenderer) && (((XYMultipleSeriesRenderer) mRenderer).getMarginsColor() == XYMultipleSeriesRenderer.NO_COLOR)) {
((XYMultipleSeriesRenderer) mRenderer).setMarginsColor(mPaint.getColor());
}
if ((mRenderer.isZoomEnabled() && mRenderer.isZoomButtonsVisible()) || mRenderer.isExternalZoomEnabled()) {
mZoomIn = new Zoom(mChart, true, mRenderer.getZoomRate());
mZoomOut = new Zoom(mChart, false, mRenderer.getZoomRate());
mFitZoom = new FitZoom(mChart);
}
int version = 7;
try {
version = Integer.valueOf(Build.VERSION.SDK);
} catch (Exception e) {
// do nothing
}
if (version < 7) {
mTouchHandler = new TouchHandlerOld(this, mChart);
} else {
mTouchHandler = new TouchHandler(this, mChart);
}
}
/**
* Returns the current series selection object.
*
* @return the series selection
*/
@Override
public SeriesSelection getCurrentSeriesAndPoint() {
return mChart.getSeriesAndPointForScreenCoordinate(new Point(oldX, oldY));
}
/**
* Transforms the currently selected screen point to a real point.
*
* @param scale
* the scale
* @return the currently selected real point
*/
@Override
public double[] toRealPoint(int scale) {
if (mChart instanceof XYChart) {
XYChart chart = (XYChart) mChart;
return chart.toRealPoint(oldX, oldY, scale);
}
return null;
}
@Override
protected void onDraw(Canvas canvas) {
// super.onDraw(canvas);
canvas.save();
canvas.getClipBounds(mRect);
int top = mRect.top;
int left = mRect.left;
int width = mRect.width();
int height = mRect.height();
if (mRenderer.isInScroll()) {
top = 0;
left = 0;
width = getMeasuredWidth();
height = getMeasuredHeight();
}
mChart.draw(canvas, left, top, width, height, mPaint);
if ((mRenderer != null) && mRenderer.isZoomEnabled() && mRenderer.isZoomButtonsVisible()) {
mPaint.setColor(ZOOM_BUTTONS_COLOR);
// zoomSize = Math.max(zoomSize, Math.min(width, height) / 7);
mZoomR.set((left + width) - (zoomSize * 3), (top + height) - (zoomSize * 0.775f), left + width, top + height);
canvas.drawRoundRect(mZoomR, zoomSize / 3, zoomSize / 3, mPaint);
float buttonY = (top + height) - (zoomSize * 0.625f);
canvas.drawBitmap(zoomInImage, (left + width) - (zoomSize * 2.75f), buttonY, null);
canvas.drawBitmap(zoomOutImage, (left + width) - (zoomSize * 1.75f), buttonY, null);
canvas.drawBitmap(fitZoomImage, (left + width) - (zoomSize * 0.75f), buttonY, null);
}
canvas.restore();
}
/**
* Sets the zoom rate.
*
* @param rate
* the zoom rate
*/
@Override
public void setZoomRate(float rate) {
if ((mZoomIn != null) && (mZoomOut != null)) {
mZoomIn.setZoomRate(rate);
mZoomOut.setZoomRate(rate);
}
}
/**
* Do a chart zoom in.
*/
@Override
public void zoomIn() {
if (mZoomIn != null) {
mZoomIn.apply();
repaint();
}
}
/**
* Do a chart zoom out.
*/
@Override
public void zoomOut() {
if (mZoomOut != null) {
mZoomOut.apply();
repaint();
}
}
/**
* Do a chart zoom reset / fit zoom.
*/
@Override
public void zoomReset() {
if (mFitZoom != null) {
mFitZoom.apply();
mZoomIn.notifyZoomResetListeners();
repaint();
}
}
/**
* Adds a new zoom listener.
*
* @param listener
* zoom listener
*/
@Override
public void addZoomListener(ZoomListener listener, boolean onButtons, boolean onPinch) {
if (onButtons) {
if (mZoomIn != null) {
mZoomIn.addZoomListener(listener);
mZoomOut.addZoomListener(listener);
}
if (onPinch) {
mTouchHandler.addZoomListener(listener);
}
}
}
/**
* Removes a zoom listener.
*
* @param listener
* zoom listener
*/
@Override
public synchronized void removeZoomListener(ZoomListener listener) {
if (mZoomIn != null) {
mZoomIn.removeZoomListener(listener);
mZoomOut.removeZoomListener(listener);
}
mTouchHandler.removeZoomListener(listener);
}
/**
* Adds a new pan listener.
*
* @param listener
* pan listener
*/
@Override
public void addPanListener(PanListener listener) {
mTouchHandler.addPanListener(listener);
}
/**
* Removes a pan listener.
*
* @param listener
* pan listener
*/
@Override
public void removePanListener(PanListener listener) {
mTouchHandler.removePanListener(listener);
}
@Override
protected RectF getZoomRectangle() {
return mZoomR;
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if (event.getAction() == MotionEvent.ACTION_DOWN) {
// save the x and y so they can be used in the click and long press
// listeners
oldX = event.getX();
oldY = event.getY();
}
if ((mRenderer != null) && (mRenderer.isPanEnabled() || mRenderer.isZoomEnabled())) {
if (mTouchHandler.handleTouch(event)) {
return true;
}
}
return super.onTouchEvent(event);
}
/**
* Schedule a view content repaint.
*/
@Override
public void repaint() {
mHandler.post(new Runnable() {
@Override
public void run() {
invalidate();
}
});
}
/**
* Schedule a view content repaint, in the specified rectangle area.
*
* @param left
* the left position of the area to be repainted
* @param top
* the top position of the area to be repainted
* @param right
* the right position of the area to be repainted
* @param bottom
* the bottom position of the area to be repainted
*/
@Override
public void repaint(final int left, final int top, final int right, final int bottom) {
mHandler.post(new Runnable() {
@Override
public void run() {
invalidate(left, top, right, bottom);
}
});
}
/**
* Saves the content of the graphical view to a bitmap.
*
* @return the bitmap
*/
@Override
public Bitmap toBitmap() {
setDrawingCacheEnabled(false);
if (!isDrawingCacheEnabled()) {
setDrawingCacheEnabled(true);
}
if (mRenderer.isApplyBackgroundColor()) {
setDrawingCacheBackgroundColor(mRenderer.getBackgroundColor());
}
setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_HIGH);
return getDrawingCache(true);
}
}
public class CustomPieChart extends RoundChart {
public static int radius = 115;
float currentAngle;
/** Handles returning values when tapping on PieChart. */
private final PieMapper mPieMapper;
/**
* Builds a new pie chart instance.
*
* @param dataset
* the series dataset
* @param renderer
* the series renderer
*/
public CustomPieChart(CategorySeries dataset, DefaultRenderer renderer) {
super(dataset, renderer);
mPieMapper = new PieMapper();
}
/**
* The graphical representation of the pie chart.
*
* @param canvas
* the canvas to paint to
* @param x
* the top left x value of the view to draw to
* @param y
* the top left y value of the view to draw to
* @param width
* the width of the view to draw to
* @param height
* the height of the view to draw to
* @param paint
* the paint
*/
@Override
public void draw(Canvas canvas, int x, int y, int width, int height, Paint paint) {
// paint.setAntiAlias(mRenderer.isAntialiasing());
paint.setAntiAlias(true);
paint.setStyle(Style.FILL);
paint.setTextSize(mRenderer.getLabelsTextSize());
int legendSize = getLegendSize(mRenderer, height / 5, 0);
int left = x;
int top = y;
int right = x + width;
int sLength = mDataset.getItemCount();
double total = 0;
String[] titles = new String[sLength];
for (int i = 0; i < sLength; i++) {
total += mDataset.getValue(i);
titles[i] = mDataset.getCategory(i);
}
if (mRenderer.isFitLegend()) {
legendSize = drawLegend(canvas, mRenderer, titles, left, right, y, width, height, legendSize, paint, true);
}
int bottom = y + height - legendSize;
drawBackground(mRenderer, canvas, x, y, width, height, paint, false, DefaultRenderer.NO_COLOR);
currentAngle = 0;
int mRadius = Math.min(Math.abs(right - left), Math.abs(bottom - top));
// radius = (int) (mRadius * 0.35 * mRenderer.getScale());
if (mCenterX == NO_VALUE) {
mCenterX = (left + right) / 2;
}
if (mCenterY == NO_VALUE) {
mCenterY = (bottom + top) / 2;
}
// Hook in clip detection after center has been calculated
mPieMapper.setDimensions(mRadius, mCenterX, mCenterY);
boolean loadPieCfg = !mPieMapper.areAllSegmentPresent(sLength);
if (loadPieCfg) {
mPieMapper.clearPieSegments();
}
// float shortRadius = radius * 0.9f;
// float longRadius = radius * 1.1f;
RectF oval = new RectF(mCenterX - radius, mCenterY - radius, mCenterX + radius, mCenterY + radius);
// List<RectF> prevLabelsBounds = new ArrayList<RectF>();
for (int i = 0; i < sLength; i++) {
paint.setColor(mRenderer.getSeriesRendererAt(i).getColor());
float value = (float) mDataset.getValue(i);
float angle = (float) (value / total * 360);
canvas.drawArc(oval, currentAngle, angle, true, paint);
// drawLabel(canvas, mDataset.getCategory(i), mRenderer, prevLabelsBounds, mCenterX, mCenterY,
// shortRadius, longRadius, currentAngle, angle, left, right, paint);
// Save details for getSeries functionality
if (loadPieCfg) {
mPieMapper.addPieSegment(i, value, currentAngle, angle);
}
currentAngle += angle;
}
// prevLabelsBounds.clear();
// drawLegend(canvas, mRenderer, titles, left, right, y, width, height, legendSize, paint, false);
// drawTitle(canvas, x, y, width, paint);
}
public static int getRadius() {
return radius;
}
@Override
public SeriesSelection getSeriesAndPointForScreenCoordinate(Point screenPoint) {
return mPieMapper.getSeriesAndPointForScreenCoordinate(screenPoint);
}
}
这篇关于菜单和文本菜单的aChartengine图的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
