/****************************************************************************************************************************
iphone_saver.elf (SWILIB.c)
(с)Mirrr (http://init.org.ua, mirrr@ukr.net)
(с)2008 

Разрешается модифицировать и использовать по вашему усмотрению любой документ из архива,
при условиях:
 - не удаляйте копирайты и адрес сайта, а также данное уведомление из исходных кодов программы.
 - при модификации программы не удаляйте логотип сайта http://init.org.ua, отображаемый один раз при первом запуске эльфа.

Эта программа является свободно распространяемой; Вы можете распространять ее повторно и (или) изменять, 
соблюдая условия Открытого лицензионного соглашения GNU (GNU GPL), опубликованного Фондом свободно распространяемого 
программного обеспечения; либо редакции 2 Соглашения, либо (на ваше усмотрение) любой редакции, выпущенной позже.
Эта программа распространяется в надежде на то, что она окажется полезной, но БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, 
включая подразумеваемую гарантию КАЧЕСТВА либо ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННЫХ ЦЕЛЕЙ. 

Подробности содержатся в Открытом лицензионном соглашении GNU.

Вместе с этой программой должен распространяться экземпляр Открытого лицензионного соглашения GNU, если он 
отсутствует, сообщите об этом в Фонд свободно распространяемого программного обеспечения 
(Free Software Foundation, Inc.), 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA 
***************************************************************************************************************************/







#ifndef _SWILIB_C
#define _SWILIB_C
#define ELKA
#include "readimg.h"
 void DisIconbar(int r){
#ifdef ELA
  DisableIconBar(r);
#else
  //null
#endif
}
#define scrtype short

#include "swilib.h"


#ifdef INPUT_OK
#include "string_works.c"
//#include "mainmenu.c"
#endif

#define true 1
#define false 0
#define null 0
#define HIGHCOLOR // 16-битный режим
#define GRAPH  // Графика
#define RGB16(R,G,B) ((B>31?31:B)+((G>63?63:G)<<5)+((R>31?31:R)<<11))

//#define UNPACK // Распаковка архивов
//#define NO7Z   // Кроме 7z
//#define NOZIP  // Кроме zip
//#define NORAR  // Кроме rar
//#define NOLOAD // in loadgraph data loaded allready
extern short *screen; // Экран 240*320*2
extern int screensize;
extern void DrawScreen(); // Функция перерисовки экрана
extern IMGHDR *read_pngimg(const char *buf);
extern IMGHDR *read_jpgimg(const char *buf);
extern HEADER_DESC input_hdr;

//extern int CreateInput();
int x_char (char liter, int font);
int y_char (int font);
int lenta=0;
char loggerCWILIB[512];
char RecTxt (char rec);
int intlog;// записуем нужное значение в лог
int plott(char liter, int font, int x, int y, int fcolor); //рисуем символ шрифта 
    char nite=255;
    char fastfon=0; //картинка загрузилась в память но не расчитаны координаты шрифтов:)


    int tmpfnt=0;   //временное хранилище шрифта поумолчанию  0..n-1 /где n - кол-во шрифтов
   //                      //Буфер в который полностью грузится файл картинки
    char *regfile=0;                    //Буфер в который полностью грузится файл реестра    
 
    WSHDR *wsbuf;
    char *fon=0;

//-----------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------

 int curcolor=0x1f, maskcolor=0xFf, bkcolor=-8192, frcolor=0; //последние два цвета - фона и фронта соответственно
 int menucolor=0xffff,  movecolor=0;
 int menubkcolor=0;//-8192;//-8192;
 char belex[]={0,0,0,60};
 //char bkcolor[]={0,0,0,60};
#ifdef ELKA
  #define width 240
  #define height 320
#else
  #define width 132
  #define height 176
#endif
//extern int width, height;

unsigned int err=0;
int loadfilesize=0;

#define ELKA // Для EL-71   
int bufan2=0;    
int bufan=0;

#ifndef NEWSGOLD
#define NEWSGOLD // Для S75
#endif


int strh2int(char *str){
int n,c=0;
while (*str!='\0')
{
if(*str>='a') n=*str-('A'-('9'+1))-('a'-'A');
else if (*str>='A') n=*str-('A'-('9'+1));
else n=*str;
c=c*16+(n-'0');
str++;
}return c;
}

void RunEntry(char *entry){
typedef int (*func)(void); 
func ff;
ff=(func)strh2int(entry);
if (ff!=NULL) SUBPROC((void *)(*ff));
}


#ifndef NEWSGOLD
int fread32(int fh, void *buf, int len, unsigned int *err){
  int clen, rlen, total=0;
  while(len){
  if (len>16384) clen=16384; else clen=len;
  total+=(rlen=fread(fh, buf, clen, err));
  if (rlen!=clen) break;
  buf=(char*)buf+rlen;
  len-=clen;
  }return(total);
}


int fwrite32(int fh, void *buf, int len, unsigned int *err){
  int clen, rlen, total=0;
  while(len){
  if (len>16384) clen=16384; else clen=len;
  total+=(rlen=fwrite(fh, buf, clen, err));
  if (rlen!=clen) break;
  buf=(char*)buf+rlen;
  len-=clen;
  }return(total);
}
#endif

int min(int a, int b){ return (a<b)?a:b;}
int max(int a, int b) { return (a>b)?a:b;}
//int abs(int a){ return (a<0)?-a:a;}

int fgets(char *buf,int size,int fh){ return 0;} //fake!!!
void printf(char *s,...){}  //fake!!!
char *strdup(char *s){ return s;}

int savefile(char *fname, char *buf, int size){
  int f,i;
  if((f=fopen(fname,A_WriteOnly+A_BIN+A_Create+A_Truncate,P_WRITE,&err))==-1) return 0;
  i=fwrite32(f,buf,size,&err); 
  fclose(f,&err); 
  return i;
}

//------------------------------------------------------------------------------

char *loadfile(char *filename){ // Загрузить файл, распак-ть
  int f; unsigned int err;  char *buf=0;
  if((f=fopen(filename,A_ReadOnly+A_BIN,P_READ,&err))!=-1){
    if(loadfilesize=lseek(f,0,2,&err,&err)){
      lenta=loadfilesize;
      buf=(char*)malloc(loadfilesize);
      lseek(f,0,0,&err,&err);
      if(fread32(f,buf,loadfilesize,&err)!=loadfilesize){ mfree(buf); buf=0;}
    } fclose(f,&err);
  } return buf;
}


//------------------------------------------------------------------------------
char *toup(char *str){			// К верхнему регистру
  char *val=str;
  while(*val!=NULL){
         if(*val>='a' && *val<='z')  *val-=' ';  
    else if(*val>='а' && *val<='п')  *val-=' ';  
    else if(*val>='р' && *val<='я')  *val-= 80;  
    ++val;
  }
  return str;
}
//------------------------------------------------------------------------------  

char *todown(char *str){		// К нижнему регистру
  char *val=str;
  while(*val!=NULL){
         if(*val>='A' && *val<='Z')  *val+=' '; 
    else if(*val>='А' && *val<='П')  *val+=' ';
    else if(*val>='Р' && *val<='Я')  *val+= 80; 
    ++val;
  }
  return str;
} 
//------------------------------------------------------------------------------ 

int  isalth (unsigned char sym){	// Алфавитный символ ?
  return ((sym>='A' && sym<='Z') || (sym>=(unsigned char)'А' && sym<=(unsigned char)'П')
    || (sym>=(unsigned char)'Р' && sym<=(unsigned char)'Я'));}

//------------------------------------------------------------------------------

int  isval (char sym){		// Символ является числом ?
  return (sym>='0' && sym<='9');}

//------------------------------------------------------------------------------

int strchrpos(const char *s, int c){	// Позиция символа в строке (1-N, 0=нет)
  char *sptr=strchr(s,c);
  return (sptr)?sptr-s+1:NULL;
}

//------------------------------------------------------------------------------  
int emptystr(char *str){		// Пустая ли строка
  while(*str && (*str==' ' || *str==9)) ++str;
  return ((*str)?0:1);
}

//------------------------------------------------------------------------------

int   strcmpsize (const char *s1,const char *s2,int size){ // Сравнить строки длины size
  int i;
  for(i=0;i<size && s1[i]==s2[i];i++);
    return (i==size)?NULL:s1[i]-s2[i];
}

//------------------------------------------------------------------------------

int getint(void *ptr){ // Получить int
  if((int)ptr & 3) return *(unsigned char*)ptr | *((unsigned char*)ptr+1)<<8\
    | *((unsigned char*)ptr+2)<<16 | *((unsigned char*)ptr+3)<<24;
  else return *(int*)ptr;
}

//------------------------------------------------------------------------------

int get3int(void *ptr ){ // Получить 3int
  return *(unsigned char*)ptr | *((unsigned char*)ptr+1)<<8 | *((unsigned char*)ptr+2)<<16; 
}

//------------------------------------------------------------------------------

short getshort(void *ptr){ // Получить short
  if((int)ptr & 1) return *(unsigned char*)ptr | *((unsigned char*)ptr+1)<<8;
  else return *(short*)ptr;
}

//------------------------------------------------------------------------------

void putint(void *ptr, int data){ // Записать int
  if((int)ptr & 3){ *(char*)ptr=data; *((char*)ptr+1)=data>>8;
    *((char*)ptr+2)=data>>16; *((char*)ptr+3)=data>>24;
  }else *(int*)ptr=data;
  
}
//------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------ |||||||||||||||||||||||||||||||||||||||||||||||||||||||
//------------------------------------------------------------------------------------------------------------
char *intToChar(int data){ // Записать int
char *buf=0;    
buf="               ";
sprintf(buf,"%i ",data);
return buf;  
}





//------------------------------------------------------------------------------

void putshort(void *ptr, short data){ // Записать short
  if((int)ptr & 1){ *(char*)ptr=data; *((char*)ptr+1)=data>>8;
  }else *(short*)ptr=data;
}

//------------------------------------------------------------------------------

#ifdef GRAPH
/*-----------------------------
смещ.	размер	имя
00	2	'BM'
02	4	Размер файла в байтах;
06	2	0
08	2	0
10	4	Смещение начала изображения в файле;
14	4	Размер этого заголовка, 40;
18	4	Ширина изображения в пикселях;
22	4	Высота изображения в пикселях;
26	2	Число плоскостей изображения, 1;
28	2	Бит на пиксел: 1,4,8 или 24;
30	4	Тип сжатия;
34	4	Размер сжатого изображения в байтах или 0;
38	4	Горизонтальное разрешение, в пикселях / на метр;
42	4	Вертикальное разрешение, в пикселях / на метр;
46	4	Количество используемых цветов;
50	4	Число "важных" цветов;
54	4*N	Карты цветов BGRР;

BMP	заголовок 54 б + палитра 4*256;*/

inline unsigned char rgb888tobyte(int color){
  return ((color>>6)&3)|((color>>11)&0x1C)|((color>>16)&0xE0); }

inline short rgb888toshort(int color){
  return ((color>>3)&0x1f)|((color>>5)&0x7e0)|((color>>8)&0xf800); }

inline unsigned char rgb565tobyte(short color){
  return ((color>>3)&3)|((color>>6)&0x1C)|((color>>8)&0xE0); }

inline short rgb565toshort(short color){
  return color; }


int loadgraphsize=0;
#ifndef HIGHCOLOR
  const int graphpoints=1;
#else  
  const int graphpoints=2;
#endif
// Формат файла 2б х 2б у  далее точки (повернуты как надо, без выравнивания)
char *loadgraph(char *filename){ // Загрузить графику (распаковываем и перекодируем) #define HIGHCOLOR учесть
  
  unsigned char *bmp=0, *buf=0, *pbuf, *pbmp, *ptr;
  int *pal;
  int sizex, sizey, bytepixel, pitch;
  int i,j;
  do{
    if(!(bmp=(unsigned char*)loadfile(filename))) break;
    if(getshort(bmp)!='MB') break;
    
    sizex=getint(bmp+18);
    sizey=getint(bmp+22);    bytepixel=getshort(bmp+28)>>3;
    
    



    if(sizex<1 || sizey<1 || bytepixel<1 || bytepixel>4) break;
    
    pitch=sizex*bytepixel; //Размер строки
 
    if(pitch&3) pitch+=4-(pitch&3); //Выравнивание на 4
 
    if(!(buf=(unsigned char*)malloc(loadgraphsize=sizex*sizey*graphpoints+4))) break;

    *(short*)buf=sizex; *(short*)(buf+2)=sizey;     //записываются размеры картинки в первые 4 байта
    


    pbuf=buf+4;
    ptr=bmp+getint(bmp+10)+sizey*pitch;
    
//------------------------------------------------------------------------------------------------------
    
    switch(bytepixel){
    case 1: //8 -> 8
      memcpy(pal=(int*)(bmp+52),bmp+54,*(short*)(bmp+50)?(*(short*)(bmp+50)<<2):1024);
    for(j=0;j<sizey;j++){
      pbmp=(ptr-=pitch);
      for(i=0;i<sizex;i++){
        *pbuf++=rgb888tobyte(pal[*pbmp++]);
    }  } break;
    
    
    
    
    
    case 2: //16 bit
    for(j=0;j<sizey;j++){
      pbmp=(ptr-=pitch);
      for(i=0;i<sizex;i++){
        
        *pbuf++=rgb565toshort(*(short*)pbmp);
        *pbuf++;        
        pbmp+=4;
    }  } break;
    
    
    
    
    case 3: //24 bit
    for(j=0;j<sizey;j++){
      pbmp=(ptr-=pitch);
      for(i=0;i<sizex;i++){
        *pbuf++=rgb888tobyte(get3int(pbmp));
        pbmp+=3;
    }  } break;
    case 4: //32 bit
    if((i=getint(bmp+10))&3){ //Выровнять данные на границу 4
      j=i-(i&3);
      memcpy(bmp+j, bmp+i, sizey*pitch);
      ptr=bmp+j+sizey*pitch;
    }
    for(j=0;j<sizey;j++){
      pbmp=(ptr-=pitch);
      for(i=0;i<sizex;i++){
        *pbuf++=rgb888tobyte(*(int*)pbmp);
        pbmp+=4;
    }  } break;
    //------------------------------------------------------------------------------------------------------
    }
    mfree(bmp);
    return (char*)buf;
  }while(0);
  if(bmp) mfree(bmp);
  if(buf) mfree(buf);
  return 0;
}
#endif




//============================================================================== D R A W S Y M S ===============================================

//============================================================================== D R A W S Y M F O N ===========================================

//============================================================================== D R A W S Y M ==================================================



//################################################################################ D R A W I M G ###########################################################
//Рисует область из рисунка в точку (х,y) экрана
int drawim(IMGHDR * onse, int x, int y, int xRect, int yRect,int xxRect, int yyRect ){ //последние параметры - рисуемая область из картинки
if (!onse) return 1;
//--------------------------------------------------------------------------------------------------------------------------------------------  
if (yRect<0 || yRect>=onse->h)yRect=0;  if (xRect<0 || xRect>=onse->w)xRect=0;  // область в картинке не должна начинаться за ней:)
if (yyRect==0 || (yRect+yyRect>=onse->h))yyRect=onse->h-yRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
if (xxRect==0 || (xRect+xxRect>=onse->w))xxRect=onse->w-xRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
int *pic=(int*)((char*)onse->bitmap);
int i,j,nsize;
//sprintf(logger,"Размер картинки: %i*%i,Tran:%i=%i\nРазмер экрана: %i",onse->h,onse->w, pic[0],  onse->h*onse->w*bits,screensize);
//-----------------------------------------------
int *sc=0;
IMGHDR FI[12]={xxRect,yyRect,8,0,0,0};
FI->w=xxRect;
FI->h=yyRect;
FI->bpnum=0xA;
FI->bitmap=(char *)(sc=(int*)malloc(nsize=xxRect*yyRect*sizeof(int)));
  
  memset(sc,0,nsize);
int *scr=(int*)((char*)FI->bitmap); 
for (i = xRect; i<xRect+xxRect; i++) for(j = yRect; j<yRect+yyRect; j++){
if (((y+j-yRect)<320) && ((x+i-xRect)<240) && ((y+j-yRect)>=0) && ((x+i-yRect)>=0) &&(i>=xRect)&&(j>=yRect)&&(i<xRect+xxRect)&&(j<yRect+yyRect))
{scr[j*xxRect+i]=pic[(j)*onse->w+i];}}


  RECT rc2;  DRWOBJ dobj; StoreXYWHtoRECT(&rc2,x,y,xxRect,yyRect);
  SetPropTo_Obj5(&dobj,&rc2,0,(IMGHDR*)&FI);
  DrawObject(&dobj);  

if(sc) mfree(sc);
 return 0;}

//##########################################################################################################################################################
//Рисует область из рисунка в точку (х,y) экранного буфера.
int drawimb(IMGHDR * onse, int x, int y, int xRect, int yRect,int xxRect, int yyRect){ //последние параметры - рисуемая область из картинки
if (!onse) return 1;
if (yRect<0 || yRect>=onse->h)yRect=0;  if (xRect<0 || xRect>=onse->w)xRect=0;  // область в картинке не должна начинаться за ней:)
if (yyRect==0 || (yRect+yyRect>=onse->h))yyRect=onse->h-yRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
if (xxRect==0 || (xRect+xxRect>=onse->w))xxRect=onse->w-xRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
short *scr=(short*)screen; 
char *pic=(char*)onse->bitmap;
int i,j;

for (i = xRect; i<xRect+xxRect; i++)for(j = yRect; j<yRect+yyRect; j++){ //i в диапазоне области ВОП рисунка (от xRect до xRect+xxRect)
                                                                         //j в диапазоне области ВОП рисунка (от yRect до yRect+yyRect)
if (((y+j-yRect)<320) && ((x+i-xRect)<240) && ((y+j-yRect)>=0) && ((x+i-xRect)>=0) 
    &&(i>=xRect)&&(j>=yRect)&&(i<xRect+xxRect)&&(j<yRect+yyRect))
 {
   
 scr[(y+j-yRect)*240+i+x-xRect]=RGB16(pic[((j)*onse->w+i)*4+0],pic[((j)*onse->w+i)*4+1],pic[((j)*onse->w+i)*4+2])  ;

 }}
 return 0;
}
//##########################################################################################################################################################
//Рисует область из 1 рисунка в точку (х,y) второго рисунка.
int drawimg2img(IMGHDR * onse, IMGHDR * timage2, int x, int y, int xRect, int yRect,int xxRect, int yyRect){ //последние параметры - рисуемая область из картинки
if (!onse) return 1;
if (yRect<0 || yRect>=onse->h)yRect=0;  if (xRect<0 || xRect>=onse->w)xRect=0;  // область в картинке не должна начинаться за ней:)
if (yyRect==0 || (yRect+yyRect>=onse->h))yyRect=onse->h-yRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
if (xxRect==0 || (xRect+xxRect>=onse->w))xxRect=onse->w-xRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
int *scr=(int*)((char*)timage2->bitmap), *pic=(int*)((char*)onse->bitmap);
int i,j;

for (i = xRect; i<xRect+xxRect; i++)for(j = yRect; j<yRect+yyRect; j++){ //i в диапазоне области ВОП рисунка (от xRect до xRect+xxRect)
                                                                         //j в диапазоне области ВОП рисунка (от yRect до yRect+yyRect)
if (((y+j-yRect)<timage2->h) && ((x+i-xRect)<timage2->w) && ((y+j-yRect)>=0) && ((x+i-xRect)>=0) 
    &&(i>=xRect)&&(j>=yRect)&&(i<xRect+xxRect)&&(j<yRect+yyRect))
 {
   
 scr[(y+j-yRect)*timage2->w+i+x-xRect]=pic[(j)*onse->w+i];

 }}
 return 0;
}
//##########################################################################################################################################################

int light2img(IMGHDR * timage, int povtor, int shir, int EFFECT_, const char colo_[4]){ //20.29   //25 - 140
if (!timage) return 1;
char *scrchar=timage->bitmap;
int i,j,tt,t1,t2,t3,fg;




if (EFFECT_==0) {
for (fg = 0; fg<povtor; fg++){
for (i = 0; i<timage->w; i++)for(j = 0; j<timage->h; j++){ //i-столбец, j-строка
if (scrchar[((j*timage->w)+i)*4+3]<shir){
  tt = scrchar[((j*timage->w)+i)*4+3];
  if (i>0) tt = tt             + scrchar[((j*timage->w)+(i-1))*4+3]; 
  if (i<(timage->w-1)) tt = tt + scrchar[((j*timage->w)+(i+1))*4+3];
  if (j>0) tt = tt             + scrchar[(((j-1)*timage->w)+i)*4+3];     
  if (j<(timage->h-1)) tt = tt + scrchar[(((j+1)*timage->w)+i)*4+3];
  
  t1 = colo_[2];
  if (i>0) t1 = t1             + scrchar[((j*timage->w)+(i-1))*4]; 
  if (i<(timage->w-1)) t1 = t1 + scrchar[((j*timage->w)+(i+1))*4];
  if (j>0) t1 = t1             + scrchar[(((j-1)*timage->w)+i)*4];     
  if (j<(timage->h-1)) t1 = t1 + scrchar[(((j+1)*timage->w)+i)*4];
  
  t2 = colo_[1];
  if (i>0) t2 = t2             + scrchar[((j*timage->w)+(i-1))*4+1]; 
  if (i<(timage->w-1)) t2 = t2 + scrchar[((j*timage->w)+(i+1))*4+1];
  if (j>0) t2 = t2             + scrchar[(((j-1)*timage->w)+i)*4+1];     
  if (j<(timage->h-1)) t2 = t2 + scrchar[(((j+1)*timage->w)+i)*4+1];
  
  t3 = colo_[0];
  if (i>0) t3 = t3             + scrchar[((j*timage->w)+(i-1))*4+2]; 
  if (i<(timage->w-1)) t3 = t3 + scrchar[((j*timage->w)+(i+1))*4+2];
  if (j>0) t3 = t3             + scrchar[(((j-1)*timage->w)+i)*4+2];     
  if (j<(timage->h-1)) t3 = t3 + scrchar[(((j+1)*timage->w)+i)*4+2];  
  
scrchar[((j*timage->w)+i)*4+3]=tt/4.5;
scrchar[((j*timage->w)+i)*4]=t1/5;
scrchar[((j*timage->w)+i)*4+1]=t2/5;
scrchar[((j*timage->w)+i)*4+2]=t3/5;
}



//====================================================================================  очистка =================================



}

for (i = 0; i<timage->w; i++)for(j = 0; j<timage->h; j++){ //i-столбец, j-строка 
if (scrchar[((j*timage->w)+i)*4+3]<125){
  
  int ded=((scrchar[((j*timage->w)+i)*4+3])*1);
scrchar[((j*timage->w)+i)*4+3]=ded;


}}


}}


//##########################################################################################################################################################

if (EFFECT_==1) {
for (fg = 0; fg<povtor; fg++){
for (i = 0; i<timage->w; i++)for(j = 0; j<timage->h; j++){ //i-столбец, j-строка
if (scrchar[((j*timage->w)+i)*4+3]<shir){
  tt = scrchar[((j*timage->w)+i)*4+3];
  if (i>0) tt = tt             + scrchar[((j*timage->w)+(i-1))*4+3]; 
  //if (i<(timage->w-1)) tt = tt + scrchar[((j*timage->w)+(i+1))*4+3];
  if (j>0) tt = tt             + scrchar[(((j-1)*timage->w)+i)*4+3];     
 // if (j<(timage->h-1)) tt = tt + scrchar[(((j+1)*timage->w)+i)*4+3];
  
  t1 = colo_[2];
  if (i>0) t1 = t1             + scrchar[((j*timage->w)+(i-1))*4]; 
  //if (i<(timage->w-1)) t1 = t1 + scrchar[((j*timage->w)+(i+1))*4];
  if (j>0) t1 = t1             + scrchar[(((j-1)*timage->w)+i)*4];     
 // if (j<(timage->h-1)) t1 = t1 + scrchar[(((j+1)*timage->w)+i)*4];
  
  t2 = colo_[1];
  if (i>0) t2 = t2             + scrchar[((j*timage->w)+(i-1))*4+1]; 
 // if (i<(timage->w-1)) t2 = t2 + scrchar[((j*timage->w)+(i+1))*4+1];
  if (j>0) t2 = t2             + scrchar[(((j-1)*timage->w)+i)*4+1];     
 // if (j<(timage->h-1)) t2 = t2 + scrchar[(((j+1)*timage->w)+i)*4+1];
  
  t3 = colo_[0];
  if (i>0) t3 = t3             + scrchar[((j*timage->w)+(i-1))*4+2]; 
 // if (i<(timage->w-1)) t3 = t3 + scrchar[((j*timage->w)+(i+1))*4+2];
  if (j>0) t3 = t3             + scrchar[(((j-1)*timage->w)+i)*4+2];     
  //if (j<(timage->h-1)) t3 = t3 + scrchar[(((j+1)*timage->w)+i)*4+2];  
  
scrchar[((j*timage->w)+i)*4+3]=tt/3;
scrchar[((j*timage->w)+i)*4]=t1/3;
scrchar[((j*timage->w)+i)*4+1]=t2/3;
scrchar[((j*timage->w)+i)*4+2]=t3/3;
}



//====================================================================================  очистка =================================



}

for (i = 0; i<timage->w; i++)for(j = 0; j<timage->h; j++){ //i-столбец, j-строка 
if (scrchar[((j*timage->w)+i)*4+3]<125){
  
  int ded=((scrchar[((j*timage->w)+i)*4+3])*1);
scrchar[((j*timage->w)+i)*4+3]=ded;


}}


}}
//##########################################################################################################################################################


if (EFFECT_==2) {
for (fg = 0; fg<povtor; fg++){
for (i = 0; i<timage->w; i++)for(j = 0; j<timage->h; j++){ //i-столбец, j-строка
if (scrchar[((j*timage->w)+i)*4+3]<shir){
  tt = scrchar[((j*timage->w)+i)*4+3];
  if (i>0) tt = tt             + scrchar[((j*timage->w)+(i-1))*4+3]; 
  if (i<(timage->w-1)) tt = tt + scrchar[((j*timage->w)+(i+1))*4+3];
  if (j>0) tt = tt             + scrchar[(((j-1)*timage->w)+i)*4+3];     
  if (j<(timage->h-1)) tt = tt + scrchar[(((j+1)*timage->w)+i)*4+3];
  
  t1 = 0;
  if (i>0) t1 = t1             + scrchar[((j*timage->w)+(i-1))*4]; 
  if (i<(timage->w-1)) t1 = t1 + scrchar[((j*timage->w)+(i+1))*4];
  if (j>0) t1 = t1             + scrchar[(((j-1)*timage->w)+i)*4];     
  if (j<(timage->h-1)) t1 = t1 + scrchar[(((j+1)*timage->w)+i)*4];
  
  t2 = 0;
  if (i>0) t2 = t2             + scrchar[((j*timage->w)+(i-1))*4+1]; 
  if (i<(timage->w-1)) t2 = t2 + scrchar[((j*timage->w)+(i+1))*4+1];
  if (j>0) t2 = t2             + scrchar[(((j-1)*timage->w)+i)*4+1];     
  if (j<(timage->h-1)) t2 = t2 + scrchar[(((j+1)*timage->w)+i)*4+1];
  
  t3 = 0;
  if (i>0) t3 = t3             + scrchar[((j*timage->w)+(i-1))*4+2]; 
  if (i<(timage->w-1)) t3 = t3 + scrchar[((j*timage->w)+(i+1))*4+2];
  if (j>0) t3 = t3             + scrchar[(((j-1)*timage->w)+i)*4+2];     
  if (j<(timage->h-1)) t3 = t3 + scrchar[(((j+1)*timage->w)+i)*4+2];  
  
scrchar[((j*timage->w)+i)*4+3]=tt/4;
scrchar[((j*timage->w)+i)*4]=t1/4;
scrchar[((j*timage->w)+i)*4+1]=t2/4;
scrchar[((j*timage->w)+i)*4+2]=t3/4;
}



//====================================================================================  очистка =================================



}

for (i = 0; i<timage->w; i++)for(j = 0; j<timage->h; j++){ //i-столбец, j-строка 
if (scrchar[((j*timage->w)+i)*4+3]<125){
  
  int ded=((scrchar[((j*timage->w)+i)*4+3])*1);
scrchar[((j*timage->w)+i)*4+3]=ded;


}}


}}

 return 0;
}
//##########################################################################################################################################################

DrwPngImg(IMGHDR *img, int x, int y)
{
  RECT rc;
  DRWOBJ drwobj;
  StoreXYWHtoRECT(&rc, x, y, img->w, img->h);
  SetPropTo_Obj5(&drwobj, &rc, 0, img);
  //SetColor(&drwobj, pen, brush);
  DrawObject(&drwobj);
}
//##########################################################################################################################################################
//Увеличить рисунок.

IMGHDR *morimg(IMGHDR * onse, int rf, int EFFECT_)
{
  if (!onse) return 0;
IMGHDR *outkasta;
outkasta = CreateImgr((onse->w+rf), (onse->h+rf));
 if (EFFECT_==1) drawimg2img(onse, outkasta, 0, 0, 0, 0,onse->w, onse->h);  
 else drawimg2img(onse, outkasta, rf/2, rf/2, 0, 0,onse->w, onse->h);
return (outkasta);}
  



//##########################################################################################################################################################
/*                                                                                      
                _____________________________________Screen_Elki___                                                                       
               |   A                             A                 |                   
               |<--+--------------- 240 ---------+---------------->|                   
               |   |                             |                 |                   
               |   |                             |                 |                    
               |   |                             | x               |                    
               |   |                             |                 |                    
               |   |                             |                 |                    
               |   |                             |                 |                    
               |   |                             |                 |                    
               |   |         ,-+-----------------+-----------------+------,             
               |   |         | |                 |        IMGHDR * onse   |             
               |   |         | yRect             |                 `      |             
               |   |         | |                 |                 `      |             
               |   |         | V_____<-- xxRect -V----------> ____ `      |             
               |  296        |       [[[[[[[[[[[[[[[[[[[[[[[[    A `      |             
               |(а жаль)     |       [[[[[[[[[[[[[[[[[[[[[[[[    | `      |             
               |   |      onse->h    [[[[[[[[[[[[[[[[[[[[[[[[    | `      |             
               |   |         |       [[Выводимый прямоугольн[    | `      |             
               |   |         |       [[[[[[[[[[ВОП[[[[[[[[[[[ yyRect      |             
               |   |         |<----->[[[[[[[[[[[[[[[[[[[[[[[[    | `      |             
               |   |   y     | xRect [[[[[[[[[[[[[[[[[[[[[[[[    | `      |             
               |<--+---------+------>[[[[[[[[[[[[[[[[[[[[[[[[____V `      |             
               |   |         |                                     `      |             
               |   |         '---------------- onse->w ------------+------'             
               |   |                                               |                    
               |   |                                               |                    
               |   |                                               |                    
               |   |                                               |                    
               |   |                                               |                    
               |   |                                               |                    
               |___V_______________________________________________|                                                                      
*/


//################################################################################ D R A W I M G B L A C K #################################################
/*int drawimblack(IMGHDR * onse, int x, int y, int xRect, int yRect,int xxRect, int yyRect, int sColor){ //последние параметры - рисуемая область из картинки
if (!onse) return 1;
//--------------------------------------------------------------------------------------------------------------------------------------------  
if (yRect<0 || yRect>=onse->h)yRect=0;  if (xRect<0 || xRect>=onse->w)xRect=0;  // область в картинке не должна начинаться за ней:)
if (yyRect==0 || (yRect+yyRect>=onse->h))yyRect=onse->h-yRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
if (xxRect==0 || (xRect+xxRect>=onse->w))xxRect=onse->w-xRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
short *scr=(short*)screen, *pic=(short*)((char*)onse->bitmap);
int i,j;

for (i = xRect; i<xRect+xxRect; i++)for(j = yRect; j<yRect+yyRect; j++){ //i в диапазоне области ВОП рисунка (от xRect до xRect+xxRect)
                                                                         //j в диапазоне области ВОП рисунка (от yRect до yRect+yyRect)
if (((y+j-yRect)<320) && ((x+i-xRect)<240) && ((y+j-yRect)>=0) && ((x+i-xRect)>=0) 
    &&(i>=xRect)&&(j>=yRect)&&(i<xRect+xxRect)&&(j<yRect+yyRect)&&(pic[(j)*onse->w+i]==0))
 {
   
 if (pic[(j)*onse->w+i]!=0)  scr[(y+j-yRect)*240+i+x-xRect]=pic[(j)*onse->w+i];
 else scr[(y+j-yRect)*240+i+x-xRect]=sColor;
 }}
 return 0;
}*/
//wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

int drawimblack(IMGHDR * onse, int x, int y, int xRect, int yRect,int xxRect, int yyRect, int sColor){ //последние параметры - рисуемая область из картинки
if (!onse) return 1;
//--------------------------------------------------------------------------------------------------------------------------------------------  
if (yRect<0 || yRect>=onse->h)yRect=0;  if (xRect<0 || xRect>=onse->w)xRect=0;  // область в картинке не должна начинаться за ней:)
if (yyRect==0 || (yRect+yyRect>=onse->h))yyRect=onse->h-yRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
if (xxRect==0 || (xRect+xxRect>=onse->w))xxRect=onse->w-xRect; //eсли размер области нулевой или вылазит за картинку, то берем до конца картинки 
short *pic=(short*)((char*)onse->bitmap);
int i,j,nsize;
//sprintf(logger,"Размер картинки: %i*%i,Tran:%i=%i\nРазмер экрана: %i",onse->h,onse->w, pic[0],  onse->h*onse->w*bits,screensize);
//-----------------------------------------------
scrtype *sc=0;
IMGHDR FI[12]={xxRect,yyRect,8,0,0,0};
FI->w=xxRect;
FI->h=yyRect;
FI->bpnum=8;
FI->bitmap=(char *)(sc=(scrtype*)malloc(nsize=xxRect*yyRect*sizeof(scrtype)));
  
  memset(sc,0,nsize);
short *scr=(short*)((char*)FI->bitmap); 
for (i = xRect; i<xRect+xxRect; i++) for(j = yRect; j<yRect+yyRect; j++){
if (((y+j-yRect)<320) && ((x+i-xRect)<240) && ((y+j-yRect)>=0) && ((x+i-xRect)>=0) 
    &&(i>=xRect)&&(j>=yRect)&&(i<xRect+xxRect)&&(j<yRect+yyRect)&&(pic[(j)*onse->w+i]==0))
scr[j*xxRect+i]=sColor;
else {scr[j*xxRect+i]=pic[(j)*onse->w+i];}


}
  RECT rc2;  DRWOBJ dobj; StoreXYWHtoRECT(&rc2,x,y,xxRect,yyRect);
  SetPropTo_Obj5(&dobj,&rc2,0,(IMGHDR*)&FI);
  DrawObject(&dobj);  
//DrawImg(y,x,(int)FI);
if(sc) mfree(sc);
 return 0;}
//wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww



//wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
//wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
#ifdef INPUT_OK
char *input(char *text, char *BoxTitle){
strcpy (Text_in_Editor, text);
//HEADER_DESC input_hdr={0,0,0,0,NULL,(int)BoxTitle,LGP_NULL};
 // CreateInput();
return Text_out_Editor;
} //Для балета нужно комментировать :(
#endif




int x_str(char *text, int font){
  int i=0, cas=0;
  while(text[i]){
cas+=x_char (text[i], font);
   ++i;
  }
  return  cas;
}

char *hex(char r){
  char *temp="  ";
int y;
y=r;
if (y==0) return "00";
temp[0]= '0';
if (y>15){temp[0]= '1'; y-=16;}
if (y>15){temp[0]= '2'; y-=16;}
if (y>15){temp[0]= '3'; y-=16;}
if (y>15){temp[0]= '4'; y-=16;}
if (y>15){temp[0]= '5'; y-=16;}
if (y>15){temp[0]= '6'; y-=16;}
if (y>15){temp[0]= '7'; y-=16;}
if (y>15){temp[0]= '8'; y-=16;}
if (y>15){temp[0]= '9'; y-=16;}
if (y>15){temp[0]= 'a'; y-=16;}
if (y>15){temp[0]= 'b'; y-=16;}
if (y>15){temp[0]= 'c'; y-=16;}
if (y>15){temp[0]= 'd'; y-=16;}
if (y>15){temp[0]= 'e'; y-=16;}
if (y>15){temp[0]= 'f'; y-=16;}

temp[1]= '0';
if (y==1){temp[1]= '1';}
if (y==2){temp[1]= '2';}
if (y==3){temp[1]= '3';}
if (y==4){temp[1]= '4';}
if (y==5){temp[1]= '5';}
if (y==6){temp[1]= '6';}
if (y==7){temp[1]= '7';}
if (y==8){temp[1]= '8';}
if (y==9){temp[1]= '9';}
if (y==10){temp[1]= 'a';}
if (y==11){temp[1]= 'b';}
if (y==12){temp[1]= 'c';}
if (y==13){temp[1]= 'd';}
if (y==14){temp[1]= 'e';}
if (y==15){temp[1]= 'f';}
return temp;
}

void hexer(const char *bufw){

    char *out; 
    out = malloc((lenta*4)+21);
    sprintf(out,"char *resstr = \x22");
    for (int i=0; i<lenta; i++){
    //
    sprintf(out,"%s\\x%s",out, hex(bufw[i]));
    }
     sprintf(out,"%s\x22\x3b ",out);   
    
    savefile("4:\\output.c", out, strlen(out));
        if (out) mfree(out);
}
#endif







//wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww


/*
DrwImg3(IMGHDR *img, int x, int y, char *pen, char *brush)
{
  RECT rc;
  DRWOBJ drwobj;
  StoreXYWHtoRECT(&rc,x,y,img->w,img->h);
  SetPropTo_Obj5(&drwobj,&rc,0,img);
  SetColor(&drwobj,pen,brush);
  DrawObject(&drwobj);
}


IMGHDR * ScreenShot()
{   
  LockSched();
  short *p=malloc((SCREENSIZE-HSIZE)*sizeof(short)), *pp=RamScreenBuffer(); 
  pp+=HSIZE; 
  IMGHDR imgs={ScreenW(),(ScreenH()-YDISP),8,(char *)p};
  for(int i=0;i<SCREENSIZE-HSIZE;i++)*p++=*pp++; 
  return &imgs;

}


void ScreenShotPlay(IMGHDR  * imgs)
{
  void *canvasdata=BuildCanvas();
  DrawCanvas(canvasdata, 0, 0, ScreenW()-1,ScreenH()-1, 1 );
  DrwImg3(imgs, 0, YDISP, GetPaletteAdrByColorIndex(0),GetPaletteAdrByColorIndex(2)); 
  UnlockSched();
}
)*/