/*
 * Kreslitko je program na kreslenie objektov - konkretne ide len
 * o sled useciek, ale tym sa da nakreslit dost, hm?
 *
 * Richard Richter, 97703, 7. zadanie
 *
 * Objekt sa kresli bod po bode lavym tlacitkom a kreslenie sa
 * konci pravym tlacitkom. Nakresleny objekt mozno presuvat,
 * rotovat a zmensovat - objekt oznacime kliknutim do jeho blizkosti
 * (nejakeho jeho bodu). Okrem toho je mozne presuvat samotne
 * body objektu.
 */

#include <fox/fx.h>

class polygon : public FXObject {
public:
	int		uzavrety;	// ak 1, tak je to uzavrety polygon
	FXObjectList	zoznam;		// zoznam uzlov (FXPoint)
	};

// Mody, v ktorych moze byt kreslitko
#define	M_BASE		0
#define	M_POLYLINE	1
#define	M_POLYGON	2
#define M_KRESLENIE	3
#define	M_SCALINGS	4
#define	M_ROTATINGS	8
#define	M_SCALING	16
#define	M_ROTATING	32
#define M_MANIPS	60	// manipulacia (akakolvek)
#define M_MANIPSF	12	// manipulacia - start bod... (prva faza)
#define M_MANIPSS	48	// manipulacia - normalovy bod... (druha faza)

// Tu zacina nase hlavne okno
class Kreslitko : public FXMainWindow {

	FXDECLARE(Kreslitko)

private:
	FXVerticalFrame		*obsah;		// hlavny ram
	FXCanvas		*plocha;	// plocha pre obraz
	FXImage			*pamat;		// pamat obrazu
	FXObjectList		*objekty;	// zoznam polygonov
	FXStatusbar		*status;	// status, co ineho
	FXMenuPane		*subormenu;	// menu
	FXMenuPane		*objektmenu;
	FXMenuPane		*manipmenu;
	FXMenuPane		*pomocmenu;
	FXPoint			*kreslenybod;	// kresleny bod
	FXPoint			*chytenybod;	// chyteny bod
	FXint			chytenydx;	// odchylka chytenia
	FXint			chytenydy;
	FXPoint			startbod;	// startovaci bod (rot, size)
	FXPoint			normbod;	// normalovy bod (rot, size)
	FXPoint			manipbod;	// manipulacny bod (rot, size)
	FXint			xormala;	// velkost x-normaly (norm-start)
	FXint			yormala;	// velkost y-normaly (norm-start)
	double			alpha;		// uhol na zaciatku rotacia
	polygon			*vyber;		// vybrany objekt
	polygon			*original;	// original manipulacie
	FXint			statdirty;	// obnovovanie statu
	FXint			lbutton_move;	// ma sa sledovat pohyb mysi?
	FXint			mod;		// mod
/*
 * Ak je mod POLYGON alebo POLYLINE - je nastavene kreslenie.
 */

protected:
	Kreslitko() {}

public:
	long onPaint(FXObject*,FXSelector,void *);
	long onResize(FXObject*,FXSelector,void *);
	long onUpdStat(FXObject*,FXSelector,void *);
	long onMBL(FXObject*,FXSelector,void *);
	long onMBLrel(FXObject*,FXSelector,void *);
	long onMMove(FXObject*,FXSelector,void *);
	long onMBR(FXObject*,FXSelector,void *);
	long cmdZmaz(FXObject*,FXSelector,void *);
	long cmdPolygon(FXObject*,FXSelector,void *);
	long cmdPolyline(FXObject*,FXSelector,void *);
	long cmdRotacia(FXObject*,FXSelector,void *);
	long cmdVelkost(FXObject*,FXSelector,void *);

	void VykresliScenu(void);
	polygon *closeto(FXint x,FXint y);
	

// Spravy naseho kreslitka
	enum {
		ID_PLOCHA=FXMainWindow::ID_LAST,
		ID_POLYGON,
		ID_POLYLINE,
		ID_ZMAZ,
		ID_ROTACIA,
		ID_VELKOST,
		ID_HELP,
		ID_STATUS,
		ID_LAST
		};

// Konstruktor a destruktor
	Kreslitko(FXApp *a);
	~Kreslitko();

// Inicializacia
	virtual void create();
	};	// Koniec deklaracie triedy


// Mapa udalosti a sprav
FXDEFMAP(Kreslitko) KreslitkoMap[] = {
FXMAPFUNC(SEL_COMMAND,		Kreslitko::ID_ZMAZ,	Kreslitko::cmdZmaz),
FXMAPFUNC(SEL_COMMAND,		Kreslitko::ID_POLYGON,	Kreslitko::cmdPolygon),
FXMAPFUNC(SEL_COMMAND,		Kreslitko::ID_POLYLINE,	Kreslitko::cmdPolyline),
FXMAPFUNC(SEL_COMMAND,		Kreslitko::ID_ROTACIA,	Kreslitko::cmdRotacia),
FXMAPFUNC(SEL_COMMAND,		Kreslitko::ID_VELKOST,	Kreslitko::cmdVelkost),
FXMAPFUNC(SEL_PAINT,		Kreslitko::ID_PLOCHA,	Kreslitko::onPaint),
FXMAPFUNC(SEL_CONFIGURE,	Kreslitko::ID_PLOCHA,	Kreslitko::onResize),
FXMAPFUNC(SEL_LEFTBUTTONRELEASE,Kreslitko::ID_PLOCHA,	Kreslitko::onMBLrel),
FXMAPFUNC(SEL_LEFTBUTTONPRESS,	Kreslitko::ID_PLOCHA,	Kreslitko::onMBL),
FXMAPFUNC(SEL_MOTION,		Kreslitko::ID_PLOCHA,	Kreslitko::onMMove),
FXMAPFUNC(SEL_RIGHTBUTTONPRESS,	Kreslitko::ID_PLOCHA,	Kreslitko::onMBR),
FXMAPFUNC(SEL_UPDATE,		Kreslitko::ID_STATUS,	Kreslitko::onUpdStat),
};

FXIMPLEMENT(Kreslitko,FXMainWindow,KreslitkoMap,ARRAYNUMBER(KreslitkoMap))


// Vytvorenie okna
Kreslitko::Kreslitko(FXApp *a):FXMainWindow(a,"Kreslitko",NULL,NULL,DECOR_ALL,0,0,782,530) {
	// Pruh menu
	FXMenubar *menubar=new FXMenubar(this,LAYOUT_SIDE_TOP|LAYOUT_FILL_X);
	// Menu subor
	subormenu=new FXMenuPane(this);
	new FXMenuTitle(menubar,"&Subor",NULL,subormenu);
	new FXMenuCommand(subormenu,"&Koniec\tCtrl-K",NULL,a,FXApp::ID_QUIT);
	// Menu objekt
	objektmenu=new FXMenuPane(this);
	new FXMenuTitle(menubar,"&Objekt",NULL,objektmenu);
	new FXMenuCommand(objektmenu,"&Polygon\tCtrl-P",NULL,this,ID_POLYGON);
	new FXMenuCommand(objektmenu,"&Lomena ciara\tCtrl-L",NULL,this,ID_POLYLINE);
	// Menu manipulacie
	manipmenu=new FXMenuPane(this);
	new FXMenuTitle(menubar,"&Manipulacie",NULL,manipmenu);
	new FXMenuCommand(manipmenu,"&Rotacia objektu\tCtrl-R",NULL,this,ID_ROTACIA);
	new FXMenuCommand(manipmenu,"&Skalovanie objektu\tCtrl-S",NULL,this,ID_VELKOST);
	new FXMenuCommand(manipmenu,"&Zmazanie objektu\tCtrl-D",NULL,this,ID_ZMAZ);
	// Menu napovedy (pomoc)
	pomocmenu=new FXMenuPane(this);
	new FXMenuTitle(menubar,"&Pomoc",NULL,pomocmenu,LAYOUT_RIGHT);
	new FXMenuCommand(pomocmenu,"Napoveda\tF1",NULL,this,ID_HELP);

	// Status
	status=new FXStatusbar(this,LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X);
	status->getStatusline()->setTarget(this);
	status->getStatusline()->setSelector(ID_STATUS);

	// Zvysok okna
	obsah=new FXVerticalFrame(this,LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y,0,0,0,0, 0,0,0,0);
	  new FXLabel(obsah,"Tu bude / je obraz",NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);
	  new FXHorizontalSeparator(obsah,SEPARATOR_GROOVE|LAYOUT_FILL_X);
	  plocha=new FXCanvas(obsah,this,ID_PLOCHA,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT);

	pamat=new FXImage(a,NULL,BITMAP_OWNED,plocha->getWidth(),plocha->getHeight());
	objekty=new FXObjectList;
	vyber=NULL;
	original=NULL;
	kreslenybod=NULL;
	chytenybod=NULL;
	statdirty=1;
	lbutton_move=0;
	mod=M_BASE;
	}

Kreslitko::~Kreslitko() {
	delete subormenu;
	delete objektmenu;
	delete manipmenu;
	delete pomocmenu;
	delete pamat;
	delete objekty;
	}

// Vytvorenie naseho okna
void Kreslitko::create() {
	pamat->create();
	FXMainWindow::create();
	VykresliScenu();
	show();
	}


long Kreslitko::onResize(FXObject*,FXSelector,void *) {
	FXDCWindow dc(plocha);

	pamat->destroy();
	delete pamat;
	pamat=new FXImage(getApp(),NULL,BITMAP_OWNED,plocha->getWidth(),plocha->getHeight());
	pamat->create();
	VykresliScenu();
	return 1;
	}

long Kreslitko::onPaint(FXObject*,FXSelector,void *) {
	FXDCWindow dc(plocha);

	dc.drawImage(pamat,0,0);
	return 1;
	}

// Obnova statusu
long Kreslitko::onUpdStat(FXObject* sender,FXSelector,void *) {
	char	buf[512],*mode;
	int	i;

	if (statdirty) {
		FXStatusline *statusline=(FXStatusline *) sender;
		switch(mod) {
			case M_BASE:
				mode="zakladny";
				break;
			case M_POLYLINE:
				mode="lomena ciara";
				break;
			case M_POLYGON:
				mode="polygon";
				break;
			case M_SCALINGS:
				mode="zmena velkosti - vztazny bod";
				break;
			case M_SCALING:
				mode="zmena velkosti";
				break;
			case M_ROTATINGS:
				mode="rotacia - vztazny bod";
				break;
			case M_ROTATING:
				mode="rotacia";
				break;
			default:
				mode="???";
				break;
			}
		if (objekty->find(i,vyber)) sprintf(buf,"Objektov: %d   Vybrany: %d   Mod: %s",objekty->no(),i,mode);
		else sprintf(buf,"Objektov: %d   Prazdny vyber   Mod: %s",objekty->no(),mode);
		statusline->setText(buf);
		statdirty=0;
		}
	return 1;
	}

// Lave tlacitko mysi na ploche - pustenie
long Kreslitko::onMBLrel(FXObject*,FXSelector,void *ptr) {
	FXEvent *ev=(FXEvent *) ptr;
	FXint	dx;
	FXint	dy;
	int	mj,j;
	double	myrmala,mxrmala,beta,dist,gama;
	FXPoint	*n;

	lbutton_move=0;
	if (mod & M_KRESLENIE) {
		if (vyber) {
			kreslenybod->x=ev->win_x,kreslenybod->y=ev->win_y;
			}
		else {
			vyber=new polygon;
			if (mod & M_POLYGON) vyber->uzavrety=1;
			else vyber->uzavrety=0;
			kreslenybod=new FXPoint();
			kreslenybod->x=ev->win_x,kreslenybod->y=ev->win_y;
			vyber->zoznam.append((FXObject *)kreslenybod);
			objekty->append(vyber);
			}
		}
	if (mod==M_BASE && vyber) {
	       	if (chytenybod) chytenybod->x=ev->win_x+chytenydx,chytenybod->y=ev->win_y+chytenydy;
		else {
			dx=ev->win_x-ev->last_x;
			dy=ev->win_y-ev->last_y;
			mj=vyber->zoznam.no();
			for (j=0; j<mj; j++) {
				n=(FXPoint *)(vyber->zoznam.list()[j]);
				n->x+=dx;
				n->y+=dy;
				}
			}
		}
	manipbod.x=ev->win_x;
	manipbod.y=ev->win_y;
	if (mod & M_SCALING) {
		mxrmala=(double)(manipbod.x-startbod.x)/xormala;
		myrmala=(double)(manipbod.y-startbod.y)/yormala;
		mj=vyber->zoznam.no();
		for (j=0; j<mj; j++) {
			n=(FXPoint *)(original->zoznam.list()[j]);
			dx=n->x-startbod.x;
			dy=n->y-startbod.y;
			n=(FXPoint *)(vyber->zoznam.list()[j]);
			n->x=(int)(startbod.x+(dx*mxrmala));
			n->y=(int)(startbod.y+(dy*myrmala));
			}
		mod=M_SCALINGS;
		delete original;
		original==NULL;
		}
	else if (mod & M_ROTATING) {
		mxrmala=(double)(manipbod.x-startbod.x);
		myrmala=(double)(manipbod.y-startbod.y);
		beta=atan(myrmala/mxrmala);
		if (mxrmala<0) beta+=PI;
		beta-=alpha;
		mj=vyber->zoznam.no();
		for (j=0; j<mj; j++) {
			n=(FXPoint *)(original->zoznam.list()[j]);
			dx=n->x-startbod.x;
			dy=n->y-startbod.y;
			gama=atan((double)dy/dx);
			if (dx<0) gama+=PI;
			dist=sqrt((n->x-startbod.x)*(n->x-startbod.x)+(n->y-startbod.y)*(n->y-startbod.y));
			n=(FXPoint *)(vyber->zoznam.list()[j]);
			n->x=(int)(startbod.x+dist*cos(beta+gama));
			n->y=(int)(startbod.y+dist*sin(beta+gama));
			}
		mod=M_ROTATINGS;
		original==NULL;
		}
	else if (mod & M_MANIPSF) {
		startbod.x=ev->win_x;
		startbod.y=ev->win_y;
		if (mod & M_SCALINGS) mod=M_SCALING;
		else mod=M_ROTATING;
		}
	chytenybod=NULL;
	statdirty=1;
	VykresliScenu();
	return 1;
	}

// Lave tlacitko mysi na ploche - stlacenie
long Kreslitko::onMBL(FXObject*,FXSelector,void *ptr) {
	FXEvent *ev=(FXEvent *) ptr;
	int i,mi;
	FXPoint	*p;

	lbutton_move=1;
	if ((mod & M_KRESLENIE) && vyber) {
		kreslenybod=new FXPoint();
		kreslenybod->x=ev->win_x,kreslenybod->y=ev->win_y;
		vyber->zoznam.append((FXObject *)kreslenybod);
		}
	if (mod==M_BASE) {
		vyber=closeto(ev->win_x,ev->win_y);
		}
	if (mod & M_MANIPSS) {
		normbod.x=ev->win_x;
		normbod.y=ev->win_y;
		xormala=normbod.x-startbod.x; if (!xormala) xormala=1;
		yormala=normbod.y-startbod.y; if (!yormala) yormala=1;
		manipbod.x=ev->win_x;
		manipbod.y=ev->win_y;
		alpha=atan((double)yormala/xormala);
		if (xormala<0) alpha+=PI;
		original=new polygon;
		original->uzavrety=vyber->uzavrety;
		mi=vyber->zoznam.no();
		for (i=0; i<mi; i++) {
			p=new FXPoint;
			p->x=((FXPoint *)(vyber->zoznam.list()[i]))->x;
			p->y=((FXPoint *)(vyber->zoznam.list()[i]))->y;
			original->zoznam.append((FXObject *)p);
			}
		}
	statdirty=1;
	VykresliScenu();
	return 1;
	}

// Pohyb mysi po ploche
long Kreslitko::onMMove(FXObject*,FXSelector,void *ptr) {
	FXEvent *ev=(FXEvent *) ptr;
	FXint	dx;
	FXint	dy;
	int	mj,j;
	double	myrmala,mxrmala,beta,gama,dist;
	FXPoint	*n;

	if (!lbutton_move) return 1;
	if ((mod & M_KRESLENIE) && vyber) kreslenybod->x=ev->win_x,kreslenybod->y=ev->win_y;
	if (mod==M_BASE && vyber) {
	       	if (chytenybod) chytenybod->x=ev->win_x+chytenydx,chytenybod->y=ev->win_y+chytenydy;
		else {
			dx=ev->win_x-ev->last_x;
			dy=ev->win_y-ev->last_y;
			mj=vyber->zoznam.no();
			for (j=0; j<mj; j++) {
				n=(FXPoint *)(vyber->zoznam.list()[j]);
				n->x+=dx;
				n->y+=dy;
				}
			}
		}
	manipbod.x=ev->win_x;
	manipbod.y=ev->win_y;
	if (mod & M_SCALING) {
		mj=vyber->zoznam.no();
		mxrmala=(double)(manipbod.x-startbod.x)/xormala;
		myrmala=(double)(manipbod.y-startbod.y)/yormala;
		for (j=0; j<mj; j++) {
			n=(FXPoint *)(original->zoznam.list()[j]);
			dx=n->x-startbod.x;
			dy=n->y-startbod.y;
			n=(FXPoint *)(vyber->zoznam.list()[j]);
			n->x=(int)(startbod.x+(dx*mxrmala));
			n->y=(int)(startbod.y+(dy*myrmala));
			}
		}
	if (mod & M_ROTATING) {
		mxrmala=(double)(manipbod.x-startbod.x);
		myrmala=(double)(manipbod.y-startbod.y);
		beta=atan(myrmala/mxrmala);
		if (mxrmala<0) beta+=PI;
		beta-=alpha;
		mj=vyber->zoznam.no();
		for (j=0; j<mj; j++) {
			n=(FXPoint *)(original->zoznam.list()[j]);
			dx=n->x-startbod.x;
			dy=n->y-startbod.y;
			gama=atan((double)dy/dx);
			if (dx<0) gama+=PI;
			dist=sqrt((n->x-startbod.x)*(n->x-startbod.x)+(n->y-startbod.y)*(n->y-startbod.y));
			n=(FXPoint *)(vyber->zoznam.list()[j]);
			n->x=(int)(startbod.x+dist*cos(beta+gama));
			n->y=(int)(startbod.y+dist*sin(beta+gama));
			}
		}
	statdirty=1;
	VykresliScenu();
	return 1;
	}

// Prave tlacitko mysi na ploche
long Kreslitko::onMBR(FXObject*,FXSelector,void *ptr) {
	FXEvent *ev=(FXEvent *) ptr;

	if (!vyber) mod=M_BASE;
	kreslenybod=NULL;
	vyber=NULL;
	statdirty=1;
	if (mod & M_MANIPS) mod=M_BASE;
	VykresliScenu();
	return 1;
	}

// Mazanie
long Kreslitko::cmdZmaz(FXObject*,FXSelector,void *) {
	if (chytenybod) {
		vyber->zoznam.remove((FXObject *)chytenybod);
		delete chytenybod;
		chytenybod=NULL;
		if (!vyber->zoznam.no()) {
			objekty->remove((FXObject *)vyber);
			delete vyber;
			vyber=NULL;
			}
		VykresliScenu();
		statdirty=1;
		}
	else if (vyber) {
		objekty->remove((FXObject *)vyber);
		delete vyber;
		vyber=NULL;
		kreslenybod=NULL;
		VykresliScenu();
		statdirty=1;
		}
	return 1;
	}

// Kreslenie polygonu
long Kreslitko::cmdPolygon(FXObject*,FXSelector,void *) {
	mod=M_POLYGON;
	statdirty=1;
	vyber=NULL;
	kreslenybod=NULL;
	VykresliScenu();
	return 1;
	}

// Kreslenie polylajny
long Kreslitko::cmdPolyline(FXObject*,FXSelector,void *) {
	mod=M_POLYLINE;
	statdirty=1;
	vyber=NULL;
	kreslenybod=NULL;
	VykresliScenu();
	return 1;
	}

// Rotacia objektu
long Kreslitko::cmdRotacia(FXObject*,FXSelector,void *) {
	if (vyber) {
		mod=M_ROTATINGS;
		statdirty=1;
		kreslenybod=NULL;
		}
	return 1;
	}

// Rotacia objektu
long Kreslitko::cmdVelkost(FXObject*,FXSelector,void *) {
	if (vyber) {
		mod=M_SCALINGS;
		statdirty=1;
		kreslenybod=NULL;
		}
	return 1;
	}

// Vykreslenie objektov
void Kreslitko::VykresliScenu(void) {
        FXDCWindow dc(pamat);
        FXDCWindow dcpl(plocha);
        int i,j,mi,mj;
	polygon *p;
	FXPoint	*n,*prev;

        dc.setForeground(FXRGB(255,255,255));
        dc.fillRectangle(0,0,pamat->getWidth(),pamat->getHeight());
	mi=objekty->no();
        for (i=0; i<mi; i++) {
		p=(polygon *)(objekty->list()[i]);
                mj=p->zoznam.no();
		for (j=0; j<mj; j++) {
			n=(FXPoint *)(p->zoznam.list()[j]);
			dc.setForeground(FXRGB(0,0,0));
			if (!j) dc.drawPoint(n->x,n->y);
			else {
				prev=(FXPoint *)(p->zoznam.list()[j-1]);
				dc.drawLine(prev->x,prev->y,n->x,n->y);
				}
			if (vyber==p) {
				dc.setForeground(FXRGB(0,0,255));
				dc.drawArc(n->x-3,n->y-3,6,6,0,360*64);
				}
			}
		prev=(FXPoint *)(p->zoznam.list()[0]);
		dc.setForeground(FXRGB(0,0,0));
		if (p->uzavrety) dc.drawLine(n->x,n->y,prev->x,prev->y);
                }
	if (mod & M_MANIPSS) {
		dc.setForeground(FXRGB(255,0,0));
		dc.drawArc(startbod.x-5,startbod.y-5,10,10,0,360*64);
		if (lbutton_move) {
			dc.setForeground(FXRGB(0,255,0));
			dc.drawArc(normbod.x-5,normbod.y-5,10,10,0,360*64);
			dc.setForeground(FXRGB(0,0,255));
			dc.drawLine(startbod.x,startbod.y,manipbod.x,manipbod.y);
			}
		}
	pamat->render();
	dcpl.drawImage(pamat,0,0);
        }

// Vrati polygon, ktory je blizko (alebo NULL)
polygon *Kreslitko::closeto(FXint x,FXint y) {
        int i,j,mi,mj,best,dist;
	double	ddist,dbest;
	polygon *p,*ret;
	FXPoint	*n,*prev;

	ret=NULL;
	chytenybod=NULL;
	best=5;	// tolerancia je maximalne 4 - tj. pat je uz vela
	mi=objekty->no();
	// prejdeme po bodoch
        for (i=0; i<mi; i++) {
		p=(polygon *)(objekty->list()[i]);
                mj=p->zoznam.no();
		for (j=0; j<mj; j++) {
			n=(FXPoint *)(p->zoznam.list()[j]);
			dist=(int)sqrt((n->x-x)*(n->x-x)+(n->y-y)*(n->y-y));
			if (dist<best) {
				best=dist;
				chytenybod=n;
				ret=p;
				chytenydx=n->x-x;
				chytenydy=n->y-y;
				}
			}
		}
	// ak sme chytili bod, koncime
	if (ret) return ret;
	// inak pojdeme po useckach (uz sa tesim)
	// tu je diametralne iny sposob vypoctu
	// tolerancie... na krajoch je mensia - uprostred vacsia...
	dbest=1;
        for (i=0; i<mi; i++) {
		p=(polygon *)(objekty->list()[i]);
                mj=p->zoznam.no();
		for (j=0; j<mj; j++) {
			n=(FXPoint *)(p->zoznam.list()[j]);
			if (j<(mj-1)) prev=(FXPoint *)(p->zoznam.list()[j+1]);
			else if (p->uzavrety) prev=(FXPoint *)(p->zoznam.list()[0]);
			ddist=sqrt((n->x-x)*(n->x-x)+(n->y-y)*(n->y-y))
				    +sqrt((x-prev->x)*(x-prev->x)+(y-prev->y)*(y-prev->y))
				    -sqrt((n->x-prev->x)*(n->x-prev->x)+(n->y-prev->y)*(n->y-prev->y));
			if (ddist<dbest) {
				dbest=ddist;
				ret=p;
				}
			}
		}
	return ret;
	}

// Hlavny program
int main(int argc,char **argv) {
	FXApp app("Kreslitko","Seriozna aplikacia");
	app.init(argc,argv);
	new Kreslitko(&app);
	app.create();
	return app.run();
	}

//Mknmm8m.