代码编辑器

#ifndef NDEBUG
#error  NDEBUG
#endif 
#ifndef _M_X64
#error  _M_X64
#endif 
#include<Windows.h>
#include<stdio.h>
#include<imm.h>
#pragma comment(lib,"imm32.lib")

#define nof(a) (sizeof(a)/sizeof(*(a)))

typedef signed __int8  s8 ;
typedef signed __int16 s16 ;
typedef signed __int32 s32 ;
typedef signed __int64 s64,ii;

typedef unsigned __int8  u8 ;
typedef unsigned __int16 u16 ;
typedef unsigned __int32 u32 ;
typedef unsigned __int64 u64,uu;

#define err             {printf("%s(%i):",__FILE__,__LINE__);::ExitProcess(0);}
#define err0(v) if(!(v)){printf("%s(%i):",__FILE__,__LINE__);::ExitProcess(0);}
#define outi(i) printf("[%s]=[%i]\n",#i,i);
#define outx(i) printf("[%s]=[0x%X]\n",#i,i);
#define outs(i) printf("[%s]=[%s]\n",#i,i);
#define rgb(c) (u32(u8(c))|u32(u8(c))<<8|u32(u8(c))<<16)

#define char_tab '\t'
#define char_ret '\n'
#define char_min ' '
#define char_max '~'


void main();
int WINAPI WinMain (HINSTANCE,HINSTANCE,LPSTR,int){
	main();
	::ExitProcess(0);
	return 0;
}


void clip_set(const char*s,u64 n=0){
	if(n==0)while(s[n])n++;;
	if(n==0)return;//////////////
	if(OpenClipboard(0)){
		EmptyClipboard(); 
		HANDLE h=GlobalAlloc(GMEM_MOVEABLE,n+16);if(h){
			char*d=(char*)GlobalLock(h);if(d){
				for(u64 i=0;i<n;i++)d[i]=s[i];
				d[n]=0;

				GlobalUnlock(h);}

		}	
		::SetClipboardData(CF_TEXT,h);
	}
	CloseClipboard();
}
void file_set(const char*sa,u64 sn,const char*file_name,ii is_add=0){
	if(sn==0)while(sa[sn])sn++;;
	if(sn==0)return;/////////////

	HANDLE file=::CreateFile(file_name,GENERIC_WRITE,0,0,CREATE_NEW,0,0);
	if(INVALID_HANDLE_VALUE==file){
		if(is_add){
			file=::CreateFile(file_name,GENERIC_WRITE,0,0,OPEN_EXISTING,0,0);
			::SetFilePointer(file,0,0,FILE_END);
		}else{
			file=::CreateFile(file_name,GENERIC_WRITE,0,0,TRUNCATE_EXISTING,0,0);
		}
	}
	if(INVALID_HANDLE_VALUE!=file){
		u64 size=sn;
		sn=0;
		while(size){
			u32 n=size>>32?-1:size;
			size-=n;

			WriteFile(file,sa+sn,n,0,0);
			sn+=n;
		}
		::CloseHandle(file);
	}
}

u64 clip_get(char*da,u64 dn=-1){
	dn--;
	u64 n=0;
	if(IsClipboardFormatAvailable(CF_TEXT)){
		if(OpenClipboard(0)){
			HANDLE h=GetClipboardData(CF_TEXT);if(h){
				char*s=(char*)GlobalLock(h);
				if(s){
					for(n=0;s[n]&&n<dn;n++)da[n]=s[n];
					GlobalUnlock(h);
				}
			}
			CloseClipboard();
		}
	}
	da[n]=0;
	return n;
}
u64 file_get(char*da,const char*file_name){
	u64 dn=0;
	HANDLE file=::CreateFile(file_name,GENERIC_READ,0,0,OPEN_EXISTING,0,0);
	if(INVALID_HANDLE_VALUE!=file){
		u64 size=0;
		::GetFileSizeEx(file,(PLARGE_INTEGER)&size);
		for(u64 i=0;i<size;i++)da[i]=0;
		const u32 n_max=1024*1024*1024;
		while(size){
			u32 n=n_max<=size?n_max:size;
			size-=n;
		
			DWORD n_read=0;
			::ReadFile(file,da+dn,n,&n_read,0);
			if(n_read==n){
				dn+=n;
			}else{
				dn=0;
				break;
			}
		}
		::CloseHandle(file);
	}
	da[dn]=0;
	return dn;
}

bool utf8_is(ii nbits,u64 i,const u8*a,u64 n){
	return i<n&&(uu(a[i])>>nbits)==(1<<(8-nbits))-2;
}
u64 utf8_get(ii nbits,u64 i,const u8*a){
	return uu(a[i])&((1<<nbits)-1);
}
char*utf8_cpy(char*d,const void*sa,ii sn){
	const u8*a=(const u8*)sa;
	ii n=sn;
	if(n>=3&&a[0]==0xef&&a[1]==0xbb&&a[2]==0xbf){
		a+=3;
		n-=3;
	}
	for(ii i=0;i<n;){
		if(1
			&&utf8_is(7,i,a,n)
			){
				wchar_t c=0
					|utf8_get(7,i,a)<<6*0
					;
				*d++=c;
				i+=1;
				continue;
		}
		if(1
			&&utf8_is(5,i+0,a,n)
			&&utf8_is(6,i+1,a,n)
			){
				wchar_t c=0
					|utf8_get(5,i+0,a)<<6*1
					|utf8_get(6,i+1,a)<<6*0
					;
				ii dn=::WideCharToMultiByte(0,0,&c,1,d,100,0,0);
				if(dn>0){
					d+=dn;
				}else{
					return 0;///////////
				}
				i+=2;
				continue;///////////

		}
		if(1
			&&utf8_is(4,i+0,a,n)
			&&utf8_is(6,i+1,a,n)
			&&utf8_is(6,i+2,a,n)
			){
				wchar_t c=0
					|utf8_get(4,i+0,a)<<6*2
					|utf8_get(6,i+1,a)<<6*1
					|utf8_get(6,i+2,a)<<6*0
					;


				ii dn=::WideCharToMultiByte(0,0,&c,1,d,100,0,0);
				if(dn>0){
					d+=dn;
				}else{
					return 0;///////////
				}

				i+=3;
				continue;///////////

		}
		
		return 0;
	}
	return d;
}
u64 utf8(char*da,const char*file_name){
	char*a=da;
	u64  n=file_get(a,file_name);
	a[n]=0;
	if(n==0)return n;/////////////
	//[*(WORD*)a=0xfeff][*(WORD*)a=0xfffe]
	if(n>=2){
		if(*(WORD*)a==0xfffe){
			*(WORD*)a=0xfeff;
			for(u64 i=1;i<n/2;i++)*((WORD*)a+i)=_byteswap_ushort(*((WORD*)a+i));
		}
		if(*(WORD*)a==0xfeff){
			char*d=a;
			for(u64 i=1;i<n/2;i++){
				char sa[100]={};
				ii sn=::WideCharToMultiByte(0,0,(wchar_t*)((WORD*)a+i),1,sa,nof(sa),0,0);
				if(sn>2)sn=2;
				//d+=cpy8(d,sa,sn);
				for(ii si=0;si<sn;si++)*d++=sa[si];
			}
			n=d-a;
			a[n]=0;

			return n;/////////
		}
	}

	char*ea=a+n;
	for(ii i=0;i<n*2;i++)ea[i]=0;
	char*eb=utf8_cpy(ea,a,n);
	if(eb){
		ii en=eb-ea;
		for(ii i=0;i<en;i++)a[i]=ea[i];
		n=en;
	}
	a[n]=0;
	return n;
}

int cmp(const char*d,const char*s){
	for(int i=0;1;i++){
		if(s[i]==0)return 1;
		if(s[i]!=d[i])return 0;
	}
}
int cmp0(const char*d,const char*s){
	for(int i=0;1;i++){
		if(s[i]!=d[i])return 0;
		if(s[i]==0)return 1;
	}
}
int geterr(){
	const int id=GetLastError();if(id==0)return 0;
	char a[0x1000]={};
	FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM,0,id,0,a,sizeof(a),0);
	outs(a);
	return 1;
}
#define funerr  if(geterr()){printf("%s(%i):",__FILE__,__LINE__);::ExitProcess(0);}



struct __mem{
	static LONG (WINAPI __PTOP_LEVEL_EXCEPTION_FILTER)(
		_EXCEPTION_POINTERS *e
		){
			EXCEPTION_RECORD64*f=(EXCEPTION_RECORD64*)e->ExceptionRecord;
			if(EXCEPTION_ACCESS_VIOLATION==f->ExceptionCode&&2==f->NumberParameters){
				const uu u=f->ExceptionInformation[1];
				if(::__mem.a<=u&&u<::__mem.b){
					if(::VirtualAlloc((void*)u,0x10000,MEM_COMMIT,PAGE_READWRITE)==0)err;
					return EXCEPTION_CONTINUE_EXECUTION;
				}
				err;
			}
			if(EXCEPTION_STACK_OVERFLOW==f->ExceptionCode){
				err;
			}
			err;

			::exit(0);
			return EXCEPTION_CONTINUE_EXECUTION;
	}

	uu a,b,n,n1;
	uu get,mem;
	__mem(){
		n1=uu(64)*uu(1024*1024*1024);
		uu ns=n1*1000;
		n=ns*2;
		a=(uu)::VirtualAlloc(0,n,MEM_RESERVE,PAGE_READWRITE);;
		err0(a);
		b=a+n;
		get=a;
		mem=a+ns;
		SetUnhandledExceptionFilter(__PTOP_LEVEL_EXCEPTION_FILTER);;
	}
}__mem;
#define VirtualAlloc // disable virtualalloc


char*memget(){
	char*a=(char*)__mem.get;
	__mem.get+=__mem.n1;
	return a;
}
struct mem{
	char*a;
	mem(){
		a=(char*)__mem.mem;
		__mem.mem+=__mem.n1;
	}
	~mem(){
		__mem.mem-=__mem.n1;
	}
};

struct xy{
ii x,y;
void set(ii x,ii y){
	this->x=x;
	this->y=y;
}


xy(){}
xy(ii v     ){this->x=v;this->y=v;}
xy(ii x,ii y){this->x=x;this->y=y;}

xy&operator  !(){return xy(  !x,  !y);}
xy&operator  ~(){return xy(  ~x,  ~y);}
xy&operator  -(){return xy(  -x,  -y);}
xy&operator ++(){return xy( ++x, ++y);}
xy&operator --(){return xy( --x, --y);}

xy&operator ++(int){return xy(x ++,y ++);}
xy&operator --(int){return xy(x --,y --);}

xy&operator  =(ii v){return xy(x  =v  ,y  =v  );}
xy&operator  =(xy&v){return xy(x  =v.x,y  =v.y);}

xy&operator  *(ii v){return xy(x  *v  ,y  *v  );}
xy&operator  *(xy&v){return xy(x  *v.x,y  *v.y);}
xy&operator *=(ii v){return xy(x *=v  ,y *=v  );}
xy&operator *=(xy&v){return xy(x *=v.x,y *=v.y);}
xy&operator  /(ii v){return xy(x  /v  ,y  /v  );}
xy&operator  /(xy&v){return xy(x  /v.x,y  /v.y);}
xy&operator /=(ii v){return xy(x /=v  ,y /=v  );}
xy&operator /=(xy&v){return xy(x /=v.x,y /=v.y);}
xy&operator  %(ii v){return xy(x  %v  ,y  %v  );}
xy&operator  %(xy&v){return xy(x  %v.x,y  %v.y);}
xy&operator %=(ii v){return xy(x %=v  ,y %=v  );}
xy&operator %=(xy&v){return xy(x %=v.x,y %=v.y);}
xy&operator  +(ii v){return xy(x  +v  ,y  +v  );}
xy&operator  +(xy&v){return xy(x  +v.x,y  +v.y);}
xy&operator +=(ii v){return xy(x +=v  ,y +=v  );}
xy&operator +=(xy&v){return xy(x +=v.x,y +=v.y);}
xy&operator  -(ii v){return xy(x  -v  ,y  -v  );}
xy&operator  -(xy&v){return xy(x  -v.x,y  -v.y);}
xy&operator -=(ii v){return xy(x -=v  ,y -=v  );}
xy&operator -=(xy&v){return xy(x -=v.x,y -=v.y);}
xy&operator <<(ii v){return xy(x <<v  ,y <<v  );}
xy&operator <<(xy&v){return xy(x <<v.x,y <<v.y);}
xy&operator<<=(ii v){return xy(x<<=v  ,y<<=v  );}
xy&operator<<=(xy&v){return xy(x<<=v.x,y<<=v.y);}
xy&operator >>(ii v){return xy(x >>v  ,y >>v  );}
xy&operator >>(xy&v){return xy(x >>v.x,y >>v.y);}
xy&operator>>=(ii v){return xy(x>>=v  ,y>>=v  );}
xy&operator>>=(xy&v){return xy(x>>=v.x,y>>=v.y);}
xy&operator  &(ii v){return xy(x  &v  ,y  &v  );}
xy&operator  &(xy&v){return xy(x  &v.x,y  &v.y);}
xy&operator &=(ii v){return xy(x &=v  ,y &=v  );}
xy&operator &=(xy&v){return xy(x &=v.x,y &=v.y);}
xy&operator  |(ii v){return xy(x  |v  ,y  |v  );}
xy&operator  |(xy&v){return xy(x  |v.x,y  |v.y);}
xy&operator |=(ii v){return xy(x |=v  ,y |=v  );}
xy&operator |=(xy&v){return xy(x |=v.x,y |=v.y);}
xy&operator  ^(ii v){return xy(x  ^v  ,y  ^v  );}
xy&operator  ^(xy&v){return xy(x  ^v.x,y  ^v.y);}
xy&operator ^=(ii v){return xy(x ^=v  ,y ^=v  );}
xy&operator ^=(xy&v){return xy(x ^=v.x,y ^=v.y);}


bool operator  <(ii v){return x  <v  &&y  <v  ;}
bool operator  <(xy&v){return x  <v.x&&y  <v.y;}
bool operator <=(ii v){return x <=v  &&y <=v  ;}
bool operator <=(xy&v){return x <=v.x&&y <=v.y;}
bool operator  >(ii v){return x  >v  &&y  >v  ;}
bool operator  >(xy&v){return x  >v.x&&y  >v.y;}
bool operator >=(ii v){return x >=v  &&y >=v  ;}
bool operator >=(xy&v){return x >=v.x&&y >=v.y;}


bool operator ==(ii v){return  (x==v&&y==v);}
bool operator !=(ii v){return !(x==v&&y==v);}

bool operator ==(xy&v){return  (x==v.x&&y==v.y);}
bool operator !=(xy&v){return !(x==v.x&&y==v.y);}


bool less (xy&m){return (y<m.y)||(y==m.y&&x< m.x);}
bool lesse(xy&m){return (y<m.y)||(y==m.y&&x<=m.x);}



bool in(ii v){return uu(x)<uu(v)  &&uu(y)<uu(v)  ;}
bool in(xy&v){return uu(x)<uu(v.x)&&uu(y)<uu(v.y);}
bool in(xy&a,xy&n){
	return (a.x<=x&&x<a.x+n.x)&&(a.y<=y&&y<a.y+n.y);
}

void small0(){
	if(x<0)x=0;
	if(y<0)y=0;
}

};
#define b_set(a,b) if((a)<(b))(a)=(b)
#define a_set(a,b) if((a)>(b))(a)=(b)




struct define_color{};

const int back_color=RGB(0xe0,0Xe0,0Xe0);
const int tiao_color=RGB(0xc0,0Xc0,0Xc0);
HBRUSH back_brush=::CreateSolidBrush(back_color);
HBRUSH tiao_brush =::CreateSolidBrush(RGB(0xc0,0Xc0,0Xc0));
HBRUSH tiao_brush2=::CreateSolidBrush(RGB(0x80,0X80,0X80));


HBRUSH rbrush=::CreateSolidBrush(RGB(-1,0,0));
HBRUSH gbrush=::CreateSolidBrush(RGB(0,-1,0));
HBRUSH bbrush=::CreateSolidBrush(RGB(0,0,-1,));
//const int select_color=RGB(170,210,255);
const int select_color=RGB(140,190,250);
HBRUSH select_brush=::CreateSolidBrush(select_color);

HBRUSH find_brush=::CreateSolidBrush(RGB(0xFF,0X80,0,));

HBRUSH comm1_brush=::CreateSolidBrush(RGB(0x80,0,0));
HBRUSH comms_brush=::CreateSolidBrush(RGB(0x80,0,0));
HBRUSH char1_brush=::CreateSolidBrush(RGB(0x80,0,0x80));
HBRUSH chars_brush=::CreateSolidBrush(RGB(0x80,0,0x80));
HBRUSH operator_brush=::CreateSolidBrush(RGB(0,0x80,0));


static HCURSOR cursor_arrow=::LoadCursorA(0,IDC_ARROW );
static HCURSOR cursor_I=::LoadCursorA(0,IDC_IBEAM );
static HCURSOR cursor_hand=::LoadCursorA(0,IDC_HAND );
static HCURSOR cursor_wait=::LoadCursorA(0,IDC_WAIT );
static HCURSOR cursor_no=::LoadCursorA(0,IDC_NO );
static HCURSOR cursor_cross=::LoadCursorA(0,IDC_CROSS );
static HCURSOR cursor_IDC_SIZEALL=::LoadCursorA(0,IDC_SIZEALL );

/*
if(c&0x80){// 2 bytes

}else if(c==tab_char){// 4 bytes

}else if(c==ten_char){// 10 bytes

}else {// 1 bytes

}

*/

const int font_min=12;
const int font_max=48;
                                       


char idchar[0x100];
char opchar[0x100];
char usechar[0x100];
char wmcan[0x10000];
struct init_char{
	int is_idchar(const char c){
		if(c&0x80)return 1;
		if(c=='_')return 1;
		if('0'<=c&&c<='9')return 1;
		if('a'<=c&&c<='z')return 1;
		if('A'<=c&&c<='Z')return 1;
		return 0;
	}
	init_char(){
		for(ii c=0;c<0x100;c++){
			idchar[c]=is_idchar(c);
			opchar[c]=(' '<c&&c<='~'&&is_idchar(c)==0);
			usechar[c]=(' '<=c&&c<='~')||c==char_tab||c==char_ret;
		}
		for(ii i=0;i<nof(wmcan);i++)wmcan[i]=0;
		for(ii i=WM_KEYFIRST;i<=WM_KEYLAST;i++)wmcan[i]=1;
		for(ii i=WM_MOUSEFIRST;i<=WM_MOUSELAST;i++)wmcan[i]=1;
		wmcan[WM_SETFOCUS]=1;
		wmcan[WM_KILLFOCUS]=1;
		wmcan[WM_SIZE]=1;
		wmcan[WM_PAINT]=1;
		wmcan[WM_TIMER]=1;
		wmcan[WM_IME_STARTCOMPOSITION]=1;
		wmcan[WM_CHAR]=1;
	}
}init_char;
int id_char(const int c){return idchar[c&0xFF];}
int op_char(const int c){return opchar[c&0xFF];}
int use_char(const int c){return usechar[c&0xFF];}
int wm_can(const int wm){return wmcan[wm&0xFFFF];}
struct value{};/////////////
int __SetProcessDPIAware=::SetProcessDPIAware();
HDC dc_screen=GetDC(0);
xy f=0;
HDC dc;
int bian;
int tiao;
xy ff=0;
int fadd;

HWND window;
HDC dc_window;
HIMC imc=0;
bool have_focus;
xy client=0;
int wx1,wx2, wy1, wy2;
xy pos;
xy drag=-1;
bool have_control=0;
bool have_shift=0;
bool have_lbutton=0;
struct wt{
	xy wa,wn;
	xy va,vn;
	wt(){
		*wb++=this;
	}
	void show_other(){
		static HBRUSH focus1_brush=::CreateSolidBrush(RGB(0,0Xc0,0));
		static HBRUSH focus0_brush=::CreateSolidBrush(RGB(0,0X40,0));
		::SelectObject(dc,have_focus&&wfocus==this?focus1_brush:focus0_brush);
		BitBlt(dc,wa.x,wa.y,wn.x,va.y-wa.y,0,0,0,PATCOPY);
		BitBlt(dc,wa.x,va.y+vn.y,wn.x,(wa.y+wn.y)-(va.y+vn.y),0,0,0,PATCOPY);

		BitBlt(dc,wa.x,wa.y,va.x-wa.x,wn.y,0,0,0,PATCOPY);
		BitBlt(dc,va.x+vn.x,wa.y,(wa.x+wn.x)-(va.x+vn.x),wn.y,0,0,0,PATCOPY);
	}
	int include(xy pos){
		return wa<=pos&&pos<wa+wn;
	}
	
	bool isfocus(){
		return have_focus&&this==wfocus;
	}

	virtual void init()=0;
	virtual void message(UINT wm, WPARAM wparam, LPARAM lparam)=0;
	virtual xy   get_pos()=0;
	virtual void set(const char*sa,ii sn)=0;
}*wa[100],**wb=wa,*wfocus=0,*we;

bool werr=0;
void winit(){
	{	
		LOGFONTA f={};
		f.lfHeight=-::f.y;
		f.lfCharSet=DEFAULT_CHARSET;
		f.lfWeight=FW_THIN;
		f.lfQuality=CLEARTYPE_QUALITY;
		strcpy(f.lfFaceName,"Consolas");
		::ImmSetCompositionFontA(imc,&f);
	}
	drag=-1;///////////
	werr=1;
	if(2<f.x){}else return;///////
	if(4<f.y){}else return;///////
	if(f.y*(1+3+1)*2<=client.x){}else return;///////
	if(f.y*((1+1+1)+(1+3+1))<=client.y){}else return;///////
	
	wx1=client.x/2;	
	wx2=client.x-wx1;
	wy1=bian+f.y+bian;
	wy2=client.y-wy1;
	for(wt**w=wa;w<wb;w++)(*w)->init();
	werr=0;
}

struct font{
	int size;
	char size_a[100];
	int  size_n;
	HMENU menu;
	enum{menu_id=1000};
	font(){
		dc=::CreateCompatibleDC(dc_screen);
		HBITMAP dc_bitmap=::CreateCompatibleBitmap(dc_screen,0x1000,0x1000);
		::SelectObject(dc,dc_bitmap);
		::SetBkMode(dc,TRANSPARENT);
		::GetTextColor(RGB(0,0,0));
		create(font_min);

		menu=::CreatePopupMenu();
		for(int i=font_min;i<=font_max;i++){
			char a[100];
			sprintf(a,"%i",i);
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,menu_id+i,a);
		}
	}
	
	void create(int size){
		if(font_min<=size&&size<=font_max){}else return;///////
		this->size=size;
		size_n=::sprintf(size_a,"%i",size);
		static HFONT hfont=0;
		::DeleteObject(hfont);
		
		hfont=CreateFontA(-MulDiv(size, GetDeviceCaps(dc_screen, LOGPIXELSY), 72)
			,0,0,0,0,FALSE,0,FALSE,DEFAULT_CHARSET,0,0
			,CLEARTYPE_QUALITY, 0,"consolas");
		::SelectObject(dc,hfont);
		TEXTMETRICA tm={};
		::GetTextMetricsA(dc,&tm);
		f.x=tm.tmAveCharWidth;
		f.y=tm.tmHeight;

		bian=f.x/2+1;
		tiao=f.y;
		
		fadd=1;b_set(fadd,f.x/6);
		ff=xy(f.x,fadd+f.y+fadd);
		winit();
	}
}font;



struct edit1:wt{
	int fn;
	char da[0x1000];
	int dn;
	int dd,de,df;
	
	void message(UINT wm, WPARAM wparam, LPARAM lparam){
		
		showi.dd=dd;
		mouse(wm,wparam,lparam);
		if(isfocus()){
			key(wm,wparam,lparam);
			menu_get(wm,wparam,lparam);
		}

		BitBlt(dc,va.x,va.y,vn.x,vn.y,0,0,0,WHITENESS);
		const int ie=de<dd?de:dd;
		const int id=de<dd?dd:de;

		::SelectObject(dc,select_brush);
		for(int fi=0;fi<fn;fi++){
			if(ie<=df+fi&&df+fi<id)BitBlt(dc,va.x+fi*f.x,va.y,f.x,vn.y,0,0,0,PATCOPY);
		}
		char*sa=da+df;
		int  sn=dn-df;if(sn>fn)sn=fn;
		if(one80(da,df)){
			::TextOutA(dc,va.x-f.x,va.y,sa-1,sn+1+1);
		}else{
			::TextOutA(dc,va.x,va.y,sa,sn+1);
		}
		if(isfocus()&&showi.can(dd)){
			BitBlt(dc,va.x+(dd-df)*f.x,va.y,f.x/3,vn.y,0,0,0,BLACKNESS);

		}

		show_other();
		if(wm==WM_MOUSEMOVE){
			if(wa<=pos&&pos<wa+wn){
				if(va<=pos&&pos<va+vn){
					::SetCursor(cursor_I);
				}else{
					::SetCursor(cursor_arrow);
				}
			}
		}
	}
	xy get_pos(){
		return va+xy(dd-df,0)*f;
	}

	bool one80(const char*sa,int sn){
		int n=0;
		for(int i=0;i<sn;i++)if(sa[i]&0x80)n++;
		return n&1;
	}
	void mouse(UINT wm, WPARAM wparam, LPARAM lparam){
		if(pos.in(va,vn)){
			if(wm==WM_LBUTTONDOWN){
				if(wparam&MK_CONTROL){

					if(wparam&MK_SHIFT){
						de=0;dd=dn;
						setdf(df);

					}else{
						xy fi=(pos-va)/f;
						setdd(fi.x+df);
						iding();;
					}
				}else{
					xy fi=(pos-va)/f;
					setdd(fi.x+df);
					drag=pos;/////////
				}
			}
			if(wm==WM_LBUTTONDBLCLK){

				xy fi=(pos-va)/f;
				setdd(fi.x+df);
				iding();;
			}
		}
		if(drag.in(va,vn)){
			xy fi=(pos-va)/f;
			setdd(fi.x+df,0);
		}
	}

	void key(UINT wm, WPARAM vk, LPARAM lparam){
		if(wm==WM_KEYDOWN){
			if(vk==VK_HOME){setdd(0);return;}
			if(vk==VK_END){setdd(dn);return;}
			if(vk==VK_LEFT){setdd(dd-1,1,1);return;}
			if(vk==VK_RIGHT){setdd(dd+1,1,1);return;}
			if(vk==VK_BACK){
				if(de==dd){
					setdd(dd-1,0,1);
				}
				set();
				return;
			}
			if(vk==VK_DELETE){
				if(de==dd){
					setdd(dd+1,0,1);
				}
				set();
				return;
			}
			if(::GetAsyncKeyState(VK_CONTROL)<0){
				if(vk=='A'){de=0;dd=dn;setdf(df);return;}

				if(vk=='X'){
					cut();
				return;}
				if(vk=='C'){
					copy();
				return;}
				if(vk=='V'){
					paste();
					return;}

			}
		}
	}
	
	struct showi{
		int dd;
		DWORD tick;
		int canret;
		void set(){tick=::GetTickCount()+500;}
		int can(int dd){
			if(this->dd!=dd){
				set();
				canret=1;
				return canret;
			}
			if(tick<::GetTickCount()){
				set();
				canret=!canret;
				return canret;
			}
			return canret;
		}
		showi(){
			dd=0;
			tick=0;
			canret=1;
		}
	}showi;
	
	
	
	edit1(){
		wfocus=this;/////////
		da[dn=0]=0;

		dd=de=df=0;
	}
	void setall(const char*ra=0,ii rn=0){
		de=0;dd=dn;
		set(ra,rn);
	}
	void set(const char*ra=0,ii rn=0){
		char sa[nof(da)];
		ii sn=0;
		if(ra){
			if(rn==0){while(ra[rn])rn++;}
			for(ii i=0;i<rn;){
				const char c=ra[i];
				if(' '<=c&&c<='~'){
					if(sn+1<nof(da)){
						sa[sn++]=c;
					}else {
						break;
					}
					i++;
					continue;
				}
				if((c&0x80)&&i+1<rn&&(ra[i+1]&0x80)){
					if(sn+2<nof(da)){
						sa[sn++]=ra[i];
						sa[sn++]=ra[i+1];
					}else {
						break;
					}
					i+=2;
					continue;
				}
				i++;
			}
		}
		const int ie=de<dd?de:dd;
		const int id=de<dd?dd:de;
		const int in=id-ie;
		if(dn-in+sn<nof(da)){}else return;//////////
		char ea[nof(da)];
		char*eb=ea;
		for(int i=id;i<dn;i++)*eb++=da[i];

		char*d=da+ie;
		for(int i=0;i<sn;i++)*d++=sa[i];
		dd=de=d-da;
		for(char*e=ea;e<eb;e++)*d++=*e;
		dn=d-da;
		da[-1]=0;
		da[dn]=0;
		setdf(df);
	}


	void setdf(int df_in){
		df=df_in;
		if(df<0){df=0;return;}
		int n=dn+1-fn;
		if(n<=0){df=0;return;}
		if(df>n)df=n;
		if(dd<df){df=dd;return;}
		if(dd>df+fn-1){df=dd-(fn-1);return ;}
	}
	void setdd(int d,bool setde=1,bool must_change=0){
		if(d<0)d=0;
		if(d>dn)d=dn;
		
		if(one80(da,d)){
			if(must_change){
				if(dd==d+1){
					d--;
				}else{
					d++;
				}
			}else{
				d++;
			}
		}

		if(d>dn)d=dn;


		dd=d;
		if(setde&&::GetAsyncKeyState(VK_SHIFT)>=0)de=d;
		setdf(df);
	}

	void iding(){
		if(id_char(da[dd])){
			de=dd;while(0<=de&&id_char(da[de]))de--;de++;
			while(dd<nof(da)&&id_char(da[dd]))dd++;
			setdf(df);
		}
	}
	
	void copy(){
		const int ia=de<dd?de:dd;
		const int ib=de<dd?dd:de;
		if(ia<ib){
			clip_set(da+ia,ib-ia);
		}
	}
	void paste(){
		mem mem1;
		char*sa=mem1.a;
		ii   sn=clip_get(sa);
		if(sn){
			set(sa,sn);
		}
	}
	void cut(){
		const int ia=de<dd?de:dd;
		const int ib=de<dd?dd:de;
		if(ia<ib){
			clip_set(da+ia,ib-ia);
			set();
		}
	}
	virtual void menu_get(UINT const wm, WPARAM const vk, LPARAM lparam)=0;

};

struct find:edit1{
	void init(){
		wa=0;wn=xy(wx1,wy1);
		//if(this==&replace){wa=xy(wx1,0);wn=xy(wx2,wy1);}
		fn=wn.x/f.x-2;

		vn.x=fn*f.x;
		vn.y=f.y;

		va=wa+(wn-vn)/2;
		showi.dd=dd;
	}
	int aisA;
	int isword;
	int show_find;
	find(){
		aisA=0;
		isword=MF_CHECKED;
		show_find=MF_CHECKED;
	}
	void menu_get(UINT const wm, WPARAM const vk, LPARAM lparam){

		if(wm==WM_RBUTTONUP&&pos.in(va,vn)){

			const int menu_id=100;
			HMENU menu=::CreatePopupMenu();
			int id=menu_id;
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"copy ");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"paste");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"cut  ");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"clear");
			POINT p;::GetCursorPos(&p);
			id=::TrackPopupMenu(menu,TPM_RETURNCMD,p.x,p.y,0,window,0);
			::DestroyMenu(menu);
			int id2=menu_id;
			if(0){}
			else if(id==id2++){copy();}
			else if(id==id2++){paste();}
			else if(id==id2++){cut();}
			else if(id==id2++){dn=0;dd=de=df=0;*da=0;}
		}

	}
	int cmp(const char*sa,ii sn,ii si){
		if(0<=si&&si+dn<=sn){}else return 0;////////
		for(ii i=0;i<dn;i++){
			u8 a=da[i];
			u8 b=sa[si+i];
			if(aisA){
				if('a'<=a&&a<='z')a=a-'a'+'A';
				if('a'<=b&&b<='z')b=b-'a'+'A';
			}
			if(a!=b)return 0;//////////
		}
		if(isword){
			if(si>0){
				if(id_char(sa[si-1]))return 0;/////////
			}
			if(si+dn<sn){
				if(id_char(sa[si+dn]))return 0;////////////
			}
		}
		return 1;///////////
	}
}find;

struct replace:edit1{
	int number;
	int select;
	void init(){
		wa=xy(wx1,0);wn=xy(wx2,wy1);
		fn=wn.x/f.x-2;

		vn.x=fn*f.x;
		vn.y=f.y;

		va=wa+(wn-vn)/2;
		showi.dd=dd;
	}
	replace(){
		select=MF_CHECKED;
	}
	void menu_get(UINT const wm, WPARAM const vk, LPARAM lparam){
		static HMENU menu;
		const int menu_id=100;
		static bool init=1;if(init){init=0;
			menu=::CreatePopupMenu();
			int id=menu_id;
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"copy ");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"paste");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"cut  ");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"clear");
		}
		if(wm==WM_RBUTTONUP&&pos.in(va,vn)){
			POINT p;::GetCursorPos(&p);
			int id=::TrackPopupMenu(menu,TPM_RETURNCMD,p.x,p.y,0,window,0);
			int id2=menu_id;
			if(0){}
			else if(id==id2++){copy();}
			else if(id==id2++){paste();}
			else if(id==id2++){cut();}
			else if(id==id2++){dn=0;dd=de=df=0;*da=0;}
		}
		
	}

}replace;


xy fn;
xy xa,xn;
xy ya,yn;
xy za,zn;
xy ea,en;
struct showi{
	xy dd;
	DWORD tick;
	int canret;
	void set(){tick=::GetTickCount()+500;}
	int can(xy dd){
		if(this->dd==dd){

		}else{
			set();
			canret=1;
			return canret;
		}
		if(tick<::GetTickCount()){
			set();
			canret=!canret;
			return canret;
		}
		return canret;
	}
	void show(){
		set();
		canret=1;
	}
	showi(){
		dd=0;
		tick=0;
		canret=1;
	}
}showi;




struct filename_t{
	char a[0x1000];
	void set(const char*name){
		for(int i=0;i<nof(a)-2;i++){
			if(a[i]=name[i]){}else break;
		}
		::SetWindowTextA(window,a);
	}
}filename;

void full_screen();
void full_work();
char*align(const void*s){
	uu u=uu(s);
	const  u8 nbit=3;
	u+=(1<<nbit)-1;
	u>>=nbit;
	u<<=nbit;

	return (char*)u;
}
#define setn(da,sa,sn) for(ii _=0;_<(sn);_++)(da)[_]=(sa)[_]

LRESULT (CALLBACK window_proc)(HWND hwnd, const UINT wm, WPARAM wparam, LPARAM lparam);


struct mt;
struct kt{
	mt*m;
	xy a,b;
	ii type;
	void set(mt*m,xy a,xy b,ii type){
		this->m=m;
		this->a=a;
		this->b=b;
		this->type=type;
	}
}*ky=(kt*)memget();
void kyset(mt*m,xy a,xy b,ii type){
	if(a.y<b.y){
		ky[a.y].set(m,a,b,type);
		ky[b.y].set(m,a,b,type);
	}
}
char*kall_a=(char*)memget(),*kall_b;
bool kall_have;
//[1234567890]
//[ {......} ]
//[/*......*/]
const char*kstring[]={
//"1234567890"
  " {......} ",
  "/*......*/",
};
#define k_type 0
#define k_number 12
const char*getsx(const char*(&s),ii&x){
	const char*sa=s;
	if(*s==k_type){
		kt*k=(kt*)(s+1);
		s+=1+sizeof(kt)+1;
		x+=k_number;

		return k->type?
		//  "1234567890"
			" /*......*/                  ":
			" { ...... }                    ";
			
	}
	if(*s&0x80){
		s+=2;
		x+=2;
		return sa;
	}
	if(*s==char_tab){
		s+=1;
		x+=4-(x&3);
		return "                                        ";
	}
	s++;
	x++;
	return sa;
}
int* colora=(int*)memget();
int**colory=(int**)memget();

struct mt{
	struct lt{
		ii x;
		ii n;
		char a[1];
	}*ca,*cb,**la,**lb;
	xy dd,de,df,ll;
	
	void setll(){
		ll.y=lb-la;
		ll.x=0;for(ii y=0;y<ll.y;y++)b_set(ll.x,la[y]->x);
	}
	void setcblb(const char*sa,const char*sb){
		if(sa<sb){}else return;////////
		if(sb[-1]!=char_ret)err;

		const char*ca=sa;
		ii x=0;
		for(const char*s=sa;s<sb;){
			if(*s==char_ret){
				s++;
				x++;
				ii cn=s-ca;

				*lb++=cb;
				for(ii i=0;i<cn;i++)cb->a[i]=ca[i];
				cb->n=cn;
				cb->x=x;
				cb=(lt*)align(cb->a+cb->n);

				ca=s;///////////
				x=0;
				continue;
			}
			getsx(s,x);
		}
	}
	char*input(char*d,const char*sa,ii sn){
		for(const char*sb=sa+sn,*s=sa;s<sb;){
			if(*s&0x80){
				if(s+1<sb&&(s[1]&0x80)){
					*d++=*s;
					*d++=*(s+1);
				}
				s+=2;
			}else{
				if(use_char(*s)){
					*d++=*s;
				}
				s+=1;
			}
		}
		return d;
	}

	void set_head(const char*sa=0,ii sn=0){
		if(sa){if(sn==0)while(sa[sn])sn++;}else{sn=0;}
		cb=ca;
		lb=la;
		mem mem1;
		char*da=mem1.a;
		char*db=da;
		if(this==::ma){
			db=input(db,sa,sn);
		}else{
			for(ii i=0;i<sn;i++)db[i]=sa[i];
			db+=sn;
		}
		*db++=char_ret;
		setcblb(da,db);
		setll();
		dd=de=df=0;
		m=mm=this;m->update();
	}
	void set_all(const char*sa=0,ii sn=0){
		mt&d=this[1];
		d.ca=d.cb=cb;
		d.la=d.lb=lb;
		d.set_head(sa,sn);
	}
	void set1(char*(&da),xy i){
		char*sa=la[i.y]->a;
		ii sn=i.x;
		setn(da,sa,sn);
		da+=sn;
	}
	void set2(char*(&da),xy i){
		char*sa=la[i.y]->a+i.x;
		ii sn=la[i.y]->n-i.x;
		setn(da,sa,sn);
		da+=sn;
	}
	void sets(char*(&da),const char*sa,ii sn){
		setn(da,sa,sn);
		da+=sn;
	}
	void set(xy ia,xy ib,const char*sa=0, ii sn=0){
		if(sa){if(sn==0)while(sa[sn])sn++;}else{sn=0;}
		if(ia==ib&&sn==0)return;///////////
		seti(ia,ib);
		mt&d=this[1];
		d.ca=d.cb=cb;
		d.la=d.lb=lb;

		for(ii y=0;y<ia.y;y++)*d.lb++=la[y];
		
		mem mem1;
		char*ea=mem1.a;
		char*eb=ea;
		set1(eb,ia);
		eb=input(eb,sa,sn);
		set2(eb,ib);
		
		d.setcblb(ea,eb);
		
		ii dy=d.lb-d.la-1;
		lt*dl=d.lb[-1];


		for(ii y=ib.y+1;y<ll.y;y++)*d.lb++=la[y];


		d.setll();
		
		ii sx=0;
		ii n=(la[ib.y]->n-ib.x);
		
		if(n<dl->n)for(const char*sa=dl->a,*sb=dl->a+dl->n-n,*s=sa;s<sb;){
			const ii si=s-sa;
			const ii x1=sx;
			getsx(s,sx);
		}

		ii dx=sx;

		d.df=df;
		d.de=d.dd=xy(dx,dy);
		d.setdf_by_dedd();
		m=mm=&d;m->update();

		
		//m->show();
	}
	
	void show(){
		for(ii y=0;y<ll.y;y++){
			printf("%i=%i[%.*s]\n",la[y]->x,la[y]->n,la[y]->n-1,la[y]->a);
			if(la[y]->x>=la[y]->n){
			}else{
				err;
			}
		}
		err;
	}
	ii get(char*da,xy ia,xy ib){
		char*d=da;
		if(ia==ib)return d-da;
		kget(d,ia,ib);
		return d-da;
	}
	void seti(xy&i){
		b_set(i.y,0);
		a_set(i.y,ll.y-1);
		if(i.x<=0){i.x=0;return;}
		if(i.x>la[i.y]->x-1){i.x=la[i.y]->n-1;return;}

			
		ii sx=0;
		for(const char*sa=la[i.y]->a,*sb=la[i.y]->a+la[i.y]->n-1,*s=sa;s<sb;){
			const ii si=s-sa;
			const ii x1=sx;
			getsx(s,sx);
			const ii x2=sx-1;
			if(i.x<sx){
				if(i.x-x1<=x2-i.x){i.x=si;return;}
				i.x=s-sa;return;/////
			}
		}
		i.x=la[i.y]->n-1;return;
	}
	void seti(xy&ia,xy&ib){
		seti(ia);
		seti(ib);
		if(ib.less(ia)){xy i=ia;ia=ib;ib=i;}
	}
	void setdf_xy(ii&i,ii a,ii b){
		if(i<=0){
			i=0;
		}else{
			const ii n=a-b;
			if(n<=0){
				i=0;
			}else{
				a_set(i,n);
			}
		}
	}
	void setdf(xy v){
		df=v;
		setdf_xy(df.y,ll.y,fn.y);
		setdf_xy(df.x,ll.x,fn.x);
	}
	void setdd_xy(ii&da,ii dn,ii d){
		ii db=da+dn;
		if(da<=d&&d<db)return;//////
		if(d<da){da=d;return;}///////////
		da=d-(dn-1);
	}

	void setd(xy&i){
		b_set(i.y,0);
		a_set(i.y,ll.y-1);
		if(i.x<=0){i.x=0;return;}
		if(i.x>(la[i.y]->x-1)){i.x=la[i.y]->x-1;return;}

			
		ii sx=0;
		for(const char*sa=la[i.y]->a,*sb=la[i.y]->a+la[i.y]->n-1,*s=sa;s<sb;){
			const ii si=s-sa;
			const ii x1=sx;
			getsx(s,sx);
			const ii x2=sx-1;
			if(i.x<sx){
				if(i.x-x1<=x2-i.x){i.x=x1;return;}
				i.x=sx;return;/////
			}
		}
		i.x=la[i.y]->x-1;return;
	}
	void setdf_by_dedd(){
		setdd_xy(df.x,fn.x,de.x);setdd_xy(df.y,fn.y,de.y);
		setdd_xy(df.x,fn.x,dd.x);setdd_xy(df.y,fn.y,dd.y);
		setdf(df);
	}
	void setdd(xy d,bool setde=1){
		setd(d);
		dd=d;
		showi.show();
		/////////////
		if(setde&&::GetAsyncKeyState(VK_SHIFT)>=0)de=d;
		/////////////
		setdf_by_dedd();
	}
	ii kget_have;
	void kget2(char*(&d),const char*sa,ii sn){
		ii x=0;
		for(const char*sb=sa+sn,*s=sa;s<sb;){
			const char*ca=s;
			getsx(s,x);
			const ii cn=s-ca;
			if(*ca==k_type){
				kget_have=1;
				kt&k=*(kt*)(ca+1);
				k.m->kget(d,k.a,k.b);
			}else{
				for(ii i=0;i<cn;i++)d[i]=ca[i];
				d+=cn;
			}
		}
	}
	void kget(char*(&d),xy a,xy b){
		seti(a,b);
		if(a.y==b.y){
			kget2(d,la[a.y]->a+a.x,b.x-a.x);

		}else{
			kget2(d,la[a.y]->a+a.x,la[a.y]->n-a.x);
			for(ii y=a.y+1;y<b.y;y++)kget2(d,la[y]->a,la[y]->n);
			kget2(d,la[b.y]->a,b.x);
		}
	}
	void cpy(char*(&d),const char*sa,ii sn){
		for(ii i=0;i<sn;i++)d[i]=sa[i];
		d+=sn;
	}
	void kget_once(char*(&d),xy a,xy b){
		seti(a,b);
		if(a.y==b.y){

			cpy(d,la[a.y]->a+a.x,b.x-a.x);

		}else{
			cpy(d,la[a.y]->a+a.x,la[a.y]->n-a.x);
			for(ii y=a.y+1;y<b.y;y++)cpy(d,la[y]->a,la[y]->n);
			cpy(d,la[b.y]->a,b.x);
		}
	}
	void set_k_close(ii iy){
		if(0<=iy&&iy<ll.y){}else return;/////////
		kt&k=ky[iy];
		if(k.m){}else return;/////////
		de=k.a;
		dd=k.b;
		this->setdf_by_dedd();
		xy ia=k.a;
		xy ib=k.b;
		seti(ia,ib);
		mt&d=this[1];
		d.ca=d.cb=cb;
		d.la=d.lb=lb;

		for(ii y=0;y<ia.y;y++)*d.lb++=la[y];
		
		mem mem1;
		char*ea=mem1.a;
		char*eb=ea;
		set1(eb,ia);
		
		*eb++=0;
		*(kt*)eb=k;eb+=sizeof(kt);
		*eb++=0;


		set2(eb,ib);
		
		d.setcblb(ea,eb);
		
		ii dy=d.lb-d.la-1;
		lt*dl=d.lb[-1];


		for(ii y=ib.y+1;y<ll.y;y++)*d.lb++=la[y];


		d.setll();
		
		d.df=df;
		d.de=xy(0,dy);
		d.dd=xy(dl->x-1,dy);
		d.setdf_by_dedd();
		m=mm=&d;m->update();

		
		//m->show();
	}
	void set_k_open(ii iy,ii ix){
		if(0<=iy&&iy<ll.y){}else return;/////////
		if(0<=ix&&ix+1+sizeof(kt)+1<=la[iy]->n){}else return;/////////
		if(k_type==la[iy]->a[ix]){}else return;/////////


		xy ia=xy(ix,iy);
		xy ib=xy(ix+1+sizeof(kt)+1,iy);
		mt&d=this[1];
		d.ca=d.cb=cb;
		d.la=d.lb=lb;

		for(ii y=0;y<ia.y;y++)*d.lb++=la[y];
		
		mem mem1;
		char*ea=mem1.a;
		char*eb=ea;
		set1(eb,ia);

		kt&k=*(kt*)(la[iy]->a+ix+1);
		k.m->kget_once(eb,k.a,k.b);

		set2(eb,ib);
		
		d.setcblb(ea,eb);
		
		ii dy=d.lb-d.la-1;
		lt*dl=d.lb[-1];


		for(ii y=ib.y+1;y<ll.y;y++)*d.lb++=la[y];


		d.setll();
		
		ii sx=0;
		ii n=(la[ib.y]->n-ib.x);
		
		if(n<dl->n)for(const char*sa=dl->a,*sb=dl->a+dl->n-n,*s=sa;s<sb;){
			const ii si=s-sa;
			const ii x1=sx;
			getsx(s,sx);
		}

		ii dx=sx;

		d.df=df;
		d.de=d.dd=xy(dx,dy);
		d.setdf_by_dedd();
		m=mm=&d;m->update();

	}
	void set_k_open_all(){
		mem mem1;
		char*sa=mem1.a;
		kget_have=0;
		ii sn=get(sa,xy(0,0),xy(la[ll.y-1]->x-1,ll.y-1));
		if(kget_have==0)return;////////////
		set_all(sa,sn);
	}
	void set_k_close_all_functions(){
		if(kall_have){}else return;//////
		set_all(kall_a,kall_b-kall_a);
	}
	void iding(xy i){
		b_set(i.y,0);
		a_set(i.y,ll.y-1);
		if(i.x<=0){i.x=0;return;}
		if(i.x>=(la[i.y]->x-1)){
			i.x=la[i.y]->x-1;
			set_k_close(i.y);

			return;/////////////
		}

			
		ii sx=0;
		for(const char*sa=la[i.y]->a,*sb=la[i.y]->a+la[i.y]->n-1,*s=sa;s<sb;){
			const char*ss=s;
			const ii si=s-sa;
			const ii x1=sx;
			getsx(s,sx);
			const ii x2=sx-1;
			if(i.x<sx){
				if(*ss==k_type){
					set_k_open(i.y,si);
					return;
				}
				bool isnow=(i.x-x1<=x2-i.x);
				const char*p=isnow?sa+si:s;
				if(id_char(*p)){
					const char*e=p;while(sa<=e&&id_char(*e))e--;e++;
					const char*d=p;while(d<sb&&id_char(*d))d++;
					if(isnow){
						de=xy(x1-(p-e),i.y);
						dd=xy(x1+(d-p),i.y);
					}else{
						de=xy(sx-(p-e),i.y);
						dd=xy(sx+(d-p),i.y);
					}
					this->setdf_by_dedd();
					this->set_find_replace();
					return;////////////////////
				}
				
				return;
			}
		}
		i.x=la[i.y]->x-1;return;

	}
		void mouse(UINT wm, WPARAM wparam, LPARAM lparam){
		xy f=ff;

		if(pos.in(ea,en)){
			xy d=df+(pos-ea)/f;
			if(wm==WM_LBUTTONDOWN){
				
				if(wparam&MK_CONTROL){

					if(wparam&MK_SHIFT){
						setdd(d);
						de=xy(0,dd.y);
						dd.x=la[dd.y]->x-1;
						setdd(dd,0);
					}else{
						iding(d);
					}
				}else{
					setdd(d);
					drag=pos;
				}

			}
			if(wm==WM_LBUTTONDBLCLK){
				iding(d);
			}
		}
		if(drag.in(ea,en)){
			xy d=(pos-ea)/f;
			setdd(df+d,0);
		}
	}
	void keydown(const int vk){
		if(vk==VK_RETURN){
			char c=char_ret;
			set(dd,de,&c,1);
			return;///////////////
		}
		if(vk==VK_TAB){
			if(dd==de){
				char c=char_tab;
				set(dd,de,&c,1);
			}else{
				if(::GetAsyncKeyState(VK_SHIFT)<0){
					//set_tab_sub(dd,de);
				}else{
					//set_tab_add(dd,de);
				}
			}
			return;////////
		}
		if(vk==VK_BACK){
			if(dd==de){
				if(dd.x==0){
					const ii y=dd.y-1;
					if(0<=y)set(xy(la[y]->x-1,y),dd);
				}else{
					ii sx=0;
					for(const char*sa=la[dd.y]->a,*sb=sa+la[dd.y]->n-1,*s=sa;s<sb;){
						const ii si=s-sa;
						const ii x1=sx;
						getsx(s,sx);
						const ii x2=sx-1;
						if(sx==dd.x){
							set(xy(x1,dd.y),dd);
							break;///////
						}
					}
					

				}
			}else{
				set(dd,de);
			}
			return;////////////////
		}
		if(vk==VK_DELETE){
			if(dd==de){
				if(dd.x==la[dd.y]->x-1){
					const ii y=dd.y+1;
					if(y<ll.y)set(dd,xy(0,y));
				}else{
					ii sx=0;
					for(const char*sa=la[dd.y]->a,*sb=sa+la[dd.y]->n-1,*s=sa;s<sb;){
						const ii si=s-sa;
						const ii x1=sx;
						getsx(s,sx);
						const ii x2=sx-1;
						if(x1==dd.x){
							set(dd,xy(sx,dd.y));
							break;///////
						}
					}

				}
			}else{
				set(dd,de);
			}
			return;////////////////////
		}

		
		if(vk==VK_LEFT){
			if(dd.x==0){
				const ii y=dd.y-1;
				if(0<=y)setdd(xy(la[y]->x-1,y));
			}else{
				ii sx=0;
					for(const char*sa=la[dd.y]->a,*sb=sa+la[dd.y]->n-1,*s=sa;s<sb;){
						const ii si=s-sa;
						const ii x1=sx;
						getsx(s,sx);
						const ii x2=sx-1;
						if(sx==dd.x){
							setdd(xy(x1,dd.y));
							break;///////
						}
					}

			}
			return;////////////////
		}
		if(vk==VK_RIGHT){
			if(dd.x==la[dd.y]->x-1){
				const ii y=dd.y+1;
				if(y<ll.y)setdd(xy(0,y));
			}else{
				ii sx=0;
					for(const char*sa=la[dd.y]->a,*sb=sa+la[dd.y]->n-1,*s=sa;s<sb;){
						const ii si=s-sa;
						const ii x1=sx;
						getsx(s,sx);
						const ii x2=sx-1;
						if(x1==dd.x){
							setdd(xy(sx,dd.y));
							break;///////
						}
					}

			}
			return;////////////////////
		}
	
		if(vk==VK_UP   ){setdd(xy(dd.x,dd.y-1));return;}
		if(vk==VK_DOWN ){setdd(xy(dd.x,dd.y+1));return;}
		if(vk==VK_PRIOR){setdd(xy(dd.x,dd.y-fn.y));return;}
		if(vk==VK_NEXT ){setdd(xy(dd.x,dd.y+fn.y));return;}

		if(::GetAsyncKeyState(VK_CONTROL)<0){
			if(vk==VK_HOME ){setdd(xy(0,0));return;}
			if(vk==VK_END  ){setdd(xy(la[ll.y-1]->x-1,ll.y-1));return;}

			if(vk=='Z'){if(m>ma){m--;m->update();}return;}
			if(vk=='T'){if(m<mm){m++;m->update();}return;}
			if(vk=='C'){copy();return;}
			if(vk=='V'){paste();return;}
			if(vk=='X'){cut();return;}
			if(vk=='A'){de=0;setdd(xy(la[ll.y-1]->x-1,ll.y-1),0);return;}
		}else{
			if(vk==VK_HOME ){setdd(xy(0,dd.y));return;}
			if(vk==VK_END  ){setdd(xy(la[dd.y]->x-1,dd.y));return;}
		}
	}
	void key(UINT const wm, WPARAM const vk, LPARAM lparam){
		if(wm==WM_KEYDOWN)keydown(vk);
	}
	bool in(xy&ia,xy&ib,xy i){
		return ia.lesse(i)&&i.less(ib);
	}
	void message_e(UINT wm, WPARAM wparam, LPARAM lparam){
		xy f=ff;
		xy ia=de;xy ib=dd;if(dd.less(de)){ia=dd;ib=de;}
		ii ya=df.y;
		ii yb=ya+fn.y;a_set(yb,ll.y);
		::SetTextColor(dc,RGB(0,0,0));
		::SetBkMode(dc,TRANSPARENT);
		for(ii y=ya;y<yb;y++){
			const int yi=y-ya;
			const ii posy=ea.y+yi*f.y;

			const ii xa=df.x;
			const ii xb=xa+fn.x;
			ii sx=0;
			for(const char*sa=la[y]->a,*sb=la[y]->a+la[y]->n,*s=sa;s<sb;){
				const char*ss=s;
				const ii si=s-sa;
				const ii ca=sx;
				const char*text_a=getsx(s,sx);
				
				const ii cn=sx-ca;
				const ii cb=sx;
				if(cb<=xa)continue;///////
				if(xb<=ca)break;
				const ii xi=ca-xa;
				const ii posx=ea.x+xi*f.x;

				if(find.show_find&&find.dn>0&&find.cmp(sa,sb-sa,si)){
					::SelectObject(dc,find_brush);		
					BitBlt(dc,posx,posy,f.x*find.dn,f.y,0,0,0,PATCOPY);
				}


				if(in(ia,ib,xy(ca,y))){
					::SelectObject(dc,select_brush);		
					BitBlt(dc,posx,posy,f.x*cn,f.y,0,0,0,PATCOPY);
				}
				::SetTextColor(dc,colory[y][ca]);
				::TextOutA(dc,posx,posy+fadd,text_a,cn);
				if(*ss==k_type)paint(posx,posy,f.x*cn);
			}
		}
		if(we->isfocus()&&df.lesse(dd)&&dd.less(df+fn)){
			xy d=dd-df;
			const ii py=ea.y+d.y*f.y;
			if(showi.can(dd))BitBlt(dc,ea.x+d.x*f.x,py,fadd*2,f.y,0,0,0,BLACKNESS);
			if(dd==de)paint(ea.x,py,en.x);
		}
	}
	void paint(ii px,ii py,ii x){
		xy f=ff;
		::BitBlt(dc,px,py,x,fadd,0,0,0,BLACKNESS);
		::BitBlt(dc,px,py+f.y-fadd,x,fadd,0,0,0,BLACKNESS);
		::BitBlt(dc,px,py,fadd,f.y,0,0,0,BLACKNESS);
		::BitBlt(dc,px+x-fadd,py,fadd,f.y,0,0,0,BLACKNESS);
	}
	void message_x(UINT wm, WPARAM wparam, LPARAM lparam){
		static HBRUSH back =::CreateSolidBrush(RGB(0xc0,0Xc0,0Xc0));
		static HBRUSH fore =::CreateSolidBrush(RGB(0x80,0X80,0X80));
		static HBRUSH fore2=::CreateSolidBrush(RGB(-1,0,0));
		::SelectObject(dc,back);
		BitBlt(dc,xa.x,xa.y,xn.x,xn.y,0,0,0,PATCOPY);

		if(fn.x<ll.x) {
			static ii drag_x;
			static ii drag_df;
		
			if(pos.in(xa,xn)){
				if(wm==WM_LBUTTONDOWN){
					drag=pos;
					drag_x=pos.x;
					drag_df=df.x;
				}
			}
			if(drag.in(xa,xn)){
				setdf(xy(drag_df+ll.x*(pos.x-drag_x)/xn.x,df.y));
			}


			ii len=xn.x*fn.x/ll.x;
			const ii min=f.x/2;
			if(len<min){
				len=min;
				::SelectObject(dc,fore2);
			}else{
				::SelectObject(dc,fore);
			}
			::BitBlt(dc,xa.x+xn.x*df.x/ll.x,xa.y,len,xn.y,0,0,0,PATCOPY);
		}


	}
	void message_y(UINT wm, WPARAM wparam, LPARAM lparam){
		static HBRUSH back =::CreateSolidBrush(RGB(0xc0,0Xc0,0Xc0));
		static HBRUSH fore =::CreateSolidBrush(RGB(0x80,0X80,0X80));
		static HBRUSH fore2=::CreateSolidBrush(RGB(-1,0,0));
		::SelectObject(dc,back);
		BitBlt(dc,ya.x,ya.y,yn.x,yn.y,0,0,0,PATCOPY);


		if(fn.y<ll.y){

			

			if(we->isfocus()&&wm==WM_MOUSEWHEEL&&we->include(pos)){
				int n=short(wparam>>16)/WHEEL_DELTA;
				n=-n;
				if(MK_CONTROL&wparam){
					if(n<0)setdf(df+xy(0,-fn.y));
					else if(n>0)setdf(df+xy(0,+fn.y));
				}else{
					setdf(df+xy(0,n));
				}
			}

			static ii drag_y;
			static ii drag_df;
			if(pos.in(ya,yn)){
				if(wm==WM_LBUTTONDOWN){
					drag=pos;
					drag_y=pos.y;
					drag_df=df.y;
				}
				/**/
				if(wm==WM_RBUTTONDOWN){
					xy fi=(pos-ya)/ff;
					if(0){}
					else if(fi.y==0){find_top();}
					else if(0<fi.y&&fi.y<fn.y/2){find_up();}
					else if(fn.y/2<=fi.y&&fi.y<fn.y-1){find_down();}
					else if(fi.y==fn.y-1){find_buttom();}
				}
				
			}

			if(drag.in(ya,yn)){
				setdf(xy(df.x,drag_df+ll.y*(pos.y-drag_y)/yn.y));
			}

			ii len=yn.y*fn.y/ll.y;
			const ii min=f.x/2;
			if(len<min){
				len=min;
				::SelectObject(dc,fore2);
			}else{
				::SelectObject(dc,fore);
			}
			::BitBlt(dc,ya.x,ya.y+yn.y*df.y/ll.y,yn.x,len,0,0,0,PATCOPY);
		}
	}
	void message_z(UINT wm, WPARAM wparam, LPARAM lparam){
		static HBRUSH back =::CreateSolidBrush(RGB(0xc0,0Xc0,0Xc0));
		::SelectObject(dc,back);
		BitBlt(dc,za.x,za.y,zn.x,zn.y,0,0,0,PATCOPY);
	}
	void set_head_file(const char*file_name){
		filename.set(file_name);
		mem m1;
		char*a=m1.a;
		ii n=utf8(a,file_name);
		set_head(a,n);
	}
	void copy(){
		if(dd!=de){
			mem mem1;
			char*sa=mem1.a;
			ii   sn=get(sa,dd,de);
			if(sn)clip_set(sa,sn);
		}
	}

	void paste(){
		mem mem1;
		char*sa=mem1.a;
		ii   sn=clip_get(sa);
		if(sn){
			set(dd,de,sa,sn);
		}
	}
	void cut(){
		if(dd!=de){
			mem mem1;
			char*sa=mem1.a;
			ii   sn=get(sa,dd,de);
			if(sn)clip_set(sa,sn);
			set(dd,de);
		}
	}
	void set_df_by_dd(){
		setdd_xy(df.x,fn.x,dd.x);setdd_xy(df.y,fn.y,dd.y);
		setdf(df);
	}
	void set_find_replace(){
		if(dd!=de){
			mem mem1;
			char*sa=mem1.a;
			ii   sn=get(sa,dd,de);
			if(sn){
				::find.setall(sa,sn);
				::replace.setall(sa,sn);
			}
		}
	}
	void menu_get(UINT const wm, WPARAM const vk, LPARAM lparam){
		if(wm==WM_RBUTTONUP&&pos.in(ea,en)){}else return;

		const int menu_id=100;
			HMENU menu=::CreatePopupMenu();
			int id=menu_id;
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"copy ");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"paste");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"cut  ");

			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"set find and replace");

			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING|find.isword,id++,"is find word");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING|find.aisA,id++,"is find aisA");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING|find.show_find,id++,"is find show");

			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"find top");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"find up");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"find down");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"find bottom");

			
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"replace selected");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"replace document");

			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"open file");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"save file");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"save as other file");

			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"window=full_work");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"window=full_screen");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"exit");

			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"k open  all");
			::InsertMenuA(menu,-1,MF_BYPOSITION|MF_STRING,id++,"k close all functions");
			POINT p;::GetCursorPos(&p);
			id=::TrackPopupMenu(menu,TPM_RETURNCMD,p.x,p.y,0,window,0);
			::DestroyMenu(menu);
			int id2=menu_id;
			if(0){}
			else if(id==id2++){copy();}
			else if(id==id2++){paste();}
			else if(id==id2++){cut();}

			else if(id==id2++){set_find_replace();}

			else if(id==id2++){find.isword^=MF_CHECKED;}
			else if(id==id2++){find.aisA^=MF_CHECKED;}
			else if(id==id2++){find.show_find^=MF_CHECKED;}

			else if(id==id2++){find_top();}
			else if(id==id2++){find_up();}
			else if(id==id2++){find_down();}
			else if(id==id2++){find_buttom();}

			else if(id==id2++){replace(de,dd);}
			else if(id==id2++){replace(xy(0),xy(la[ll.y-1]->x,ll.y-1));}
			
			else if(id==id2++){open_file();}
			else if(id==id2++){save_file();}
			else if(id==id2++){save_file(1);}

			else if(id==id2++){full_work();}
			else if(id==id2++){full_screen();}
		
			else if(id==id2++){::exit(0);}

			else if(id==id2++){set_k_open_all();}
			else if(id==id2++){set_k_close_all_functions();}
	}
	int finds(ii y,ii ia,ii ib,int is_first,int is_de_dd){
		mem mem1;
		char*da=mem1.a;
		kget_have=0;
		char*db=da;
		kget2(db,la[y]->a,la[y]->n);
		ii sn=db-da;
		ii sx=0;
		ii sy=y;
		ii dx=-1;
		ii dy=-1;
		for(const char*sa=da,*sb=da+sn,*s=sa;s<sb;){
			const ii si=s-sa;
			const ii xa=sx;
			if(*s==char_ret){
				s++;
				sx++;

				sy++;
				sx=0;
				continue;/////////
			}
			getsx(s,sx);
			if(ia<=si&&si<ib&&::find.cmp(sa,sb-sa,si)){
				dx=xa;
				dy=sy;
				if(is_first)break;
			}

		}
		if(dx>=0){
			const ii xa=dx;
			const ii sy=dy;

			if(kget_have){

				mt&d=this[1];
				d.ca=d.cb=cb;
				d.la=d.lb=lb;

				for(ii i=0;i<y;i++)*d.lb++=la[i];
				d.setcblb(da,db);
				for(ii i=y+1;i<ll.y;i++)*d.lb++=la[i];

				d.setll();

				d.df=df;
				if(is_de_dd){
					d.de=xy(xa,sy);
					d.dd=xy(xa+find.dn,sy);
				}else{
					d.dd=xy(xa,sy);
					d.de=xy(xa+find.dn,sy);
				}
				d.setdf_by_dedd();
				m=mm=&d;m->update();

				return 1;/////////////

			}else{
				//printf("[%.*s]",sn-si,sa+si);
				if(is_de_dd){
					de=xy(xa,sy);
					dd=xy(xa+find.dn,sy);
				}else{
					dd=xy(xa,sy);
					de=xy(xa+find.dn,sy);
				}
				setdf_by_dedd();
				return 1;/////////
			}
			return 1;
		}
		return 0;

	}
	void find_top(){
		if(find.dn>0){}else return;////////////
		for(ii y=0;y<ll.y;y++)if(finds(y,0,uu(1)<<60,1,0))return;//////
	}
	void find_down(){
		
		if(find.dn>0){}else return;////////////
		ii y=dd.y;
		{

			ii sx=0;
			for(const char*sa=la[y]->a,*sb=sa+la[y]->n,*s=sa;s<sb;){
				const ii si=s-sa;
				const ii x1=sx;
				getsx(s,sx);
				const ii x2=sx-1;
				if(dd.x==x1){
					mem mem1;
					char*da=mem1.a;
					kget_have=0;
					char*db=da;
					kget2(db,la[y]->a,si);
					ii dn=db-da;
					if(finds(y,dn,uu(1)<<60,1,1))return;///////////
					break;
				}
			}
		}
		for(y++;y<ll.y;y++)if(finds(y,0,uu(1)<<60,1,1))return;//////
	
	}
	
	void find_up(){
		if(find.dn>0){}else return;////////////
		ii y=dd.y;
		{
			ii sx=0;
			for(const char*sa=la[y]->a,*sb=sa+la[y]->n,*s=sa;s<sb;){
				const ii si=s-sa;
				const ii x1=sx;
				getsx(s,sx);
				const ii x2=sx-1;
				if(dd.x==x1){
					mem mem1;
					char*da=mem1.a;
					kget_have=0;
					char*db=da;
					kget2(db,la[y]->a,si);
					ii dn=db-da;
					if(finds(y,0,dn,0,0))return;///////////
					break;
				}
			}
		}
		for(y--;0<=y;y--)if(finds(y,0,uu(1)<<60,0,0))return;///////
	}
	void find_buttom(){
		if(find.dn>0){}else return;////////////
		for(ii y=ll.y-1;0<=y;y--)if(finds(y,0,uu(1)<<60,0,1))return;;
	}
	void replace(xy ia,xy ib){
		if(find.dn>0){}else return;////////////
		mem mem1;
		char*sa=mem1.a;

		ii sn=get(sa,ia,ib);
		mem mem2;
		char*da=mem2.a;
		char*db=da;
		::replace.number=0;
		for(ii si=0;si<sn;){
			if(find.cmp(sa,sn,si)){
				::replace.number++;
				for(ii i=0;i<::replace.dn;i++)*db++=::replace.da[i];
				si+=find.dn;
			}else{
				*db++=sa[si];
				si++;
			}
		}
		if(0==::replace.number)return;//////////
		set(ia,ib,da,db-da);

	}

	void save_file(int other=0){
		::SetCursor(cursor_wait);
		mem mem1;
		char*da=mem1.a;
		ii dn=get(da,xy(0,0),xy(la[ll.y-1]->x-1,ll.y-1));
		if(dn<=0)return;/////////////



		if(other||0==*filename.a){

			OPENFILENAMEA ofn={sizeof(ofn),}; 
			ofn.lStructSize = sizeof(OPENFILENAME); 
			ofn.hwndOwner = window; 
			ofn.lpstrFilter = "\0\0\0"; \

				char szFile[0x1000];
			*szFile='\0';
			ofn.lpstrFile= szFile; 
			ofn.nMaxFile = sizeof(szFile)/ sizeof(*szFile); 

			ofn.lpstrInitialDir = (LPSTR)NULL; 
			//ofn.Flags = OFN_SHOWHELP | OFN_OVERWRITEPROMPT; 
			ofn.lpstrTitle =0;

			::SetWindowLongPtr(window,GWLP_WNDPROC ,LONG_PTR(::DefWindowProcA));
			GetSaveFileName(&ofn);
			::SetWindowLongPtr(window,GWLP_WNDPROC ,LONG_PTR(window_proc));

			{
				HIMC imc=::ImmGetContext(window);
				LOGFONTA f={};
				f.lfHeight=-::f.y;
				f.lfCharSet=DEFAULT_CHARSET;
				f.lfWeight=FW_THIN;
				f.lfQuality=CLEARTYPE_QUALITY;
				strcpy(f.lfFaceName,"Consolas");
				::ImmSetCompositionFontA(imc,&f);
				::ImmReleaseContext(window,imc);
			}
			if(*ofn.lpstrFile){
				filename.set(szFile);

			}else{
				return;//////////////
			}

		}
		set_head(da,dn);
		file_set(da,dn,filename.a);
	}
	void open_file(){
		::SetCursor(cursor_wait);
		OPENFILENAMEA ofn={};       // common dialog box structure
		char szFile[0x1000]={};       // buffer for file name

		// Initialize OPENFILENAME
		ZeroMemory(&ofn, sizeof(ofn));
		ofn.lStructSize = sizeof(ofn);
		ofn.hwndOwner = window;
		ofn.lpstrFile = szFile;
		// Set lpstrFile[0] to '\0' so that GetOpenFileName does not 
		// use the contents of szFile to initialize itself.
		ofn.lpstrFile[0] = '\0';
		ofn.nMaxFile = sizeof(szFile);
		ofn.lpstrFilter = "All\0*.*\0Text\0*.TXT\0";
		ofn.nFilterIndex = 1;
		ofn.lpstrFileTitle = NULL;
		ofn.nMaxFileTitle = 0;
		ofn.lpstrInitialDir = NULL;
		ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

		// Display the Open dialog box. 
		::SetWindowLongPtr(window,GWLP_WNDPROC ,LONG_PTR(::DefWindowProcA));
		GetOpenFileNameA(&ofn);
		::SetWindowLongPtr(window,GWLP_WNDPROC ,LONG_PTR(window_proc));
		if(*ofn.lpstrFile){
			outs(ofn.lpstrFile);
			ma->set_head_file(ofn.lpstrFile);
		}

		{
			HIMC imc=::ImmGetContext(window);
			LOGFONTA f={};
			f.lfHeight=-::f.y;
			f.lfCharSet=DEFAULT_CHARSET;
			f.lfWeight=FW_THIN;
			f.lfQuality=CLEARTYPE_QUALITY;
			strcpy(f.lfFaceName,"Consolas");
			::ImmSetCompositionFontA(imc,&f);
			::ImmReleaseContext(window,imc);
		}
	}

	void update(){
		kall_have=0;
		kall_b=kall_a;
		for(ii y=0;y<ll.y;y++)ky[y].m=0;
		
		mem mem1;
		xy*pa=(xy*)mem1.a;
		xy*pb=pa;
		mem mem2;
		char**pall=(char**)mem2.a;


		const ii color_comment=RGB(0X80,0,0);
		const ii color_char=RGB(0X80,0X60,0);
		const ii color_operator=RGB(0,0x80,0);

		bool comment=0;
		xy comment_ia;
		char*comment_all;
		int*color=colora;
		char char_op=0;
		for(ii y=0;y<ll.y;y++){
			colory[y]=color;
			

			const char*sa=la[y]->a;
			const char*sb=la[y]->a+la[y]->n;if(y==ll.y-1)sb--;
			const char*s=sa;
			ii x=0;
			while(s<sb){
				const char*ss=s;
				ii xa=x;
				if(comment){
					if(s[0]=='*'&&s[1]=='/'){
						s+=2;
						x+=2;
						comment=0;
						xy comment_ib=xy(x,y);
						kyset(this,comment_ia,comment_ib,1);
						while(xa<x)colory[y][xa++]=color_comment;
						for(const char*p=ss;p<s;p++)*kall_b++=*p;
						{
							int have=0;
							for(xy*p=pa;p<pb;p++)if(pall[p-pa]){have=1;break;}
							if(0==have&&comment_ia.y<comment_ib.y&&kall_a<=comment_all&&comment_all<kall_b){
								kall_b=comment_all;
								*kall_b++=0;
								((kt*)(kall_b))->set(this,comment_ia,comment_ib,1);kall_b+=sizeof(kt);
								*kall_b++=0;

								kall_have=1;
							}
						}
						continue;
					}
					getsx(s,x);
					while(xa<x)colory[y][xa++]=color_comment;
					for(const char*p=ss;p<s;p++)*kall_b++=*p;
					continue;///////////
				}
				if(s[0]=='/'&&s[1]=='*'){
					comment_all=kall_b;
					comment_ia=xy(x,y);

					s+=2;
					x+=2;
					comment=1;
					

					while(xa<x)colory[y][xa++]=color_comment;
					for(const char*p=ss;p<s;p++)*kall_b++=*p;
					continue;////////
				}
				if(s[0]=='/'&&s[1]=='/'){
					s+=2;
					x+=2;
					while(s<sb)getsx(s,x);
					while(xa<x)colory[y][xa++]=color_comment;
					for(const char*p=ss;p<s;p++)*kall_b++=*p;
					continue;
				}
				if(*s=='\''){
					const char c=*s;
					s++;
					x++;
					while(s<sb){
						if(*s==c){
							s++;
							x++;
							break;
						}
						if(*s=='\\'){
							s++;
							x++;
							if(s<sb)getsx(s,x);
							continue;
						}
						
						getsx(s,x);
					}
					
					while(xa<x)colory[y][xa++]=color_char;
					for(const char*p=ss;p<s;p++)*kall_b++=*p;
					continue;
				}
				if(*s=='\"'){
					const char c=*s;
					s++;
					x++;
					while(s<sb){
						if(*s==c){
							s++;
							x++;
							break;
						}
						if(*s=='\\'){
							s++;
							x++;
							if(s<sb)getsx(s,x);
							continue;
						}
						
						getsx(s,x);
					}
					
					while(xa<x)colory[y][xa++]=color_char;
					for(const char*p=ss;p<s;p++)*kall_b++=*p;
					continue;
				}
				if(*s=='{'){
					int have=0;
					for(xy*p=pa;p<pb;p++)if(pall[p-pa]){have=1;break;}
					
					pall[pb-pa]=(0==have&&char_op==')'?kall_b:0);
					*pb++=xy(x,y);
					s++;
					x++;
					while(xa<x)colory[y][xa++]=color_operator;
					for(const char*p=ss;p<s;p++)*kall_b++=*p;
					continue;
				}
				if(*s=='}'){
					s++;
					x++;
					for(const char*p=ss;p<s;p++)*kall_b++=*p;
					if(pb>pa){
						pb--;
						xy ia=*pb;
						xy ib=xy(x,y);
						kyset(this,ia,ib,0);
						if(ia.y<ib.y&&kall_a<=pall[pb-pa]&&pall[pb-pa]<kall_b){

							
							//printf("###################\n");printf("%.*s",kall_b-pall[pb-pa],pall[pb-pa]);printf("###################\n");
							
							
							
							kall_b=pall[pb-pa];
							*kall_b++=0;
							((kt*)(kall_b))->set(this,ia,ib,0);kall_b+=sizeof(kt);
							*kall_b++=0;
							kall_have=1;
							pall[pb-pa]=0;
						}
					}
					while(xa<x)colory[y][xa++]=color_operator;
					
					continue;
				}

				getsx(s,x);
				if(op_char(*ss)){
					while(xa<x)colory[y][xa++]=color_operator;
					char_op=*ss;
				}else{
					while(xa<x)colory[y][xa++]=0;	
				}
				for(const char*p=ss;p<s;p++)*kall_b++=*p;

			}
			color+=x;
		}
	}
	
}*ma,*m,*mm;

struct edit:wt{
	void init(){

		wa=xy(0,wy1);
		wn=xy(wx1+wx2,wy2);

		
		fn.x=(wn.x-(bian+tiao)*2)/f.x;
		zn.x=yn.x=tiao;
		xn.x=en.x=fn.x*f.x;
		fn.y=(wn.y-(bian+tiao+bian))/ff.y;
		zn.y=en.y=yn.y=fn.y*ff.y;
		xn.y=tiao;



		vn.x=zn.x+en.x+yn.x;
		vn.y=en.y+xn.y;
		va=wa+(wn-vn)/2;

		za=va;
		ea=xy(va.x+zn.x,va.y);
		ya=xy(va.x+zn.x+en.x,va.y);
		xa=xy(va.x+zn.x,va.y+en.y);

	}
	void message(UINT wm, WPARAM wparam, LPARAM lparam){
	showi.dd=m->dd;
		if(isfocus()){
			m->key(wm,wparam,lparam);
			m->menu_get(wm,wparam,lparam);
		}
		m->mouse(wm,wparam,lparam);
		BitBlt(dc,va.x,va.y,vn.x,vn.y,0,0,0,WHITENESS);

		m->message_e(wm,wparam,lparam);
		m->message_x(wm,wparam,lparam);
		m->message_y(wm,wparam,lparam);
		m->message_z(wm,wparam,lparam);
		


		show_other();
		SetTextColor(dc,RGB(0,0,0));
				char ta[0x1000];
		char*tb=ta;
		tb+=sprintf(tb,"dd(%i,%i)",m->dd.x,m->dd.y);
		tb+=sprintf(tb,"de(%i,%i)",m->de.x,m->de.y);
		tb+=sprintf(tb,"df(%i,%i)",m->df.x,m->df.y);
		tb+=sprintf(tb,"ll(%i,%i)",m->ll.x,m->ll.y);
		tb+=sprintf(tb,"mm(%i/%i)",::m-::ma,::mm-::ma);
		tb+=sprintf(tb,"replace(%i)",::replace.number);
		::TextOutA(dc,xa.x,xa.y,ta,tb-ta);


		if(wm==WM_MOUSEMOVE){
			if(wa<=pos&&pos<wa+wn){
				if(ea<=pos&&pos<ea+en){
					::SetCursor(cursor_I);
				}else{
					::SetCursor(cursor_arrow);
				}
			}
		}
		{
			xy a(xa.x+xn.x,xa.y);
			xy n(yn.x,xn.y);
			//static HBRUSH back =::CreateSolidBrush(RGB(0,0XFF0,0XFF));::SelectObject(dc,back);BitBlt(dc,a.x,a.y,n.x,n.y,0,0,0,PATCOPY);
			if(wm==WM_RBUTTONUP&&pos.in(a,n)){

				POINT p;::GetCursorPos(&p);
				int id=::TrackPopupMenu(font.menu,TPM_RETURNCMD,p.x,p.y,0,window,0);
				//::geterr();
				font.create(id-font.menu_id);
			}
			::TextOutA(dc,xa.x+xn.x,xa.y,font.size_a,font.size_n);
		}



	}
	xy   get_pos(){
		xy f=ff;
		m->set_df_by_dd();

		return ea+(m->dd-m->df)*f;
	}
	void set(const char*sa,ii sn){
		m->set(m->de,m->dd,sa,sn);
	}
	edit(){
		we=wfocus=this;
		err0(ma=(mt*)memget());
		err0(ma->ca=(mt::lt*)memget());
		err0(ma->la=(mt::lt**)memget());

	//ma->set_head_file("cpp.cpp");return;
	
	if(2<=__argc){
		ma->set_head_file(__argv[1]);
	}else {
		ma->set_head();
	}
	}
	
}
edit
	;
LRESULT (CALLBACK window_proc)(HWND hwnd, const UINT wm, WPARAM wparam, LPARAM lparam){



	if(WM_DROPFILES==wm){
		char a[0x1000];
		if(::DragQueryFileA(HDROP(wparam),0,a,sizeof(a))){
			filename.set(a);
			ma->set_head_file(a);
			we=wfocus=&edit;
			::SetFocus(window);
		}
	}


	if(wm==WM_SIZE){
		client.x=u16(lparam);
		client.y=u16(lparam>>16);
		winit();
	}
	if(wm==WM_SETFOCUS){have_focus=1;}
	if(wm==WM_KILLFOCUS){have_focus=0;}
	//if(wm==WM_KILLFOCUS)::exit(0);
	if(wm==WM_CLOSE)::ExitProcess(0);
	if(wm==WM_PAINT){
		PAINTSTRUCT ps; 
		HDC hdc; 
		hdc = BeginPaint(hwnd, &ps); 
		EndPaint(hwnd, &ps); 
	}
	if(wm_can(wm)){}else return ::DefWindowProcA(hwnd,wm,wparam,lparam);///////////

	if(werr){
		::BitBlt(dc_window,0,0,client.x,client.y,0,0,0,BLACKNESS);
		return ::DefWindowProcA(hwnd,wm,wparam,lparam);
	}
	//////////////////////////
	have_control=::GetAsyncKeyState(VK_CONTROL)<0;
	have_shift=::GetAsyncKeyState(VK_SHIFT)<0;
	have_lbutton=::GetAsyncKeyState(VK_LBUTTON)<0;
	if(have_lbutton){}else drag=-1;////////
	{
		POINT pos;
		::GetCursorPos(&pos);
		::ScreenToClient(window,&pos);
		::pos=xy(pos.x,pos.y);
	}
	{	
		if(WM_LBUTTONDOWN==wm||WM_RBUTTONDOWN==wm||WM_MBUTTONDOWN==wm){
			for(wt**w=wa;w<wb;w++)if((*w)->include(pos)){wfocus=*w;break;}
		}
	}
	if(WM_IME_STARTCOMPOSITION==wm){
		
		static HIMC imc=::ImmGetContext(window);

		static int size=0;if(size!=font.size){size=font.size;
		LOGFONTA f={};
		f.lfHeight=-::f.y;
		f.lfCharSet=DEFAULT_CHARSET;
		f.lfWeight=FW_THIN;
		f.lfQuality=CLEARTYPE_QUALITY;
		strcpy(f.lfFaceName,"Consolas");
		::ImmSetCompositionFontA(imc,&f);
		}

		xy pos=wfocus->get_pos();
		COMPOSITIONFORM d={};
		d.dwStyle=CFS_RECT|CFS_FORCE_POSITION;
		d.rcArea.left=pos.x;
		d.rcArea.top=pos.y;
		d.rcArea.right=pos.x+0x1000;
		d.rcArea.bottom=pos.x+0x1000;

		d.ptCurrentPos.x=pos.x;
		d.ptCurrentPos.y=pos.y;
		::ImmSetCompositionWindow(imc,&d);
		
	}
	if(WM_CHAR==wm){
		
		static char b=0;
		const char c=wparam;
		if(c&0x80){
			if(b&0x80){
				char a[2]={b,c};
				wfocus->set(a,2);
				b=0;
			}else{
				b=c;
			}
		}else{
			if(char_min<=c&&c<=char_max)wfocus->set(&c,1);
			b=0;
		}
	}
	for(wt**w=wa;w<wb;w++)(*w)->message(wm,wparam,lparam);
	::BitBlt(dc_window,0,0,client.x,client.y,dc,0,0,SRCCOPY);
	
	return ::DefWindowProcA(hwnd,wm,wparam,lparam);
}
struct window_init{
	window_init(){
		WNDCLASSEXA wc={sizeof(wc)};
		wc.style=CS_DBLCLKS ;
		wc.hCursor=0;
		wc.lpfnWndProc=window_proc;
		wc.lpszClassName="hua";
		::RegisterClassExA(&wc);
		RECT v;
		::SystemParametersInfoA(SPI_GETWORKAREA,0,&v,0);
		xy va(v.left,v.top);
		xy vb(v.right,v.bottom);
		if(va<vb){}else err;/////////////

		xy vn=vb-va;
		vn.x/=2;
		va.x=vn.x;
		vn.y/=5;
		vn.y*=4;
		vb=va+vn;

		window=::CreateWindowExA(WS_EX_ACCEPTFILES|WS_EX_WINDOWEDGE  ,wc.lpszClassName,0,WS_OVERLAPPEDWINDOW|WS_VISIBLE,va.x,va.y,vn.x,vn.y,0,0,0,0);
		dc_window=::GetDC(window);
		imc=::ImmGetContext(window);
		::SetCursor(::LoadCursorA(0,IDC_ARROW ));
		::SetTimer(window,'100',50,0);
		::SetWindowTextA(window,filename.a);
	}

}window_init;

void full_screen(){
	::SetWindowLongPtr(window,GWL_STYLE ,LONG_PTR(WS_POPUPWINDOW|WS_VISIBLE));
	::SetWindowPos(window,HWND_TOPMOST,0,0,::GetSystemMetrics(SM_CXSCREEN),::GetSystemMetrics(SM_CYSCREEN),SWP_SHOWWINDOW);
}
void full_work(){
	RECT r;
	::SystemParametersInfoA(SPI_GETWORKAREA,0,&r,0);
	::SetWindowLongPtr(window,GWL_STYLE ,LONG_PTR(WS_OVERLAPPEDWINDOW|WS_VISIBLE));
	::SetWindowPos(window,HWND_TOP ,r.left,r.top,r.right-r.left,r.bottom-r.top,SWP_SHOWWINDOW);
}
void main(){
	
	while(1){
		MSG msg={};
		::GetMessageA(&msg,0,0,0);
		::TranslateMessage(&msg);
		::DispatchMessageA(&msg);
	}
}