FRACTAL

/********************************************************************************
*                                                                               *
*                                     FrAcTaL                                   *
* 																				*
* FrAcTaL is a Mandelbrot and Julia fractals generator, and navigator.			*
* 																				*
* Copyright (C) 2004-2005  Julien MICHOT										*
* 																				*
* Contact : m.i.t.c.h@free.fr - http://www.webfractales.com					*
* 																				*
* This program is free software; you can redistribute it and/or					*
* modify it under the terms of the GNU General Public License					*
* as published by the Free Software Foundation; either version 2				*
* of the License, or (at your option) any later version.						*
* 																				*
* This program is distributed in the hope that it will be useful,				*
* but WITHOUT ANY WARRANTY; without even the implied warranty of				*
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the					*
* GNU General Public License for more details.									*
* 																				*
* You should have received a copy of the GNU General Public License				*
* along with this program; if not, write to the Free Software					*
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.	*
* 																				*
* 																				*
* 	You can have the Fox-Toolkit library here : www.fox-toolkit.org	       		*
* 																				*
********************************************************************************/
#include "fx.h"
#define TAILLEX 800
#define TAILLEY 600
#define TAILLEMINX 100
#define TAILLEMINY 75
#define pi 3.1415926535897932384626433832


FXuchar ImageFrac[TAILLEX*TAILLEX*3];                 // Created images
FXuchar ImageFrac2[TAILLEMINX*TAILLEMINX*3];                 // Created images
double  Val[TAILLEX*TAILLEY];
double  Val2[TAILLEMINX*TAILLEMINY];

// Event Handler Object
class Fractal : public FXMainWindow {

  // Macro for class hierarchy declarations
  FXDECLARE(Fractal)

private:

  FXCanvas        *canvas;                    // Canvas to draw into
  FXImage         *Frac;
  FXBMPImage      *picture;                   // Complete picture

  FXCanvas        *canvas2; 
  FXImage         *Frac2;
  FXBMPImage      *picture2;       
  
  FXFont          *font;                      // Font for text
  FXLabel		  * InfosCoor;
  FXLabel		  * InfosCoor2;
  FXCursor		  * cur;
  FXCheckButton   * EnJulia, * JuliaAuto;
  FXCursor		  * cursorautre;
  FXTextField     * JuliaX, * JuliaY;
  double		  ConstJuliaX,ConstJuliaY;
  FXDial		  * x_dial;

  FXMDIClient       *mdiclient;               // MDI Client area
  	double		echelle;
	int			taillex,tailley;
	double		bail_min;//, bail_max
	int			i,j,la,ha;
	double		ax,ay,bx,by,bxx,norme;
	double		Echel,Echel2,X0,Y0,Xtmp,Ytmp;
	bool		Z1ok,Z2ok,Ok;
	int			EtatZoom,QuelZoom;
	int			CoordZX,CoordZY,CoordZX3,CoordZY3,CoordZX2,CoordZY2,p1av,p2av,larg,haut,IsMove;
	int			CurX,CurY;
	int			color_frac;

protected:
  Fractal(){}

public:

  // Message handlers
  
  long onCanvasRepaint(FXObject*,FXSelector,void*);
  long onCanvasRepaint2(FXObject*,FXSelector,void*);
  long onCmdWell(FXObject*,FXSelector,void*);
  long onCmdWell2(FXObject*,FXSelector,void*);
  long onCmdRestore(FXObject*,FXSelector,void*);
  long onMouseDown(FXObject*,FXSelector,void * ptr);
  long onMouseDown2(FXObject*,FXSelector,void * ptr);
  long onMouseUp(FXObject*,FXSelector,void * ptr);
  long onMouseUp2(FXObject*,FXSelector,void * ptr);
  long onMouseMove(FXObject*,FXSelector,void * ptr);
  long onCmdAbout(FXObject*,FXSelector,void * ptr);
  long onMouseWheel(FXObject*,FXSelector,void*);
  long onKeyPress(FXObject*,FXSelector,void*);
  long onJulia(FXObject*,FXSelector,void*);
  long onReset(FXObject*,FXSelector,void*);
  long onLeftBtnPress(FXObject*,FXSelector,void*);

public:

  // Messages for our class
  enum{
    ID_CANVAS=FXMainWindow::ID_LAST,
	ID_CANVAS2,
	ID_JULIA,
	ID_JULIAAUTO,
    ID_RESTORE,
	ID_ABOUT,
	ID_ROLL,
	ID_DIAL_X,
	ID_RESET,
    ID_LAST
    };

public:

  // Fractal constructor
  Fractal(FXApp* a);

  // Initialize
  virtual void create();

  void	MakeFrac(int Num);
  void  Init(int Num);
  void	ColorFrac(int Num, bool uok);
  void	RefreshMin(int nblarg);
  void	RefreshImg(int Num);
  
  // Fractal destructor
  virtual ~Fractal();
  };



// Message Map for the Scribble App class
FXDEFMAP(Fractal) FractalMap[]={

  //____Message_Type______________ID_______________Message_Handler___
  FXMAPFUNC(SEL_PAINT,   Fractal::ID_CANVAS,  Fractal::onCanvasRepaint),/*
  FXMAPFUNC(SEL_COMMAND, Fractal::ID_WELL,    Fractal::onCmdWell),*/
  FXMAPFUNC(SEL_PAINT,   Fractal::ID_CANVAS2,  Fractal::onCanvasRepaint2),
  FXMAPFUNC(SEL_LEFTBUTTONPRESS, Fractal::ID_CANVAS,	  Fractal::onMouseDown),
  FXMAPFUNC(SEL_LEFTBUTTONRELEASE, Fractal::ID_CANVAS,	  Fractal::onMouseUp),
  FXMAPFUNC(SEL_RIGHTBUTTONPRESS, Fractal::ID_CANVAS,	  Fractal::onMouseDown2),
  FXMAPFUNC(SEL_RIGHTBUTTONRELEASE, Fractal::ID_CANVAS,	  Fractal::onMouseUp2),
  FXMAPFUNC(SEL_MOTION, Fractal::ID_CANVAS,	  Fractal::onMouseMove),
  FXMAPFUNC(SEL_MOUSEWHEEL, Fractal::ID_CANVAS,	  Fractal::onMouseWheel),
  FXMAPFUNC(SEL_COMMAND, Fractal::ID_RESTORE, Fractal::onCmdRestore),
  FXMAPFUNC(SEL_KEYPRESS, Fractal::ID_CANVAS, Fractal::onKeyPress),
  FXMAPFUNC(SEL_COMMAND, Fractal::ID_ABOUT, Fractal::onCmdAbout),
  FXMAPFUNC(SEL_COMMAND, Fractal::ID_JULIA, Fractal::onJulia),
  FXMAPFUNC(SEL_COMMAND, Fractal::ID_RESET, Fractal::onReset),
  FXMAPFUNC(SEL_CHANGED, Fractal::ID_DIAL_X,	  Fractal::onLeftBtnPress),
  };



// Macro for the ScribbleApp class hierarchy implementation
FXIMPLEMENT(Fractal,FXMainWindow,FractalMap,ARRAYNUMBER(FractalMap))



// Construct Fractal
Fractal::Fractal(FXApp* a):FXMainWindow(a,"Fractals",NULL,NULL,DECOR_ALL,0,0,TAILLEX+150,TAILLEY+80){

  FXVerticalFrame *canvasFrame;
  FXVerticalFrame *buttonFrame;
  FXHorizontalFrame *contents;



  FXColorDialog *colordlg=new FXColorDialog(this,"Color Dialog");

  contents=new FXHorizontalFrame(this,LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y,0,0,0,0, 0,0,0,0);

  // LEFT pane to contain the canvas
  canvasFrame=new FXVerticalFrame(contents,FRAME_SUNKEN|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,10,10);

    // Label above the canvas
    new FXLabel(canvasFrame,"FrAcTal 0.1, by  MiTcH",NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);

    // Horizontal divider line
    new FXHorizontalSeparator(canvasFrame,SEPARATOR_GROOVE|LAYOUT_FILL_X);

    // Drawing canvas
    canvas=new FXCanvas(canvasFrame,this,ID_CANVAS,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT);


	// RIGHT pane for the buttons
	buttonFrame=new FXVerticalFrame(contents,FRAME_SUNKEN|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,10,10);

    // Label above the buttons
 //   new FXLabel(buttonFrame,"Button Frame",NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);

    // Horizontal divider line
    new FXHorizontalSeparator(buttonFrame,SEPARATOR_RIDGE|LAYOUT_FILL_X);

    // Button to draw
    new FXButton(buttonFrame,"Save Image...\tRead back image and save to file",NULL,this,ID_RESTORE,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,5,5);

		
	 EnJulia = new FXCheckButton(buttonFrame,"Julia",this,ID_JULIA);
	 JuliaX = new FXTextField(buttonFrame,1,NULL,0,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FIX_WIDTH,0,0,90,0);
	 JuliaY = new FXTextField(buttonFrame,1,NULL,0,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FIX_WIDTH,0,0,90,0);
	 JuliaAuto = new FXCheckButton(buttonFrame,"selection auto",this,ID_JULIAAUTO);

	 FXString ch="";
		for(int i=0;i<=(4.0*TAILLEY/100.0);i++)
		;//	ch+="\n";

	canvas2=new FXCanvas(buttonFrame,this,ID_CANVAS2,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT,0,0,100,75);
	new FXLabel(buttonFrame,ch,NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);	
	  // Create images with dithering
	  Frac=new FXImage(getApp(),ImageFrac,IMAGE_DITHER|IMAGE_SHMI|IMAGE_SHMP,TAILLEX,TAILLEY);
	  Frac2=new FXImage(getApp(),ImageFrac2,IMAGE_DITHER|IMAGE_SHMI|IMAGE_SHMP,TAILLEMINX,TAILLEMINY);

	  // Create image with nearest color instead of dithering

	  // Result image
	  picture=new FXBMPImage(getApp(),NULL,IMAGE_SHMI|IMAGE_SHMP,TAILLEX,TAILLEY);
	  picture2=new FXBMPImage(getApp(),NULL,IMAGE_SHMI|IMAGE_SHMP,TAILLEMINX,TAILLEMINY);

	 
	  //picture=new FXBMPImage(getApp(),NULL,0,850,TAILLEY);
	// mdiclient=new FXMDIClient(buttonFrame,LAYOUT_FILL_X|LAYOUT_FILL_Y);
		FXMatrix *colori=new FXMatrix(buttonFrame,1,FRAME_THICK|FRAME_RAISED|MATRIX_BY_COLUMNS|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,10,10);
		new FXLabel(colori,"COULEUR",NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);
		x_dial=new FXDial(colori,NULL,ID_DIAL_X,FRAME_SUNKEN|FRAME_THICK|DIAL_CYCLIC|DIAL_HORIZONTAL|LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT|LAYOUT_CENTER_Y,0,0,90,14,0,0,0,0);
		x_dial->setTipText("Changer la couleur");
		//x_dial->setNotchOffset(900);
		x_dial->setRange(0,255);
		x_dial->setValue(255);

    new FXButton(buttonFrame,"E&xit\tQuitter FrAcTaL",NULL,getApp(),FXApp::ID_QUIT,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_BOTTOM|LAYOUT_LEFT,0,0,0,0,10,10,5,5);

	new FXButton(buttonFrame,"A&bout\tA propos du logiciel...",NULL,this,ID_ABOUT,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_BOTTOM|LAYOUT_LEFT,0,0,0,0,10,10,5,5);

	new FXButton(buttonFrame,"&Reset\tRevenir au mandelbrot",NULL,this,ID_RESET,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_BOTTOM|LAYOUT_LEFT,0,0,0,0,10,10,5,5);

//	  Init(1);
	  bail_min=0.003;
	  Echel=0.005*(800/TAILLEX);
	  Echel2=0.005*(800/TAILLEMINX);
	  X0=(double) -2.1;
	  Y0=(double)  1.3;
	  Z1ok=0;Z2ok=0;Ok=0;
	  larg=0;
	  EtatZoom=0;
	  QuelZoom=1;
	  color_frac=255;

	  MakeFrac(1);
	  MakeFrac(2);


	  // Make font
	  font=new FXFont(getApp(),"Comic sans MS",15,FONTWEIGHT_BOLD);
	
	  new FXHorizontalSeparator(canvasFrame,SEPARATOR_GROOVE|LAYOUT_FILL_X);
      cursorautre= new FXCursor(getApp(),CURSOR_IBEAM);
	  cursorautre->create();
	  InfosCoor = new FXLabel(canvasFrame,"0 x 0",NULL,JUSTIFY_BOTTOM|LAYOUT_FILL_X);
	  InfosCoor2 = new FXLabel(canvasFrame," ",NULL,JUSTIFY_BOTTOM|LAYOUT_FILL_X);
	  // Make a tip
	  new FXTooltip(getApp());

	 cur= new FXCursor(getApp(),CURSOR_IBEAM);
	  setDragCursor(cur);
  }



// Destroy Fractal
Fractal::~Fractal(){
  delete Frac;
  delete picture;
  delete Frac2;
  delete picture2;
  delete font;
 
  }


// Create and initialize
void Fractal::create(){

  // Create the windows
  FXMainWindow::create();

  // Create images
  Frac->create();
  Frac2->create();


  picture->create();
  picture2->create();

  // Font too
  font->create();

  // Make it appear
  show(PLACEMENT_SCREEN);

  // First time repaint
  canvas->update();
  canvas2->update();

  }


// Handle the clear message
long Fractal::onCanvasRepaint(FXObject*,FXSelector,void* ptr){
  FXEvent *event=(FXEvent*)ptr;
  FXuint pat;

  // We caused a redraw, so redo it all
  if(event->synthetic){
    FXDCWindow dc(picture);

    // Erase the canvas, color comes from well
    dc.setForeground(0);

    dc.fillRectangle(0,0,picture->getWidth(),picture->getHeight());
		
	
    // Draw images
    dc.drawImage(Frac,0,0);
  dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut); ////
    }

  // Now repaint the screen
  FXDCWindow sdc(canvas,event);

  // Clear whole thing
  sdc.setForeground(0);
  sdc.fillRectangle(0,0,canvas->getWidth(),canvas->getHeight());

  // Paint image
  sdc.drawImage(picture,0,0);


  return 1;
  }

long Fractal::onCanvasRepaint2(FXObject*,FXSelector,void* ptr){
   FXEvent *event2=(FXEvent*)ptr;
  FXuint pat2;

  // We caused a redraw, so redo it all
  if(event2->synthetic){
    FXDCWindow dc2(picture2);

    // Erase the canvas, color comes from well
    dc2.setForeground(0);

    dc2.fillRectangle(0,0,picture2->getWidth(),picture2->getHeight());
		

    // Draw images
    dc2.drawImage(Frac2,0,0);
	/*
	Init();

	for(i=0;i<la;i++)
		for(j=0;j<ha;j++)
		{
			ax= (double) (i-Xcenter)/Zoom;
			ay= (double) (j-Ycenter)/Zoom;

			for(int u=0;u<=100&&norme>bail_min;u++)
			{
			
				bxx=bx;
				bx=(double)bx*bx-(double)by*by + ax;
				by=(double) 2.0*bxx*by + ay;
				norme=sqrt(bx*bx+by*by);
			}
				dc.setForeground(FXRGB(255,255*norme,0));

				dc.fillRectangle(i,j,1,1);

			ax=0;ay=0;bx=0;by=0;norme=1;
		}

*/
    // Draw text
  //  dc2.setTextFont(font);
   // dc2.setForeground(FXRGB(150,0,150));
   // dc2.drawText(TAILLEY,550,"Julien Michot",13);
    }

  // Now repaint the screen
  FXDCWindow sdc2(canvas2,event2);

  // Clear whole thing
  sdc2.setForeground(FXRGB(212,208,200));
  sdc2.fillRectangle(0,0,canvas2->getWidth(),canvas2->getHeight());

  // Paint image
  sdc2.drawImage(picture2,0,0);

  return 1;
  }

// Color well got changed
long Fractal::onCmdWell(FXObject*,FXSelector,void*)
{
  canvas->update();
  return 1;
}
// Color well got changed
long Fractal::onCmdWell2(FXObject*,FXSelector,void*)
{
  canvas2->update();
  return 1;
}


// Restore image from off-screen pixmap
long Fractal::onCmdRestore(FXObject*,FXSelector,void*){
canvas->update();
  FXFileDialog savedialog(this,"Save BMP");
  savedialog.setDirectory(".");
  if(savedialog.execute()){
    FXFileStream outfile;
    if(outfile.open(savedialog.getFilename(),FXStreamSave)){
      picture->restore();
      picture->savePixels(outfile);
      outfile.close();
      }
    }
  return 1;
  }


// Here we begin
int main(int argc,char *argv[]){

  // Make application
  FXApp application("Image","FoxText");

  // Start app
  application.init(argc,argv);

  // Make window
  new Fractal(&application);

  // Create the application's windows
  application.create();

  // Run the application
  return application.run();
  }

void Fractal::MakeFrac(int Num)
{
	color_frac=x_dial->getValue();
	Init(Num);
	bool uok;

	for(i=0;i<la;i++)
	{
		for(j=0;j<ha;j++)
		{
			uok=1;

			ax= (double) (i*echelle+Xtmp);
			ay= (double) (j*echelle-Ytmp);

			if(EnJulia->getCheck())
			{
				bx=ax;
				by=ay;
			}

			for(int u=0;u<=100&&norme>bail_min && norme<=300000000000;u++)//300000000000
			{
			
				bxx=bx;
				if(!(EnJulia->getCheck()))
				{
				bx=(double)bx*bx-(double)by*by + ax;
				by=(double) 2.0*bxx*by + ay;
				}else{
				bx=(double)bx*bx-(double)by*by + ConstJuliaX;//Xtmp;
				by=(double) 2.0*bxx*by + ConstJuliaY;//Ytmp;
				}
				norme= (double) sqrt((double)bx*bx+(double)by*by);
				 uok=u;
			}
			if(Num==1) Val[(j*taillex+i)]=norme;
			else if(Num==2) Val2[(j*taillex+i)]=norme;
			ColorFrac(Num,uok);
			ax=0;ay=0;bx=0;by=0;norme=1;
		}
	}


}

void Fractal::RefreshImg(int Num)
{
			FXDCWindow dc(canvas);
			FXDCWindow dc2(canvas2);
	if(Num==1)
	{
		delete Frac;
		Frac=new FXImage(getApp(),ImageFrac,IMAGE_DITHER|IMAGE_SHMI|IMAGE_SHMP,TAILLEX,TAILLEY);
		Frac->create();
		dc.setForeground(FXRGB(0,0,0));
		dc.fillRectangle(0,0,TAILLEX,TAILLEY);
		dc.drawImage(Frac,0,0);
	}else{
		delete Frac2;
		Frac2=new FXImage(getApp(),ImageFrac2,IMAGE_DITHER|IMAGE_SHMI|IMAGE_SHMP,TAILLEMINX,TAILLEMINY);
		Frac2->create();
		dc2.setForeground(FXRGB(0,0,0));
		dc2.fillRectangle(0,0,TAILLEX,TAILLEY);
		dc2.drawImage(Frac2,0,0);
	}
}

void Fractal::ColorFrac(int Num, bool uok)
{

	if(norme<2)
	{		// à l'intérieur 
		if(Num==1)
		{
		ImageFrac[3*(j*taillex+i)]=0;
		ImageFrac[3*(j*taillex+i)+1]=0;
		ImageFrac[3*(j*taillex+i)+2]=255*sin(norme);
		}else{
		ImageFrac2[3*(j*taillex+i)]=0;
		ImageFrac2[3*(j*taillex+i)+1]=0;
		ImageFrac2[3*(j*taillex+i)+2]=255*sin(norme);

		}
	}else{// à l'extérieur
      if(!(j==0 && i==0))
		if(Num==1)
		{
		ImageFrac[3*(j*taillex+i)]=color_frac*(sin(norme/Val[j*taillex+i-1]));
		ImageFrac[3*(j*taillex+i)+1]=color_frac*(sin(norme/Val[j*taillex+i-1]));
		ImageFrac[3*(j*taillex+i)+2]=color_frac*(sin(norme/Val[j*taillex+i-1]));
		}else{
		ImageFrac2[3*(j*taillex+i)]=color_frac*(sin(norme/Val2[j*taillex+i-1]));
		ImageFrac2[3*(j*taillex+i)+1]=color_frac*(sin(norme/Val2[j*taillex+i-1]));
		ImageFrac2[3*(j*taillex+i)+2]=color_frac*(sin(norme/Val2[j*taillex+i-1]));


		}
	}
/*
	if(norme<=bail_min )
	{
		if(Num==1)
		{
		ImageFrac[3*(j*taillex+i)]=255;
		ImageFrac[3*(j*taillex+i)+1]=0;//(255-255.0*((double)bail_min/norme));
		ImageFrac[3*(j*taillex+i)+2]=0;
		}else{
		ImageFrac2[3*(j*taillex+i)]=255;
		ImageFrac2[3*(j*taillex+i)+1]=(255-255.0*((double)bail_min/norme));
		ImageFrac2[3*(j*taillex+i)+2]=0;
		}
	//	if(norme >0.001) 	ImageFrac[3*(j*TAILLEX+i)+2]=255;
	//	ImageFrac[3*(j*TAILLEX+i)+2]=255-100*sqrt(ax*ax+ay*ay);
	//	if((double) sqrt((double)ax*ax+(double)ay*ay) == 0) ImageFrac[3*(j*TAILLEX+i)+1]=255;

	}	else	{
		if(Num==1)
		{
		ImageFrac[3*(j*taillex+i)]=0;
		ImageFrac[3*(j*taillex+i)+1]=0;
		ImageFrac[3*(j*taillex+i)+2]=255*sin(norme);
		}else{
		ImageFrac2[3*(j*taillex+i)]=255*sin(((int)(norme)%255)-2.0*pi/3.0);
		ImageFrac2[3*(j*taillex+i)+1]=255*sin(((int)(norme)%255)-pi/3.0);
		ImageFrac2[3*(j*taillex+i)+2]=255*sin(((int)(norme)%255));

		}

	}

	if(0)
	{
		if(Num==1)
		{
		ImageFrac[3*(j*taillex+i)]=0;
		ImageFrac[3*(j*taillex+i)+1]=0;
		ImageFrac[3*(j*taillex+i)+2]=0;
		}else{
		ImageFrac2[3*(j*taillex+i)]=255;
		ImageFrac2[3*(j*taillex+i)+1]=(255-255.0*((double)bail_min/norme));
		ImageFrac2[3*(j*taillex+i)+2]=0;
		}
	//	if(norme >0.001) 	ImageFrac[3*(j*TAILLEX+i)+2]=255;
	//	ImageFrac[3*(j*TAILLEX+i)+2]=255-100*sqrt(ax*ax+ay*ay);
	//	if((double) sqrt((double)ax*ax+(double)ay*ay) == 0) ImageFrac[3*(j*TAILLEX+i)+1]=255;

	}	else	{
		if(Num==1)
		{
		ImageFrac[3*(j*taillex+i)]=uok;
		ImageFrac[3*(j*taillex+i)+1]=uok;
		ImageFrac[3*(j*taillex+i)+2]=uok;
		}else{
		ImageFrac2[3*(j*taillex+i)]=255*sin(((int)(norme)%255)-2.0*pi/3.0);
		ImageFrac2[3*(j*taillex+i)+1]=255*sin(((int)(norme)%255)-pi/3.0);
		ImageFrac2[3*(j*taillex+i)+2]=255*sin(((int)(norme)%255));

		}

	}*/
}

void Fractal::Init(int Num)
{
	if(Num==1)
	{
		Xtmp=X0;
		Ytmp=Y0;
		echelle=Echel;
		taillex=TAILLEX;
		tailley=TAILLEY;

	}else{

		echelle=Echel2;
		taillex=TAILLEMINX;
		tailley=TAILLEMINY;
	}
	la=taillex;ha=tailley;
	ax=0;ay=0;bx=0;by=0;norme=1;
}

long Fractal::onMouseDown(FXObject*,FXSelector,void * ptr)
{
	FXEvent * ev = (FXEvent *) ptr;
	FXDCWindow dc(canvas);
if(!(JuliaAuto->getCheck()))
{
	switch(EtatZoom)
	{
	case 0:
		CoordZX=ev->win_x;
		CoordZY=ev->win_y;
		CoordZX2=CoordZX;
		CoordZY2=CoordZY;
		CoordZX3=0;
		CoordZX3=0;
		Z1ok=1;
		p1av=0;p2av=0;
		EtatZoom=1;
		break;
	case 1:

		break;
	case 4:
		CoordZX=CoordZX2;
		CoordZY=CoordZY2;

		if(QuelZoom==1||1)
		{
		X0+=(double)CoordZX2*Echel;
		Y0-=(double)CoordZY2*Echel;
		}else{
		X0-=(double)(CoordZX2)*Echel/2.0;
		Y0+=(double)(CoordZY2)*Echel/2.0;
		}

		if(larg==0) larg=20;
		if(QuelZoom==1)
		Echel*=(double)((double)(larg)/TAILLEX);
		else
		Echel*=(double)((double)TAILLEX/(larg));

		MakeFrac(1);
		RefreshImg(1);

		EtatZoom=0;
		QuelZoom=1;

		break;
	case 3:
		CoordZX3=ev->win_x;
		CoordZY3=ev->win_y;	
		IsMove=0;

		if( ev->win_x >= FXMIN(CoordZX,CoordZX2) 
			&&  ev->win_x <= FXMAX(CoordZX,CoordZX2) 
			&&  ev->win_y >= FXMIN(CoordZY,CoordZY2) 
			&&  ev->win_y <= FXMAX(CoordZY,CoordZY2) 
		)		EtatZoom=4;
		else	
		{
		if(echelle!=Echel)	dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
			EtatZoom=0;
		}
			//dc.drawFocusRectangle(CoordZX,CoordZY,p1av,p2av);
		dc.drawFocusRectangle(CoordZX,CoordZY,larg,haut);
		dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);

		break;
	case 5:
		CoordZX3=ev->win_x;
		CoordZY3=ev->win_y;	
		CoordZX=CoordZX2;
		CoordZY=CoordZY2;
		IsMove=0;

		if( ev->win_x >= FXMIN(CoordZX2,CoordZX2+larg) 
			&&  ev->win_x <= FXMAX(CoordZX2,CoordZX2+larg) 
			&&  ev->win_y >= FXMIN(CoordZY2,CoordZY2+haut) 
			&&  ev->win_y <= FXMAX(CoordZY2,CoordZY2+haut) 
		)		EtatZoom=4;
		else
		{
			dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
			EtatZoom=0;
			QuelZoom=1;
		}
			//dc.drawFocusRectangle(CoordZX,CoordZY,p1av,p2av);
	//	dc.drawFocusRectangle(CoordZX,CoordZY,larg,haut);
	//	dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);

		break;
	default:
		EtatZoom=0;
		QuelZoom=1;
		break;
	}
	/*
	if(!Z2ok)
	{
	FXEvent * ev = (FXEvent *) ptr;
		CoordZX=ev->win_x;
		CoordZY=ev->win_y;
		Z1ok=1;
		p1av=0;p2av=0;
	}else{
	}
*/
}else{
	MakeFrac(1);
	RefreshImg(1);
	JuliaAuto->setCheck(0);
}
	return 1;
}

long Fractal::onMouseDown2(FXObject* z,FXSelector zz,void * ptr)
{//

	QuelZoom=-1;
	onMouseDown(z,zz,ptr);

/*
	if(!Z1ok)
	{
	FXEvent * ev = (FXEvent *) ptr;
		CoordZX=ev->win_x;
		CoordZY=ev->win_y;
		Z2ok=1;
		p1av=0;p2av=0;
	}else{
	}*/
	return 1;
}

long Fractal::onMouseUp(FXObject*,FXSelector,void * ptr)
{
	FXEvent * ev = (FXEvent *) ptr;
	switch(EtatZoom)
	{
	case 1:
		CoordZX2=ev->win_x;
		CoordZY2=ev->win_y;		
		EtatZoom=3;
		break;
	case 4:
		if(IsMove==0)
		{
		CoordZX=CoordZX2;
		CoordZY=CoordZY2;
		X0+=(double)CoordZX*Echel;
		Y0-=(double)CoordZY*Echel;

		if(larg==0) larg=20;
		if(QuelZoom==1)
		Echel*=(double)((double)(larg)/TAILLEX);
		else
		Echel*=(double)((double)TAILLEX/(larg));

		MakeFrac(1);
		RefreshImg(1);

		QuelZoom=1;
		EtatZoom=0;
		}else EtatZoom=5;

		break;
	default:
		QuelZoom=1;
		break;
	}
	return 1;
}

long Fractal::onMouseUp2(FXObject* z,FXSelector zz,void * ptr)
{
	
	onMouseUp(z,zz,ptr);

	return 1;
}

long Fractal::onMouseWheel(FXObject* z,FXSelector,void* ptr)
{
	FXEvent * ev = (FXEvent *) ptr;

	FXString Chain;

			if(QuelZoom==1 && ( (ev->code)==65507 || (ev->code)==16777215))
				QuelZoom=-1;
			else if(QuelZoom==-1 && (ev->code)!=65507 && (ev->code)!=16777215 )
			{
				QuelZoom=1;
			}

	FXint x,y;
	FXuint ze=0;
	this->getCursorPosition(x,y,ze);
	Chain= FXStringVal((ze),10)+"-"+FXStringVal((QuelZoom),10);
			InfosCoor2->setText(Chain);
	
		 larg=(TAILLEX/2);

		if(ze==16)
		{
		X0+=(double)(CurX)*Echel/2.0;
		Y0-=(double)(CurY)*Echel/2.0;
		Echel*=(double)((double)(larg)/TAILLEX);
		}else{
		Echel*=(double)((double)TAILLEX/(larg));
		X0-=(double)(CurX)*Echel/2.0;
		Y0+=(double)(CurY)*Echel/2.0;
		}

		MakeFrac(1);
		RefreshImg(1);

		QuelZoom=1;
		EtatZoom=0;

		return 1;
}

long Fractal::onKeyPress(FXObject* z,FXSelector zz,void* ptr)
{
	FXEvent * ev = (FXEvent *) ptr;
	FXString Chain = " key="+ FXStringVal(ev->code,10);
	InfosCoor2->setText(Chain);
	FXDCWindow dc(canvas);

	switch(ev->code)
	{
	case 65421://enter

		EtatZoom=4;
		IsMove=0;
		onMouseUp(z,zz,ptr);
		break;
	case 65293://enter
		EtatZoom=4;
		IsMove=0;
		onMouseUp(z,zz,ptr);
		break;
	case 65307://echap
		if(EtatZoom==5 || EtatZoom==3)
		{
			if( EtatZoom!=3 )	dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
			else if(echelle!=Echel) dc.drawFocusRectangle(CoordZX,CoordZY,larg,haut);
			EtatZoom=0;
			QuelZoom=1;
		}
		break;
	default:
		break;
	}


	return 1;
}

long Fractal::onMouseMove(FXObject*,FXSelector,void * ptr)
{

	int p1,p2;
	FXString Chain;
	IsMove=0;
	FXEvent * ev = (FXEvent *) ptr;
	CurX=ev->win_x;
	CurY=ev->win_y;
	
		if(ev->win_y < TAILLEY && ev->win_x < TAILLEX)
		{	
			Chain= FXStringVal((float)(ev->win_x)*Echel+X0,4,0) + " x " + FXStringVal((float)Y0-(ev->win_y)*Echel,4,0) + " norme="+ FXStringVal((float)(Val[(ev->win_y)*TAILLEX + ev->win_x]/Val[(ev->win_y)*TAILLEX + ev->win_x-1]),10,0);
			InfosCoor->setText(Chain);
		}
	FXDCWindow dc(canvas);
	switch(EtatZoom)
	{
	case 1:

	  if(ev->win_y < TAILLEY && ev->win_x < TAILLEX)
	  {
		if( ev->win_y >= (CoordZX+(ev->win_x-CoordZX)*TAILLEY/TAILLEX) && ev->win_x <= (CoordZY+(ev->win_y-CoordZY)*TAILLEX/TAILLEY) ) 
			{
				p1=((ev->win_y-CoordZY)*TAILLEX/TAILLEY);
				p2=ev->win_y-CoordZY;

			}else if(ev->win_x >= (CoordZY+(ev->win_y-CoordZY)*TAILLEX/TAILLEY) &&  ev->win_y >= (CoordZX+(ev->win_x-CoordZX)*TAILLEY/TAILLEX)) {
				p2=((ev->win_x-CoordZX)*TAILLEY/TAILLEX);
				p1=ev->win_x-CoordZX;
			}else {
				p2=((ev->win_x-CoordZX)*TAILLEY/TAILLEX);
				p1=ev->win_x-CoordZX;
			}		//canvas->update();

			if(abs(p1)>=1 && abs(p2)>=1) dc.drawFocusRectangle(CoordZX,CoordZY,p1av,p2av);
			dc.drawFocusRectangle(CoordZX,CoordZY,p1,p2);
			larg=p1;
			haut=p2;
			p1av=p1;p2av=p2;


			RefreshMin(ev->win_x-CoordZX);
	  }
		break;
	case 4:
			dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);

			CoordZX2=CoordZX+(ev->win_x-CoordZX3);
			CoordZY2=CoordZY+(ev->win_y-CoordZY3);


			dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);

	  		p1av=ev->win_x;p2av=ev->win_y;
		    IsMove=1;
			RefreshMin(larg);
		break;
	default:
		if(EnJulia->getCheck() && JuliaAuto->getCheck())
		{
			ConstJuliaX=X0+(double)(ev->win_x)*Echel;
			ConstJuliaY=Y0-(double)(ev->win_y)*Echel;

			JuliaX->setText("x="+FXStringVal(ConstJuliaX));
			JuliaY->setText("y="+FXStringVal(ConstJuliaY));
			if(larg==0) larg=TAILLEX;
			RefreshMin(larg);
		}
		break;
	}

	return 1;
}

long Fractal::onCmdAbout(FXObject*,FXSelector,void * ptr)
{

	FXMessageBox about(this,"About FrAcTal 0.1","Logiciel de création de fractales\nAuteur : Julien MICHOT\nemail : m.i.t.c.h@free.fr\nsite : www.fractals.fr.fm",NULL,MBOX_OK|DECOR_TITLE|DECOR_BORDER);
	about.execute();

	return 1;
}

void Fractal::RefreshMin(int nblarg)
{

	if(QuelZoom==1)
	{
		if(!(JuliaAuto->getCheck()))
		{
			Xtmp=X0+(double)CoordZX2*Echel;
			Ytmp=Y0-(double)CoordZY2*Echel;
		}else{
		}
			Echel2=(double)(Echel*(TAILLEX/TAILLEMINX)*(double)(nblarg)/TAILLEX);
	}else{
		if(!(JuliaAuto->getCheck()))
		{
			Xtmp=X0+(double)CoordZX2*Echel;
			Ytmp=Y0-(double)CoordZY2*Echel;
		}

		if( (nblarg) !=0)
				Echel2=(double)(Echel*(TAILLEX/TAILLEMINX)*(double)TAILLEX/(nblarg));
		else 		Echel2=(double)(Echel*(TAILLEX/TAILLEMINX)*(double)TAILLEX/(20.0));
	}
			MakeFrac(2);
			RefreshImg(2);
}

long Fractal::onJulia(FXObject*,FXSelector,void*)
{
this->setDefaultCursor(cursorautre);

	if((!EnJulia->getCheck()) || JuliaX->getText()!="" )
	{
		MakeFrac(1);
		RefreshImg(1);
	}
	MakeFrac(2);
	RefreshImg(2);


	return 1;
}
long Fractal::onReset(FXObject*,FXSelector,void*)
{
		bail_min=0.003;
		Echel=0.005*(800/TAILLEX);
		Echel2=0.005*(800/TAILLEMINX);
		X0=(double) -2.1;
		Y0=(double)  1.3;
		Z1ok=0;Z2ok=0;Ok=0;
		larg=0;
		EtatZoom=0;
		QuelZoom=1;
		EnJulia->setCheck(0);
		JuliaAuto->setCheck(0);
		MakeFrac(1);
		RefreshImg(1);
		return 1;
}

long Fractal::onLeftBtnPress(FXObject*,FXSelector,void*)
{EnJulia->setCheck(1);
		MakeFrac(2);
		RefreshImg(2);
	return 1;
}