I developed a new filling algorithm for eMage. The filling takes immensely long - up to 30 seconds is normal. The delay is caused by the fact that I've employed swap files instead of putting the bitmap in memory and not the algorithm itself. The algorithm I've used lets me pattern fill with minor modification. Assume you have got the entire bitmap in memory row after row and each pixel is represented by 8 bits. Yes I am being wasteful here - I've used 8 bits instead of 4. This gives me around 240 values per pixel which have not been used, which means that I can use them to store special information.

The wasteful storage format (it takes double the actual amount of space required) makes the filling algorithm relatively easy. When I click on a point demanding a fill operation, I wish to convert all pixels of the same color in the region common to the point where I clicked to be converted to the fill color. So whaddoi do? I just mark the pixel clicked with one of the unused numbers say 18. Next I check the pixels up, down left and right whether they are of the same color as the original point clicked. If they are, then I mark them with a new number say, 17. Next I scan the entire bitmap for all pixels with value 17. If any are found, then I mark them as 18 and check if the pixels up, down, left or right are the same color as the original point clicked. If so mark them as 17 ... after all that's done scan again and repeat the procedure. Do it till there is no change noted.

Then convert all the points marked as 18 to the desired color or draw the suitable pattern over the 18-marked areas. Might seem wasteful to you. But its pretty fast if done with the bitmap stored in main memory. If you got better solutions, do tell me.

I had to hunt around quite a bit for this one. Its pretty easy once you see it though. You just draw line segments in increasing inclinations away from the centre of the spiral.
void spiral( int xCentre, int yCentre, int maxRadius, float twistFactor) { float angle, angleStep; float radius, radiusStep; int x, y, lastX, lastY; angle=0.0; angleStep=twistFactor*3.14159/maxRadius; radius=0.0; radiusStep=0.1; lastX=xCentre; lastY=yCentre; while( radius <= maxRadius) { x=xCentre+radius*cos(angle); y=yCentre+radius*sin(angle); line( lastX, lastY, x, y); lastX=x; lastY=y; angle+=angleStep; radius+=radiusStep; } }

The following functions use standard algorithms to draw circles and ellipses. I've modified them from my Canvas library - didn't get time to test it after that. They originally used different functions for graphical o/p so just watch out for errors. Tell me if you find errors.
void line( int x0, int y0, int x1, int y1) { x0-=left;x1-=left;y0-=top;y1-=top; int x; double dy,dx,m,y; if(x0>x1||(x0==x1&&y0>y1)) { x=x0;y=y0; x0=x1;y0=y1; x1=x;y1=y; } y=y0; dy=y1-y0; dx=x1-x0; if(!dx) /*vertical line*/ { for(y=y0;y<=y1;y++) putpixel(x0,(int)y); return; } m=dy/dx; if(fabs(m)<=1) for(x=x0;x<=x1;x++) { putpixel(x,(int)y); y+=m; } else { if(y0>y1) { x=x0;y=y0; x0=x1;y0=y1; x1=x;y1=y; } y=x0; for(x=y0;x<y1;x++) { putpixel((int)y,x); y+=1/m; } } } void setcirclepoints( int xx, int y, int xcen, int ycen, int circle) { putpixel(xcen+xx,ycen+y); putpixel(xcen+xx,ycen-y); putpixel(xcen-xx,ycen+y); putpixel(xcen-xx,ycen-y); if(circle) { putpixel(xcen+y,ycen+xx); putpixel(xcen+y,ycen-xx); putpixel(xcen-y,ycen+xx); putpixel(xcen-y,ycen-xx); } } void circle( int x, int y, int rad) { x-=left;y-=top; int p=1-rad; int x0=0,y0=rad; while(x0<=y0) { setcirclepoints(x0,y0,x,y,1); if(p<0) p+=2*x0+3; else { p+=2*(x0-y0)+5; y0--; } x0++; } } void ellipse( int x, int y, double a, double b) { x-=left;y-=top; double d2; int x0=0.0,y0=b; double d1=(double)b*b-a*a*b+0.25*a*a; setcirclepoints(x0,y0,x,y,0); while(a*a*(y0-0.5)>b*b*(x0+1)) { if(d1<0) d1+=(double)b*b*(2*x0+3); else { d1+=(double)b*b*(2*x0+3)+a*a*(-2*y0+2); y0--; } x0++; setcirclepoints(x0,y0,x,y,0); } d2=(double)b*b*(x0+0.5)*(x0+0.5)+a*a*(y0-1)*(y0-1)-a*a*b*b; while(y0>0) { if(d2<0) { d2+=(double)b*b*(2*x0+2)+a*a*(-2*y0+3); x0++; } else d2+=(double)a*a*(-2*y0+3); y0--; setcirclepoints(x0,y0,x,y,0); } }

Instead of drawing pixels whenever you detect a mouse down at freehand draw mode you might want to draw lines instead. This gives smoother output. Just remember the previous point detected and draw a line to the new point detected. Then store the new point so that you can draw a line from there when another point is detected.

Rubber banding is what you see when you move your mouse around while keeping the button pressed down to draw lines, circles etc. You see that lines, circles etc. are drawn and can be moved around until you reach your desired figure. This can be done easily by inverting the background pixels and then inverting them back again as you move around. The inverting technique ensures that you don't have to refresh the entire canvas each time you move the mouse while drawing the line, circle etc. An easy way to do this is encapsulating the putpixel() function as below:
void setpixel( int x, int y, int color) { if(color==16) putpixel(x,y,15-getpixel(x,y)); else putpixel(x,y,color); }

This means that passing color value as 16, puts a pixel which is the inverse of the original. Inverting twice gives the original color. You could modify the functions to draw line, circle etc. to use setpixel() instead of putpixel(). This means that you can easily draw these figures showing the inverse of the background. Repeating the inverse function to draw the same figure would return the Canvas to the original state. No cleaning! No refreshing!