Canvas for drawing lines that indicate cuneiform characters. More...

Inheritance diagram for DrawingCanvas:

Collaboration diagram for DrawingCanvas:

Public Member Functions
	DrawingCanvas (Context c, AttributeSet attrs)
	Constructor for this class. More...

void	undoPath ()

void	redoPath ()

void	setOnLongClickListener (@Nullable OnLongClickListener l)

boolean	onTouchEvent (MotionEvent event)

Public Attributes
List< LineParameters >	lines = new LinkedList<>()

List< String >	strokes = new LinkedList<>()

int	width

int	height

Protected Member Functions
void	onSizeChanged (int w, int h, int oldw, int oldh)

void	onDraw (Canvas canvas)

Package Functions
void	clearCanvas ()
	Clears the canvas. More...

Package Attributes
Integer	a =0

Integer	b =0

Integer	c =0

Integer	d =0

Integer	s =0

Integer	left =0

Integer	right =0

Integer	up =0

Integer	down =0

String	paleocodage =""

float	mY

Private Member Functions
void	startTouch (float x, float y)

void	moveTouch (float x, float y)

void	upTouch ()

Private Attributes
Canvas	mCanvas

float	startX

float	startY

Path	mPath

CuneiPainter	context

Paint	mPaint

float	mX

List< Path >	paths

List< Path >	undonepaths

Static Private Attributes
static final float	TOLERANCE = 5

Detailed Description

Canvas for drawing lines that indicate cuneiform characters.

Constructor & Destructor Documentation

DrawingCanvas	(	Context	c,
		AttributeSet	attrs
	)

Constructor for this class.

Parameters

c	the context of this canvas
attrs	the attributes to consider

References DrawingCanvas.context, DrawingCanvas.mPaint, and DrawingCanvas.mPath.

                                                             {
             super(c, attrs);
             this.paths=new ArrayList<>();
             this.undonepaths=new ArrayList<>();
             context = (CuneiPainter)c;
 
             // we set a new Path
             mPath = new Path();
 
             // and we set a new Paint with the desired attributes
             mPaint = new Paint();
             mPaint.setAntiAlias(true);
             mPaint.setColor(Color.RED);
             mPaint.setStyle(Paint.Style.STROKE);
             mPaint.setStrokeJoin(Paint.Join.ROUND);
             mPaint.setStrokeCap(Paint.Cap.ROUND);
             mPaint.setStrokeWidth(20);
             this.mCanvas=new Canvas();
         }

Member Function Documentation

void clearCanvas ( )

package

Clears the canvas.

References DrawingCanvas.paths.

                        {
             for(Path p:this.paths){
                 p.reset();
             }
             this.paths.clear();
             this.paleocodage="";
             this.lines.clear();
             stroketypeLength.clear();
             invalidate();
         }

void moveTouch	(	float	x,
		float	y
	)

private

References DrawingCanvas.mX, DrawingCanvas.mY, and DrawingCanvas.TOLERANCE.

Referenced by DrawingCanvas.onTouchEvent().

                                                  {
             float dx = Math.abs(x - mX);
             float dy = Math.abs(y - mY);
             if (dx >= TOLERANCE || dy >= TOLERANCE) {
                 mPath.quadTo(mX, mY, (x + mX) / 2, (y + mY) / 2);
                 mX = x;
                 mY = y;
             }
         }

void onDraw ( Canvas canvas )

protected

References DrawingCanvas.mPaint, and DrawingCanvas.paths.

                                              {
             super.onDraw(canvas);
             // draw the mPath with the mPaint on the canvas when onDraw
             for(Path p:this.paths){
                 canvas.drawPath(p,mPaint);
             }
         }

void onSizeChanged	(	int	w,
		int	h,
		int	oldw,
		int	oldh
	)

protected

                                                                        {
             super.onSizeChanged(w, h, oldw, oldh);
 
             // your Canvas will draw onto the defined Bitmap
             Bitmap mBitmap = Bitmap.createBitmap(w <= 0 ? 1 : w, h <= 0 ? 1 : h, Bitmap.Config.ARGB_8888);
             this.mCanvas = new Canvas(mBitmap);
         }

boolean onTouchEvent ( MotionEvent event )

References DrawingCanvas.moveTouch(), DrawingCanvas.startTouch(), and DrawingCanvas.upTouch().

                                                        {
             float x = event.getX();
             float y = event.getY();
 
             switch (event.getAction()) {
                 case MotionEvent.ACTION_DOWN:
                     startTouch(x, y);
                     invalidate();
                     break;
                 case MotionEvent.ACTION_MOVE:
                     moveTouch(x, y);
                     invalidate();
                     break;
                 case MotionEvent.ACTION_UP:
                     upTouch();
                     invalidate();
                     break;
             }
             return true;
         }

void redoPath ( )

References DrawingCanvas.s, and DrawingCanvas.undonepaths.

                               {
             if(!this.undonepaths.isEmpty()) {
                 paths.add(this.paths.remove(this.paths.size() - 1));
                 invalidate();
             }
             s++;
         }

void setOnLongClickListener ( @Nullable OnLongClickListener l )

                                                                         {
         super.setOnLongClickListener(l);
         this.clearCanvas();
     }

void startTouch	(	float	x,
		float	y
	)

private

References DrawingCanvas.mX, DrawingCanvas.mY, DrawingCanvas.startX, and DrawingCanvas.startY.

Referenced by DrawingCanvas.onTouchEvent().

                                                   {
             undonepaths.clear();
             mPath.reset();
             mPath.moveTo(x, y);
             mX = x;
             mY = y;
             startX=x;
             startY=y;
         }

void undoPath ( )

References StrokeType.A, DrawingCanvas.a, StrokeType.B, DrawingCanvas.b, StrokeType.C, DrawingCanvas.c, StrokeType.D, DrawingCanvas.d, DrawingCanvas.paths, DrawingCanvas.s, and DrawingCanvas.strokes.

                               {
             if(!this.paths.isEmpty() && !strokes.isEmpty()) {
                 undonepaths.add(this.paths.remove(this.paths.size() - 1));
                 invalidate();
                 s--;
                 switch(strokes.get(strokes.size()-1)){
                     case "a":--a;stroketypeLength.get(StrokeType.A).remove(stroketypeLength.get(StrokeType.A).size()-1);break;
                     case "b":--b;stroketypeLength.get(StrokeType.B).remove(stroketypeLength.get(StrokeType.B).size()-1);break;
                     case "c":--c;stroketypeLength.get(StrokeType.C).remove(stroketypeLength.get(StrokeType.C).size()-1);break;
                     case "d":--d;stroketypeLength.get(StrokeType.D).remove(stroketypeLength.get(StrokeType.D).size()-1);break;
                 }
                 strokes.remove(strokes.size()-1);
                 this.lines.remove(lines.size()-1);
                 this.paleocodage=LocationCalc.calculateRelation(this.lines);
                 this.context.setStatusText();
                 this.context.lookUp();
             }
 
         }

void upTouch ( )

private

References StrokeType.A, DrawingCanvas.a, StrokeType.B, DrawingCanvas.b, StrokeType.C, DrawingCanvas.c, StrokeType.D, DrawingCanvas.d, DrawingCanvas.down, StrokeType.E, StrokeType.F, StrokeType.INV_A, StrokeType.INV_B, DrawingCanvas.left, DrawingCanvas.lines, DrawingCanvas.mPaint, DrawingCanvas.mPath, DrawingCanvas.mX, DrawingCanvas.mY, DrawingCanvas.paleocodage, DrawingCanvas.right, DrawingCanvas.s, DrawingCanvas.startX, DrawingCanvas.startY, and DrawingCanvas.up.

Referenced by DrawingCanvas.onTouchEvent().

                                {
             mPath.lineTo(mX, mY);
             //mPath.moveTo(startX, startY);
             float delta_x = mX - startX;
             float delta_y = mY - startY;
 
             //
 
             double m=delta_y/delta_x;
             double radius = Math.atan(m)*100;
             System.out.println("Angle: "+radius);
             ++s;
             if(radius>140 && radius<200){
                 System.out.println("Detected: A");
                 ++a;
                 strokes.add("a");
                 if(startY>mY){
                     up++;
 
                     this.lines.add(new LineParameters(startX,startY,mX,mY,delta_x,delta_y,StrokeType.INV_A));                               paleocodage=LocationCalc.calculateRelation(lines);
                     //paleocodage+="!a-";
 
                 }else{
                     down++;
                     this.lines.add(new LineParameters(startX,startY,mX,mY,delta_x,delta_y,StrokeType.A));
                     paleocodage=LocationCalc.calculateRelation(lines);
                     //paleocodage+="a-";
 
                 }
                 this.context.setStatusText();
             }else if(radius>-30 && radius<30){
                 System.out.println("Detected: B");
                 ++b;
                 strokes.add("b");
                 if(startX>mX){
                     left++;
                     //paleocodage+="!b-";
                     /*mPath.moveTo(startX+40, startY+50);
                     mPath.lineTo(startX+40, startY+50);
                     mPath.lineTo(startX, startY+45);
                     mPath.lineTo(startX+40, startY+50);*/
                     this.lines.add(new LineParameters(startX,startY,mX,mY,delta_x,delta_y,StrokeType.INV_B));
                     paleocodage=LocationCalc.calculateRelation(lines);
 
                 }else{
                     //paleocodage+="b-";
                     this.lines.add(new LineParameters(startX,startY,mX,mY,delta_x,delta_y,StrokeType.B));
                     paleocodage=LocationCalc.calculateRelation(lines);
                     right++;
                     /*mPath.moveTo(startX-40, startY+50);
                     mPath.lineTo(startX-40, startY+45);
                     mPath.lineTo(startX, startY+45);
                     mPath.lineTo(startX+40, startY+40);*/
 
                 }
                 this.context.setStatusText();
             }else if(radius<-30 && radius>-170){
                 System.out.println("Detected: D");
                 ++d;
                 strokes.add("d");
                 if(startY>mY){
                     up++;
                     this.lines.add(new LineParameters(startX,startY,mX,mY,delta_x,delta_y,StrokeType.C));
                     paleocodage=LocationCalc.calculateRelation(lines);
                     //paleocodage+="c-";
                     /*mPath.moveTo(startX+50, startY+50);
                     mPath.lineTo(startX+50, startY);
                     mPath.lineTo(startX, startY+50);
                     mPath.lineTo(startX+50, startY+50);*/
 
                 }else{
                     down++;
                     //paleocodage+="d-";
                     this.lines.add(new LineParameters(startX,startY,mX,mY,delta_x,delta_y,StrokeType.D));
                     paleocodage=LocationCalc.calculateRelation(lines);
 
                     /*mPath.moveTo(startX, startY);
                     mPath.lineTo(startX, startY+50);
                     mPath.lineTo(startX-50, startY);
                     mPath.lineTo(startX, startY);*/
                 }
                 this.context.setStatusText();
             }else if(radius>30 && radius<150){
                 System.out.println("Detected: C");
                 ++c;
                 strokes.add("c");
                 if(startY>mY){
                     //paleocodage+="e-";
                     this.lines.add(new LineParameters(startX,startY,mX,mY,delta_x,delta_y,StrokeType.E));
                     paleocodage=LocationCalc.calculateRelation(lines);
                     up++;
                 }else{
                     down++;
                     //paleocodage+="f-";
                     this.lines.add(new LineParameters(startX,startY,mX,mY,delta_x,delta_y,StrokeType.F));
                     paleocodage=LocationCalc.calculateRelation(lines);
 
                 }
                 this.context.setStatusText();
 
             }
             //System.out.println(LocationCalc.calculateRelation(lines,lines.get(lines.size()-1)));
             this.context.lookUp();
             this.mCanvas.drawPath(mPath,mPaint);
             paths.add(mPath);
             mPath=new Path();
         }