Ethernet Программатор ПЗУ / Ethernet-based EEPROM programmer

/*
 *
 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 * NEVER USE NAME 'send' FOR ANYTHING !
 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 *

============================================================================
 Name : ethprog.c
 Author : jopka 2011-2013
 Version : beta
 Copyright : GPL v.2+
 Description : Ethernet SPI / I2C programmer via OSCaR module

============================================================================
 */

typedef unsigned char byte;
typedef unsigned short word;
#define NOT !
//typedef unsigned char[1024] string; - not work!
//#define string byte[1024]

#define debug 0
// #define <> !=

#define gtkgui 1

#include <stdlib.h>
#include <gtk-2.0/gtk/gtk.h> // /gtk.h>
#include <stdio.h> /* Standard input/output definitions */
#include <fcntl.h> /* File control definitions */
//#include <errno.h> /* Error number definitions */
//#include <termios.h> /* POSIX terminal control definitions */
//#include <gnome.h>
#include <string.h>
#include <cairo.h>
#include <sys/time.h>
#include <sys/stat.h> //file_exists

#include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
#include <arpa/inet.h> /* for sockaddr_in and inet_addr() */

#include <signal.h>
#include <sys/time.h>

#include <cairo.h>

#include <libconfig.h>

#define chipqty 2

#define inifile "ethprog.ini"
int inierr;
GtkWidget * entry_ip;
GtkWidget * entry_filename;
GtkWidget * spin_port;

const char * oscar_ip_readonly; // due to libconfig nature
char oscar_ip_readwrite[256]; // due to libconfig nature

// not work when i switch to 64-bit
//long long oscar_port;
// so i change it to something that work
long oscar_port;
#define not !

int dev_is_connected;

GtkWidget *window;
//GtkWindow *window;
GtkWidget *main_vbox;
//GtkWidget *status_bar;
GtkWidget *status_bar_label;

//GtkWidget *button;

GtkWidget *textview;
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextMark *insert_mark;
GtkWidget *scrollview;

GtkWidget *lbl[chipqty+2][20];  // labels
GtkWidget *btn[chipqty+2][10];  // pushbuttons
//GtkWidget *rb[chipqty+2][10]; // radio buttons
GtkWidget *cbt[chipqty+2][10];  // checkbuttons
GtkWidget *hb;          // hbox
GtkWidget *vbfile;              // vboxes
GtkWidget *vbcontrol;
GtkWidget *vbchip[chipqty];
GtkWidget *vbromlist[chipqty];

GtkWidget *vbx;

GtkWidget *dr[chipqty+2]; //gtk.DrawingArea

//GdkPixbuf *pb[chipqty+2]; // http://openbooks.sourceforge.net/books/wga/graphics-gdk-pixbuf.html

GdkCursor* cursor;

cairo_t *cr;

int i;
//int fd; // f - file, fd - port
FILE *f;
int xpos;
int read_value;

//char portname[1024];
char s[1024*1024],s1[1024*1024],s2[1024*1024],ss[1024*1024];

#define maxsize 256*2048 *16

//byte a[maxsize], a2[maxsize];

byte outbuf[maxsize];
byte inbuf[maxsize];
byte a[maxsize], a2[maxsize];

unsigned short device_port;
char *device_ipaddr;
int sock;
//struct sockaddr_in device_sock;
struct sockaddr_in devaddr;
unsigned short devport;
char devipaddr[256];
int rcvd;
int eep_daughbrd_type;
byte eep_socket[10];

int valid_crc;

int i,ii,iii,j;
char filename[1024];
byte fexist;
unsigned int crc[4];
word sum[4];
byte readfilemode;
byte stop;
byte automode;
int dx, dy;
// int once;
int state;

int eeprom_ready;
int fileread_ready;

// least of file/data size and eeprom size
// (largest common part between two sizes)
int active_size, max_size;

config_t cfg;
config_setting_t *setting;
config_setting_t *root;

// make sure all values set to correct defaults before first run.
int ini_settings_update(void) {
    config_init(&cfg);
    root = config_root_setting(&cfg);
// Add some settings to the configuration.
    setting = config_setting_add(root, "ip", CONFIG_TYPE_STRING);
    config_setting_set_string(setting, oscar_ip_readwrite);
    setting = config_setting_add(root, "port", CONFIG_TYPE_INT);
    config_setting_set_int(setting, oscar_port);

// Write out the new configuration.
    if(! config_write_file(&cfg, inifile))
    {
        fprintf(stderr, "Error while writing config file.\n");
        config_destroy(&cfg);
        return(EXIT_FAILURE);
    }
    return(EXIT_SUCCESS);
}

/*
 * tx size: 8 bytes = control, other than 8 (1..7, 9..many) data to write.
 *
 * rx answer always 256(512?) NO! new SPI uses random sizes like 264.
 * rx byte #0 = ACK when write. (or all bytes = ACKs) (for i2c only)
 *
 * get ID and start TWI hardware in atmega
 * send 8 bytes 55 aa 00 ff 00 00 00 00
 * rcv ~38 bytes ff 00 aa 55 xx xx xx yy 'z.t.string' 00, xx's - capabilites
 * yy = daughterboard type (sockets available: spi, twi, etc), see w5100uni.asm
 *
 * set GPIO ctrl (static pins, power, LEDs etc.)
 * send 8 bytes 55 aa 00 ff 00 00 01 ww ww - byte for write
 * rcv 1 byte 01
 * OR
 * rcv 256 bytes rd xx xx.... rd - read sensors (reserved for future)
 *
 * TWI: set START/STOP cond. and set R/W for i2c, set /SS on/off for SPI
 * send 8 bytes 55 aa 00 ff 00 00 02 a6 (lsb=0) START, then write a6, then switch to writing mode
 * 02 a7 (lsb=1) START, then write a7, then switch to read mode
 * 03 00 STOP
 * 03 01 STOP and stop TWI hardware in atmega
 * rcv 1 byte ACK
 *
 * SPI: set /SS on/off
 * send 8 bytes 55 aa 00 ff 00 00 04 xx /SS ON, then write 'xx' byte
 * 55 aa 00 ff 00 00 05 00 /SS OFF
 * rcv 1 byte ?
 *
 *
 *
 * read bytes
 * send 8 bytes 55 aa 00 ff 00 01 rr rr rrrr - q'ty of read bytes (1-1514)
 * rcv rrrr bytes
 *
 *
 * read/write operation - depends on write mode (i2c) or always r/w for SPI because need to write any byte for read byte
 * send 1..7, 9..many bytes dd dd dd (data for write, don't care for read but q'ty important)
 * rcv many bytes xx xx xx.... (xx = read data)
 * rcv many bytes aa aa aa..... (aa = ACK answer)
 *
 */

float r;
word w;
byte b;
unsigned int filesizereal, filesizealigned;

word rom_autodetect_type;

struct romdesc
{
    char name[32];
    byte mode;
    unsigned int bsize;
    unsigned int blocks; // named 'pages' or 'blocks' in different datasheets
    unsigned int pagespersector;
    byte iface_type;

};

byte romtype;       //number 1-8,
//or 0 = found but not known,
// 255 = not found any chip
#define romq 9
#define TWI 1
#define SPI 2

// bsize (page size) currently required to be less than max pkt size (1514 bytes)
const struct romdesc romparams[romq+1] = {
// name, mode, page size, pages total, pages per sector, type
// 'pages in sector' probably used if device sector-erasable but not page-erasable,
// if >0, then each new sector per this q'ty of pages, must erased first.
// if =0, each page will be auto-erased by chip (we hope).
        {"Unknown",              2,  64,  128,  0,  TWI},
        {"at17c/lv65(a) 8kb",    2,  64,  128,  0,  TWI},
        {"at17c/lv128(a) 16kb",  2,  64,  256,  0,  TWI},
        {"at17c/lv256(a) 32kb",  2,  64,  512,  0,  TWI},
        {"at17c/lv512(a) 64kb",  3, 128,  512,  0,  TWI},
        {"at17c/lv010(a) 128kb", 3, 128, 1024,  0,  TWI},
        {"at17c/lv002(a) 256kb", 3, 256, 1024,  0,  TWI},
        {"at17c/lv040 512kb",    3, 256, 2048,  0,  TWI},
        {"SPI at45db021d 264kb", 4, 264, 1024,  0,  SPI},
// {"SPI EN25F16 2MB", 4, 256, 8192, 16} -- correct
        {"SPI EN25F16 lim 0,5MB",      4, 256, 2048, 16,  SPI} // define smaller size for fast work
// {"SPI at45db021d 264kb", 4, 264, 2}
};

const int max_header_offset=200; // not fixed!!!!!!! typical 72...73

const unsigned int CRCPOLY=0xEDB88320;
unsigned int CRCTable[256];

//byte speed;
//#define readblocksize 512 //set in fpga project; agjust timeouts when change.

//struct sigaction sa; struct itimerval timer; // its work.

void chksum_crc32gentab ()              // taken somewhere from internet...
{
    unsigned long crc, poly;
    int i, j;

    poly = 0xEDB88320L;
    for (i = 0; i < 256; i++)
    {
        crc = i;
        for (j = 8; j > 0; j--)
        {
            if (crc & 1)
            {
                crc = (crc >> 1) ^ poly;
            }
            else
            {
                crc >>= 1;
            }
        }
        CRCTable[i] = crc;
    }
}

unsigned int RecountCRC(byte b, unsigned int CrcOld) {
    return ((CrcOld >> 8) & 0x00FFFFFF) ^ CRCTable[(CrcOld ^ b) & 0xFF];
}

void memolinesadd(char ss[1000])
{
    gtk_text_buffer_get_end_iter(buffer, &iter);
    gtk_text_buffer_insert(buffer, &iter, ss, -1);
    gtk_text_buffer_get_end_iter(buffer, &iter); //again
    insert_mark = gtk_text_buffer_get_insert (buffer);
    gtk_text_buffer_place_cursor(buffer, &iter);
    gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW (textview),
            insert_mark, 0.0, TRUE, 0.0, 1.0);
}

void ApplicationProcessMessages(void) {
    if (state == 0) {
        // nothing
    } else {
        while (gtk_events_pending ()) gtk_main_iteration ();
    }
}

/* Redraw the screen from the backing pixmap */
static gboolean expose_event( GtkWidget *widget, GdkEventExpose *event, int i )
{
    // x0[i]=event->area.x;
    // y0[i]=event->area.y;
    dx=event->area.width;
    if (dx<256) dx=256; // workaround against wrong size reported bug
    dy=event->area.height;
    if (dy<256) dy=256; // workaround against wrong size reported bug
    // if (dy==257) {dy=256;} //workaround for wrong size reporting bug...

    if (stop==0) {
        sprintf(s,"i=%d dx=%d dy=%d\n",i,dx,dy);
        memolinesadd(s);
        cr = gdk_cairo_create(widget->window);

        // cairo_rectangle (cr, x0[i], y0[i], dx, dy);
        cairo_rectangle (cr, 0, 0, dx, dy);

// cairo_set_source_rgb (cr, 0, 0, 0);
// inverted due to full OS color invert via Compiz Neg plugin.
        cairo_set_source_rgb (cr, 1, 1, 1);
        cairo_fill (cr);

        /* cairo_rectangle (cr, x0[i], y0[i], 1, 1);
 cairo_set_source_rgb (cr, 1, 1, 0);
 cairo_fill (cr);

 cairo_rectangle (cr, x0[i]+255, y0[i]+255, 1, 1);*/
        // cairo_set_source_rgb (cr, 1, 1, 0);
        cairo_fill (cr);

        cairo_destroy(cr);
    } else {
        printf("Stopped!"); //trying to catch - seems to never work...
    }

    return FALSE;
}

void exitapp(void) {
    // if (cr!=NULL) cairo_destroy(cr);
    // stop=1;
    gtk_main_quit();
}

void msg1(char s[1024]) {
    gtk_label_set_text(GTK_LABEL(lbl[2][1]), s);
}

void uncheckall(void) {
    for (i=0; i<romq; i++) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbt[2][i]),0);
    }
}

void _check(int i) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbt[2][i]),1);
}

void setrom(void) { //here rom = current ROM
    switch (romtype) {
    case 255:
        msg1("No chip / wrong pinout.");
        uncheckall();
        break;
        // case 254:
        // msg1("Wrong chip orientation.");
        // uncheckall();
        // break;
    case 0:
        sprintf(s,"Found unknown: %d, select manually:",rom_autodetect_type);
        msg1(s);
        uncheckall();
        break;
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
case 9:
        msg1("Found known device.");
        uncheckall();
        _check(romtype-1);
        if ( ! ((romtype==4)|(romtype==5)|(romtype==6))) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbt[1][3]),0);
            // not work? gtk_widget_set_sensitive(cbt[1][3],0); // enabled:=false;
        }
        break;
    }
}

int dtx, drx;

/*
 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 * NEVER USE NAME send FOR ANYTHING
 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 */
void send_rcv (word qty) { // assume same size packet always send/rcv
    int q;
    char s[1024*1024];
// int rcvd;

    // unsigned char b[4], bb[4]; //byte

    if (debug)
    {
        sprintf(s,"(%d) %d byte(s) send: ",dtx, qty);
        for(q=0; q<qty; q++) {
            // sprintf(s,"%s%02x ",s,outbuf[q]);
            if (q<16) sprintf(s,"%s%02x ",s,outbuf[q]);
            if (q==16)  sprintf(s,"%s...",s);
        }
        printf("%s\n",s);
    }
    dtx=dtx+qty;

    if (send(sock, outbuf, qty, 0) != qty)
        printf("send() sent a different number of bytes than expected\n");

    rcvd = 0;
    if ((rcvd = recv(sock, inbuf, sizeof(inbuf), 0)) <= 0)
        printf("recv() failed or connection closed prematurely\n");

    // if (rcvd==rcvcount) {
    if (debug)
    {
        sprintf(s,"%d byte(s) receive: ",rcvd);
        for(q=0; q<rcvd; q++) {
            if (q<16) sprintf(s,"%s%02x ",s,inbuf[q]);
            if (q==16)  sprintf(s,"%s...",s);
        }
        printf("%s\n",s);
    }

    /* } else {
 printf("recv() get a different number of bytes than expected");
 }*/

}

// send 8 ctrl bytes 55 aa 00 ff 00 00 00 xx
void txctrl(char b1, char b2) {
    outbuf[0]=0x55;
    outbuf[1]=0xaa;
    outbuf[2]=0x00;
    outbuf[3]=0xff;
    outbuf[4]=0x00;
    outbuf[5]=0x00;
    outbuf[6]=b1;
    outbuf[7]=b2;
    send_rcv(8);
}

void rxdata(word qty) {
    outbuf[0]=0x55;
    outbuf[1]=0xaa;
    outbuf[2]=0x00;
    outbuf[3]=0xff;
    outbuf[4]=0x00;
    outbuf[5]=0x01;
    outbuf[6]=(qty) & 0xff;
    outbuf[7]=(qty >> 8) & 0xff;
    send_rcv(8);
}

void txdata(word qty) {
    send_rcv(qty);
}

/*

 void pgmgetid() {
 txctrl(0,0);
}*/

void dev_getid(void) {
    txctrl(0,0);
}

/* OLD 0=OE 1=CE 2=CEO 3=SER_EN
 * 4=pwr_ON 5-not used 6=LED0 7=LED1
 */

// now currently OE, CE, CEO, SER_EN not controlled and must be tied down in uC,
// but user may to write additional func in uC to handle it.
#define LED0 2 // green
#define LED1 1 // red
#define PWR_ON 0
#define not_used 4
#define PWR_OFF 8

void pgmsetmode(char b) { // set GPIO
    txctrl(1,b);
}

void pgmsendstartsetaddrtwi(char addr) {
    txctrl(2,addr);
}

void pgmsendstoptwi() {
    txctrl(3,0);
}

void pgmsendstoptwiofftwi() {
    txctrl(3,1);
}

void pgmsendstartsetaddrspi(char addr) {
    txctrl(4,addr);
}

void pgmsendstopspi() {
    txctrl(5,0);
}

/*void pgmsendSPIcmd(char b) {
 txctrl(4,b);
}*/

void iface_set(byte u) {
    if (u==1) {
        gdk_window_set_cursor(gtk_widget_get_window(window), NULL);
    }
    if (u==0) {
        cursor = gdk_cursor_new(GDK_WATCH);
        gdk_window_set_cursor(gtk_widget_get_window(window), cursor);
        gdk_cursor_destroy(cursor);
    }
    gtk_widget_set_sensitive(vbx,u);
    gtk_widget_set_sensitive(vbcontrol,u);
}

void iface_busy() {
    iface_set(0);
}

void iface_ready() {
    iface_set(1);
}

int file_exists (char * _fileName)
{
    struct stat buf;
    int i = stat ( _fileName, &buf );
    /* File found */
    if ( i == 0 )
    {
        return 1;
    }
    return 0;
}

void printcrc (int crc, int sum, int activesize, byte m, byte n) {
// sprintf(s,"Sz:<b>%d</b> CRC:<b>%08x</b> Sum:<b>%04x</b>", activesize, crc, sum);
    sprintf(s,"<b>%d</b>b %08x <b>%04x</b>", activesize, crc, sum);
    gtk_label_set_markup (GTK_LABEL (lbl[m][n]), s);
}

/*void drwpixel(float rr, float gg, float bb, byte bt, word x, word y, int n) {
// int c;
// c=0;
// cr = gdk_cairo_create(window->window);
 cr = gdk_cairo_create(dr[n]->window);
 cairo_rectangle (cr, x, y, 1, 1);
 cairo_set_source_rgb (cr, rr*bt/255.0, gg*bt/255.0, bb*bt/255.0);
 cairo_fill (cr);
 cairo_destroy(cr);
}*/

// http://stackoverflow.com/questions/7941215/gtkmm-drawing-single-pixels
/*static void
put_pixel (GdkPixbuf *pixbuf, int x, int y, guchar red, guchar green, guchar blue, guchar alpha)
{
 int width, height, rowstride, n_channels;
 guchar *pixels, *p;

 n_channels = gdk_pixbuf_get_n_channels (pixbuf);

 g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
 g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
 g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
 g_assert (n_channels == 4);

 width = gdk_pixbuf_get_width (pixbuf);
 height = gdk_pixbuf_get_height (pixbuf);

 g_assert (x >= 0 && x < width);
 g_assert (y >= 0 && y < height);

 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
 pixels = gdk_pixbuf_get_pixels (pixbuf);

 p = pixels + y * rowstride + x * n_channels;
 p[0] = red;
 p[1] = green;
 p[2] = blue;
 p[3] = alpha;
}
*/

void drwpixel2(double rr, double gg, double bb, byte bt, int bytenum, int totalbytes) {
    float zoomfactor;
    float a;
    int aa;
    int x,y;
    int px_sz;

// zoomfactor=dx*dy/totalbytes;
    zoomfactor=(float)dx*(float)dy/totalbytes;

    px_sz=1;

    if (zoomfactor>4)  {
        zoomfactor=zoomfactor/4;
        px_sz=2;
    }

    if (zoomfactor>1) zoomfactor=1;

    a=bytenum*zoomfactor;
    aa=a;
    x=aa % (dx/px_sz);
    y = aa / (dx/px_sz);

// if ((x%2==0)&(y%2==0)) {
    {
// cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
        cairo_rectangle (cr, x*px_sz+0.0, y*px_sz+0.0, 1*px_sz+0.0, 1*px_sz+0.0);
        // cairo_set_source_rgb (cr, 0, 0, bb*bt/255.0);
// cairo_set_source_rgb (cr, rr*bt/255.0, gg*bt/255.0, bb*bt/255.0);

// inverted due to full OS color invert via Compiz Neg plugin.
// cairo_set_source_rgb (cr, 1.0-(rr)*bt/255.0, 1.0-(gg)*bt/255.0, 1.0-(bb)*bt/255.0);
        cairo_set_source_rgb (cr, 1.0-(1.0-rr)*bt/255.0, 1.0-(1.0-gg)*bt/255.0, 1.0-(1.0-bb)*bt/255.0);
// cairo_set_source_rgb (cr, (1.0-rr)*bt/255.0, (1.0-gg)*bt/255.0, (1.0-bb)*bt/255.0);
// cairo_set_source_rgb (cr, rr*bt/255.0, gg*bt/255.0, bb*bt/255.0);
// cairo_set_source_rgb (cr, (rr)*(255-bt)/255.0, (gg)*(255-bt)/255.0, (bb)*(255-bt)/255.0);
        cairo_fill (cr);
    }

    /* SLOW
cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 cairo_set_source_rgb (cr, rr*bt/255.0, gg*bt/255.0, bb*bt/255.0);
 cairo_set_line_width (cr, 1.0);
// cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
 cairo_move_to (cr, x+0.5, y+0.5);
 cairo_line_to (cr, x+1.5, y+0.5);
 cairo_stroke (cr);*/
}

// Returns the floor form of binary logarithm for a 32 bit integer.
// −1 is returned if ''n'' is 0.
int floorLog2(unsigned int n) {
    if (n == 0)
        return -1;

    int pos = 0;
    if (n >= 1<<16) { n >>= 16; pos += 16; }
    if (n >= 1<< 8) { n >>=  8; pos +=  8; }
    if (n >= 1<< 4) { n >>=  4; pos +=  4; }
    if (n >= 1<< 2) { n >>=  2; pos +=  2; }
    if (n >= 1<< 1) {           pos +=  1; }
    return pos;
}

void readstr() {
// strcpy(s,"------------------------------");
    strcpy(s,"-----------------------------------------------------------");
    i=0;
    fread(&b,1,1,f);
    fread(&b,1,1,f);
    fread(&b,1,1,f);
    if (b>2) {
        s[b-1]='\0';
    }
printf("*%s*\n",s);

    do {
        fread(&b,1,1,f);
        if (b>0) s[i]=b;
        i++;
//} while ((b>0)&(i<=30)); - changed 03/18/2014
    } while ((b>0)&(i<=50));
    strcat(s,"\n");
printf("#%s#\n",s);
}

void readfile () {
    int i;
    unsigned int za;
    char fname[1024];

    printcrc(0, 0, active_size, 0, 5);
    printcrc(0, 0, max_size, 0, 6);
    ApplicationProcessMessages();
    fileread_ready = FALSE;

    strcpy(fname, gtk_entry_get_text(GTK_ENTRY(entry_filename)));

    fexist = file_exists(fname);
    gtk_text_buffer_set_text (buffer, "", -1);

    memset (&a2, 0, sizeof (a2));
    if (fexist==1) {
        f = fopen(fname, "rb");
        if (!f)
        {
            printf("Unable to open file!");
            memolinesadd("Unable to open file!");
            exit(EXIT_FAILURE);
            // return 1;
        }
        fileread_ready = TRUE;

        fseek(f,0,SEEK_END);    //eof
        filesizereal=ftell (f);
        fseek(f,0,SEEK_SET);        //start of file
        strcpy(s1,"");
        fseek(f,13,SEEK_SET);
        readstr();
        strcat(s1,s);
        readstr();
        strcat(s1,s);
        readstr();
        strcat(s1,s);
        readstr();
        strcat(s1,s);
        fread(&b,1,1,f);
        fread(&b,1,1,f); //hi byte
        fread(&b,1,1,f); za=b*65536;
        fread(&b,1,1,f); za=za+b*256;
        fread(&b,1,1,f); za=za+b; //lo byte

        //printf("%d-%d-%d\n",filesizereal, fseek(f,0,SEEK_CUR), za);
        //printf("%d-%d-%d\n",filesizereal, ftell(f), za);
        //return 1;

        if ((filesizereal-ftell(f))==za)
            readfilemode=1;
        else
            readfilemode=0;

        if (readfilemode==1) {
            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbt[0][0]),1);
            sprintf(s,"%d bytes overall\n",filesizereal);
            filesizereal=za;                // not real size, but bytes to read
// memolinesadd(s);
            memolinesadd(s1); // ?
        } else {
            sprintf(s,"Raw bytes mode\n");
            memolinesadd(s);
            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbt[0][0]),0);
            fseek(f,0,SEEK_SET);
        }
        sprintf(s,"%d bytes data\n",filesizereal);
        if (active_size == 0) {  // not initialized yet
            active_size = filesizereal;
        } else {  // already exist - so correct only if need
// that not work when re-read larger file... =(
// if (active_size>filesizereal) { active_size = filesizereal; }
// so try brute force workaround...
            active_size = filesizereal;
        }
        memolinesadd(s);
        fread(&a2,filesizereal,1,f);
        fclose(f);

        filesizealigned=1<<(floorLog2(filesizereal-1)+1);
        sprintf(s,"%d bytes to 2^n\n",filesizealigned);
        if (max_size<filesizealigned) { max_size = filesizealigned; }
        memolinesadd(s);

        //for(i=1; i<100; i++) { printf("%d %d\n",i,floorLog2(i)); }

        sum[0]=0;
        sum[1]=0;
        crc[0]=0xffffffff;
        crc[1]=0xffffffff;
        cr = gdk_cairo_create(dr[0]->window);
// for (i=0; i<(filesizereal); i++) {
        for (i=0; i<(max_size); i++) {
            if (i<filesizereal) {
                sum[0] = sum[0] + a2[i];
                crc[0] = RecountCRC(a2[i],crc[0]);
                sum[1] = sum[0];
                crc[1] = crc[0];

                b=a2[i] / 2 + a2[i] / 4 + 64; //+ a2[n] / 8 + 32;
                drwpixel2(0,0,0,b,i,filesizealigned);
            } else {
                crc[1] = RecountCRC(0, crc[1]);
            }
        }
        cairo_destroy(cr);
        crc[0] = crc[0] ^ 0xffffffff;
        crc[1] = crc[1] ^ 0xffffffff;
        printcrc(crc[0], sum[0], active_size, 0, 5);
        printcrc(crc[1], sum[1], max_size, 0, 6);
    } else {
        memolinesadd("File not exist yet.");
        automode=0;
        // z=0;
        ////// gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbt[1][1]),1);
        ////// gtk_widget_set_sensitive(cbt[1][1],0);
    }
}

void wrt_adr(int adr) {
    if ((romparams[romtype].mode==3)) {        // three address bytes
        outbuf[0]=(adr >> 16) & 0xff;
        outbuf[1]=(adr >> 8) & 0xff;
        outbuf[2]=(adr) & 0xff;
        // send_rcv(3);
        txdata(3);
    } else {
        outbuf[0]=(adr >> 8) & 0xff;
        outbuf[1]=(adr) & 0xff;
        // send_rcv(2);
        txdata(2);
    }
}

void wrt_adr_at45(int pagenum, int bytenum) {
        outbuf[0]=(pagenum >> 7) & 0xff;
        outbuf[1]=((pagenum * 2) & 0xff) + ((bytenum >> 8) & 0xff);
        outbuf[2]=(bytenum) & 0xff;
        txdata(3);
}

void wrt_adr_en25(int adr) {
// same as wrt_adr...
    outbuf[0]=(adr >> 16) & 0xff;
    outbuf[1]=(adr >> 8) & 0xff;
    outbuf[2]=(adr) & 0xff;
        txdata(3);
}

void wrt_dummybytes_at45(int qty) {
    int i;
    if (qty==8) {
        printf("Qty 8 not allowed due to its become command, not bytes!\n");
        exit(EXIT_FAILURE);
    }
    for (i=0; i<qty; i++){
        outbuf[i]=0; // dymmy bytes
    }
    txdata(qty);
}

void ReadChipToArrayanddraw (void)  { //into 'a' array
    int i, j, n, _size;
    if (romtype==255) return;
    if (NOT (dev_is_connected)) return;
    if (NOT (eeprom_ready)) return;

    iface_busy();
    pgmsetmode(PWR_OFF);
    usleep(50000);
    pgmsetmode(PWR_ON + LED0 + LED1);
    usleep(50000);

    if (romparams[romtype].iface_type==SPI) {
        if (romtype==8) { // at45db021
            // read status: here only for test
                pgmsendstartsetaddrspi(0xd7); // Status Register Read (Opcode: 57H / d7h)
                wrt_dummybytes_at45(1); // this reads-in statys byte
            printf(" * * * Status read: %d\n",inbuf[0]);
                pgmsendstopspi();
                usleep(1000);
                pgmsendstartsetaddrspi(0xe8); // Continuous Array Read (Opcode: 68H / e8h)
                wrt_adr_at45(0,0); // write 3 byte address + 4 dymmy bytes, so prepared to ready main bytes
                wrt_dummybytes_at45(4);
        }
        if (romtype==9) { // en25f16
    // pgmsendstartsetaddr(0x05); // Read Status Register (RDSR) (05h)
                pgmsendstartsetaddrspi(0x9f); // Read Identification
                wrt_dummybytes_at45(1);
                printf(" EN25 read id must be 28: %d\n", inbuf[0]);
                wrt_dummybytes_at45(1);
                printf(" EN25 read id must be 49: %d\n", inbuf[0]);
                wrt_dummybytes_at45(1);
                printf(" EN25 read id must be 21: %d\n", inbuf[0]);
                pgmsendstopspi();
                usleep(1000);
    //return;
                pgmsendstartsetaddrspi(0x03); // Read Data Bytes (READ) (03h)
                wrt_adr_en25(0); // write 3 byte address, so prepared to ready main bytes
    // wrt_dummybytes_at45(4); - no dummy for en25f16
        }
    } else if (romparams[romtype].iface_type==TWI) {
        pgmsendstartsetaddrtwi(0xa6);
        wrt_adr(0);
        pgmsendstartsetaddrtwi(0xa7);
    }

    _size=romparams[romtype].blocks*romparams[romtype].bsize;

    if (active_size == 0) {  // not initialized yet
        active_size = _size;
    } else {  // already exist - so correct only if need
        if (active_size>_size) { active_size = _size; }
    }
    if (max_size<_size) { max_size = _size; }

    printf("Reading: rom=%d, blocks=%d, bsize=%d, size=%d, activesize=%d\n",romtype,romparams[romtype].blocks,romparams[romtype].bsize, _size, active_size);
    crc[2]=0xffffffff;
    crc[3]=0xffffffff;
    sum[2]=0;
    sum[3]=0;

    printcrc(0, 0, active_size, 2, 5);
    printcrc(0, 0, max_size, 2, 6);
    ApplicationProcessMessages();

    for (j=0; j<(_size / romparams[romtype].bsize); j++) {
        for (i=0; i<romparams[romtype].bsize; i++) {outbuf[i]=0; inbuf[i]=0;}
        rxdata(romparams[romtype].bsize);
        cr = gdk_cairo_create(dr[2]->window);
        for (i=0; i<romparams[romtype].bsize; i++) {
            n=j*romparams[romtype].bsize+i;
            a[n]=inbuf[i];
            if (n<active_size) {
                crc[2] = RecountCRC(a[n],crc[2]);
                crc[3] = RecountCRC(a[n],crc[3]);
                sum[2] = sum[2] + a[n];
                sum[3] = sum[3] + a[n];
            } else {
                crc[3] = RecountCRC(a[n],crc[3]);
                sum[3] = sum[3] + a[n];
            }

            b=a[n] / 2 + a[n] / 4 + 64; // + a[n] / 8 + 32;
// try to create bright running area to easy see reading when data not changed,
// but extremely slow.
// drwpixel2(1,1,0,255,n,_size);
            drwpixel2(0,1,0,b,n,_size);

// exit(0); // test

        }
    }
    cairo_destroy(cr);

    // pgmsendstop();

    if (romparams[romtype].iface_type==SPI) {
        pgmsendstopspi();
    } else if (romparams[romtype].iface_type==TWI) {
        pgmsendstoptwiofftwi();
    }
/*
#ifdef SPI
 pgmsendstop();
#else
 pgmsendstoptwioff();
#endif*/

    pgmsetmode(PWR_OFF); //led0-green +led1-red + pwr

    GdkColor bgcolor, fgcolor;

    crc[2] = crc[2] ^ 0xffffffff;
    crc[3] = crc[3] ^ 0xffffffff;
    printcrc(crc[2], sum[2], active_size, 2, 5);
    printcrc(crc[3], sum[3], max_size, 2, 6);

    if (GTK_TOGGLE_BUTTON(cbt[1][1])->active) {
        valid_crc = ((crc[1]==crc[3])&&(sum[1]==sum[3]));
    } else {
        valid_crc = ((crc[0]==crc[2])&&(sum[0]==sum[2]));
    }

    if (valid_crc) {
        gdk_color_parse ("green", &fgcolor);
        gdk_color_parse ("dark green", &bgcolor);
        gtk_widget_modify_fg (GTK_WIDGET(lbl[1][8]), GTK_STATE_NORMAL, &fgcolor);
// http://people.gnome.org/~shaunm/girdoc/C/Gtk.Widget.modify_bg.html
// label bg color not work. =(
        gtk_widget_modify_bg (GTK_WIDGET(lbl[1][8]), GTK_STATE_NORMAL, &bgcolor);
        gtk_widget_modify_bg (GTK_WIDGET(lbl[1][8]), GTK_STATE_SELECTED, &bgcolor);
        gtk_label_set_text(GTK_LABEL(lbl[1][8]), "Identical");
    } else {
        gdk_color_parse ("red", &fgcolor);
        gdk_color_parse ("dark red", &bgcolor);
        gtk_widget_modify_fg (GTK_WIDGET(lbl[1][8]), GTK_STATE_NORMAL, &fgcolor);
        gtk_widget_modify_bg (GTK_WIDGET(lbl[1][8]), GTK_STATE_NORMAL, &bgcolor);
        gtk_label_set_text(GTK_LABEL(lbl[1][8]), "Different");
    }
    iface_ready();
}

#define XOR ^
#define MOD %

void WriteChipFromArrayanddraw () {
    int i, j, n, _size;
    int qb;
    int p;
    int pmin;
    int pmax;
    byte k;
// unsigned int adr;

    void polling (int pollingmax) {
// usleep(5000); //workaround for weak w5100 support for packet flow
        p=0;
        do {
            usleep(100);

            if (romparams[romtype].iface_type==SPI) {
                if (romtype==8) { // at45db021
    // read status
                    pgmsendstartsetaddrspi(0xd7); // Status Register Read (Opcode: 57H / d7h)
                    wrt_dummybytes_at45(1); // this reads-in statys byte
    //printf(" * * * Status read: %d\n",inbuf[0]);
                    k = inbuf[0] & 0b10000000;
                    pgmsendstopspi();
    // usleep(100); // pause before next 'start' (SS->active)
                }

                if (romtype==9) { // en25f16
                    pgmsendstartsetaddrspi(0x05); // Read Status Register (RDSR) (05h)
                    wrt_dummybytes_at45(1); // this reads-in statys byte
                    k = ( (inbuf[0] & 0b00000001) XOR 0b00000001);
                    pgmsendstopspi();
                }
            } else if (romparams[romtype].iface_type==TWI) {
                pgmsendstartsetaddrtwi(0xa6);
                k = inbuf[0] & 1;
            }

            p=p+1;
//printf(" * * * k= %d\n",k);

        } while ( (k==0) && (p<pollingmax) );
        if (p>pmax) pmax=p;
        if (p<pmin) pmin=p;
    } // polling()

    if (not (dev_is_connected)) return;

    if (romtype==255) return;
    if (romtype==0) return;

    iface_busy();
    pmin=9999;
    pmax=0;
    memcpy(a, a2, sizeof(a));
    pgmsetmode(PWR_OFF);
    usleep(50000);
    pgmsetmode(PWR_ON + LED1); //red
    usleep(50000);

    _size=romparams[romtype].blocks*romparams[romtype].bsize; //used for draw
    printf("Writing: rom=%d, blocks=%d, bsize=%d, size=%d, mode=%d\n",romtype,romparams[romtype].blocks,romparams[romtype].bsize, _size, romparams[romtype].mode);

    if (GTK_TOGGLE_BUTTON(cbt[1][1])->active) {
// full
        qb=romparams[romtype].blocks;
    } else {
// partially write
        qb=filesizereal / romparams[romtype].bsize;
        if ((filesizereal % romparams[romtype].bsize) >0 ) { qb=qb+1; }
    }

    cr = gdk_cairo_create(dr[2]->window);

    for (j=0; j<qb; j++) {
// while (gtk_events_pending ()) gtk_main_iteration ();
        polling(100);

        if (romparams[romtype].iface_type==SPI) {
            if (romtype==8) { // at45db021
                pgmsendstartsetaddrspi(0x82); // Main Memory Page Program through Buffer
                wrt_adr_at45(j,0);
            }

            if (romtype==9) { // en25f16
    // sector erase here...
                if ((j MOD romparams[romtype].pagespersector)==0) {
                    pgmsendstartsetaddrspi(0x06); // Write Enable (WREN) (06h)
                    pgmsendstopspi(); // deactivate /CS

                    pgmsendstartsetaddrspi(0x20); // Sector Erase (SE) (20h)
                    wrt_adr_en25 (j * romparams[romtype].bsize);
                    pgmsendstopspi(); // deactivate /CS

                    polling(1000);
                }

                pgmsendstartsetaddrspi(0x06); // Write Enable (WREN) (06h)
                pgmsendstopspi(); // deactivate /CS

                pgmsendstartsetaddrspi(0x02); // Page Program (PP) (02h)
                wrt_adr_en25 (j * romparams[romtype].bsize);
            }
        } else if (romparams[romtype].iface_type==TWI) {
            // adr=j*romparams[romtype].bsize;
                    pgmsendstartsetaddrtwi(0xa6);
                    wrt_adr(j*romparams[romtype].bsize);
        }

        for (i=0; i< romparams[romtype].bsize; i++) {
            n=j*romparams[romtype].bsize+i;
            outbuf[i]=a2[n];
            b=a[n] / 2 + a[n] / 4 + 64; // + a[n] / 8 + 32;
            drwpixel2(1,0,0,b,n,_size);
        }
        // send_rcv(romparams[rom].bsize);
        txdata(romparams[romtype].bsize);

        if (romparams[romtype].iface_type==SPI) {
            pgmsendstopspi();
        } else if (romparams[romtype].iface_type==TWI) {
            pgmsendstoptwi();
        }

/*
#ifdef SPI
 pgmsendstop();
#else
 pgmsendstop();
#endif
*/

    }
    polling(100);

    cairo_destroy(cr);

    printf("Polling: pmin=%d pmax=%d\n",pmin,pmax);

    pgmsetmode(PWR_ON + LED0); //green

    //write reset polarity
    if (GTK_TOGGLE_BUTTON(cbt[1][2])->active) {
        if (romparams[romtype].iface_type==TWI) {
            switch (romtype) { //here 'start' not need because previous polling
            /* case 1:
 case 2:
 case 3: //not verified because not have old chips
 printf("Write reset polarity (1-3)...\n");
 sb=sb | 3; //OE=1, CE=1
 outstatus();
 adr=0x3fff;
 cb=128+2;
 wrt_adr();
 iob=0xff;
 outbyte_without_read();
 cb=128+32+2 ; //stop & initiate write cycle
 outbyte_without_read(); //here may read last ACK for write err check
 polling();
 sb=sb & (255-3); //OE=0, CE=0
 outstatus();
 break;*/
            case 4:
            case 5:
            case 6:
            case 7:
                printf("Write reset polarity (4-7)...\n");
                pgmsendstartsetaddrtwi(0xa6);
                if ((romtype==4)|(romtype==5)) {
                    wrt_adr(0x20000);
    // adr=0x20000;
                } else {
    // adr=0x40000;
                    wrt_adr(0x40000);
                }
              //wrt_adr(adr);
                outbuf[0]=0xff; // or 00
                outbuf[1]=0xff;// or 00
                outbuf[2]=0xff;// or 00
                outbuf[3]=0xff;// or 00
                txdata(4);
                pgmsendstoptwi();

                polling(1000);
                break;
            }
        }
    } //write reset polarity

    if (GTK_TOGGLE_BUTTON(cbt[1][3])->active) { //disable osc

        if (romparams[romtype].iface_type==TWI) {
            if ((romtype==4)|(romtype==5)|(romtype==6)) {
                printf("Disable OSC (4-6)...\n");
                pgmsendstartsetaddrtwi(0xa6);
                if ((romtype==4)|(romtype==5)) {
    // adr=0x380000;
                    wrt_adr(0x380000);
                } else {
                    wrt_adr(0xe00000);
    // adr=0xe00000;
                }
    // wrt_adr(adr);
                outbuf[0]=0x00; // or ff
                txdata(1);
                pgmsendstoptwi();
                polling(1000);
            }
        }
    }
    pgmsetmode(PWR_OFF);
    ReadChipToArrayanddraw();
    iface_ready();
}

void eeprom_write(void) {
    WriteChipFromArrayanddraw();
}

/*
 cr = gdk_cairo_create(lbl[1][8]->window);

 cairo_set_source_rgba(cr, 0, 0, 1, 0.5);
 cairo_rectangle(cr, 0, 0, 40, 40);
 cairo_fill(cr);

 cairo_destroy(cr);

 * */
// gtk_label_set_text(GTK_LABEL(lbl[2][5]), "CRC: n/a");

// NEW!!! (AT17C ONLY WARNING)
// After reading the manufacturer identification bytes, a hardware power cycle (power on
// reset) is required in order to access the actual location of the memory in the programming
// mode. For the new devices (35.5 process), toggling the SER_EN pin from Low
// to High and the Low with respect to the programming clock cycle will automatically
// exit the manufacturer identification read mode without power cycle.
void detect(void) {
    if (dev_is_connected) {
        iface_busy();
        eeprom_ready = FALSE;
        printcrc(0,0,0,2,5);
        printcrc(0,0,0,2,6);
        romtype=255; // chipnotfound;
        setrom();
        msg1("Detecting...");

// dev_getid();

        pgmsetmode(PWR_OFF);
        usleep(100000);
        pgmsetmode(PWR_ON + LED0); // green
        usleep(100000);

        if (eep_socket[TWI] == 1) {
            printf ("Has TWI socket. Detecting TWI EEPROM:\n");
            pgmsendstartsetaddrtwi(0xa7);
            if (inbuf[0]==0xff) { // ack
                // chip found
                pgmsendstartsetaddrtwi(0xa6);
                romtype=4;
                wrt_adr(0x040000);
                romtype=0;
                pgmsendstartsetaddrtwi(0xa7);
                // send_rcv(2); //read 2 bytes
                rxdata(2);

                rom_autodetect_type=inbuf[0]*256+inbuf[1];
                // printf("\n%d\n",rom_autodetect_type);
                switch (rom_autodetect_type) {
                case 0x78EC: // it is 1E, 37
                    romtype=4;
                    break;
                case 0x78EF:
                    romtype=5;
                    break;
                }
                setrom();
                // pgmsendstop();
                pgmsendstoptwiofftwi();
            } else {
                romtype=255; //no chip
                setrom();
                printf ("TWI Detect: nack - chip problem\n");
                // if (automode==1) { exit(EXIT_FAILURE); }
                automode=0;
            }
            usleep(50000);
        }

        if (eep_socket[SPI] == 1) {
            printf ("Has SPI socket. Detecting SPI EEPROM:\n");

            romtype=9; // en25f16

            automode=0;
            setrom();

        }

        if ((romtype>=1)&&(romtype<=9)) {
            // if (automode==0) ReadChipToArrayanddraw();
            // if (automode==1) WriteChipFromArrayanddraw();
            // if (automode==1) { if (crc1==crc2) exitapp(); }
            eeprom_ready = TRUE;

            ReadChipToArrayanddraw();

        }
        pgmsetmode(PWR_OFF);

        if ((romtype==8)||(romtype==9)) {
            gtk_widget_set_sensitive(cbt[1][2],0);
            gtk_widget_set_sensitive(cbt[1][3],0);
        }

        iface_ready();
    } else {
        printf ("Programmer not connected!\n");
    }
    readfile();
}

//struct sigaction sa;
struct itimerval timer; //unfortunately can't have two timers.
//And sigalrm timer affect socket timeout! So must used without mixing
//socket operation and main work.

/*void dummy (int signum)
{
}*/
/*
void timer_empty(void)
{
 // sa.sa_handler = &dummy;
 // sigaction (SIGALRM, &sa, NULL);
}

void timer_set(int tim)
{
 timer.it_value.tv_sec = 0;
 timer.it_value.tv_usec = tim;
 timer.it_interval.tv_sec = 0;
 timer.it_interval.tv_usec = tim;
 setitimer (ITIMER_REAL, &timer, NULL);
 // sa.sa_handler = &timer_handler;
 // sigaction (SIGALRM, &sa, NULL);
 // tick = 0;
}
*/

void gtkgui_close(void) {
    strcpy(oscar_ip_readwrite, gtk_entry_get_text(GTK_ENTRY(entry_ip)));
    oscar_port = gtk_spin_button_get_value ((GtkSpinButton*) spin_port);
    gtk_main_quit();
}

void msg(char *s)
{
    /*gettimeofday(&current_time, NULL);
 seconds = current_time.tv_sec - programstart_time.tv_sec;
 useconds = current_time.tv_usec - programstart_time.tv_usec;
 mtime = (seconds*1000000.0 + useconds)/1000000.0;
 printf("[%f] %s\n",mtime,s);*/
    printf("%s\n", s);
}

void statustext(char s[1024]) {
    char ss[1024];
    strcpy(ss, "<i>");
    strcat(ss, s);
    strcat(ss, "</i>");
    ss[strlen(ss)]='\0';
    gtk_label_set_markup (GTK_LABEL (status_bar_label), ss);
    ApplicationProcessMessages();
}

void dev_connect (void) {
#ifdef gtkgui
    strcpy(oscar_ip_readwrite, gtk_entry_get_text(GTK_ENTRY(entry_ip)));
    oscar_port = gtk_spin_button_get_value ((GtkSpinButton*) spin_port);
#endif
    strcpy(devipaddr, oscar_ip_readwrite);
    devport = oscar_port;

    if (dev_is_connected == 1)
        return;
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        msg("socket() failed\n");
    memset(&devaddr, 0, sizeof(devaddr));
    devaddr.sin_family      = AF_INET;             /* Internet address family */
    devaddr.sin_addr.s_addr = inet_addr(devipaddr);   /* Server IP address */
    devaddr.sin_port        = htons(devport); /* Server port */
    /* Establish the connection to the echo server */
    if (connect(sock, (struct sockaddr *) &devaddr, sizeof(devaddr)) < 0) {
        msg("connect() failed");
        dev_is_connected = 0;
// strcpy(s, "Connect failed.");
        sprintf(s, "Connect to %s:%d failed.",devipaddr,devport);
#ifdef gtkgui
        statustext(s);
// gtk_label_set_text(GTK_LABEL(status_bar_label), s);
#else
        printf("%s\n",s);
#endif

    } else {
        eep_daughbrd_type = 0;
        dev_is_connected = 1;
        usleep(100000);
        dev_getid();
        strcpy(s, "Connected: ");
        if ((rcvd>8) && (rcvd<256)) {
            for (i=8; i<(rcvd-1); i++) {
                sprintf(s,"%s%c",s,inbuf[i]);
            }
        }
        sprintf(s,"%s\nDaugterboard: ", s);
        eep_daughbrd_type = inbuf[7]; // get capability byte #3
        eep_socket[TWI]=0; eep_socket[SPI]=0;
        strcpy(ss, "UNKNOWN / NOT FOUND");
        if (eep_daughbrd_type == 1) { strcpy(ss, "TWI/I2C 3,3V"); eep_socket[TWI]=1; }
        if (eep_daughbrd_type == 2) { strcpy(ss, "SPI 3,3V"); eep_socket[SPI]=1; }
        if (eep_daughbrd_type == 3) { strcpy(ss, "TWI/I2C and SPI 3,3V"); eep_socket[TWI]=1; eep_socket[SPI]=1; }
        if (eep_daughbrd_type == 5) { strcpy(ss, "TWI/I2C 5V"); eep_socket[TWI]=1; }
        if (eep_daughbrd_type == 6) { strcpy(ss, "SPI 5V"); eep_socket[SPI]=1; }
        if (eep_daughbrd_type == 7) { strcpy(ss, "TWI/I2C and SPI 5V"); eep_socket[TWI]=1; eep_socket[SPI]=1; }

        sprintf(s,"%s %s (type: %d)", s, ss, eep_daughbrd_type);
// sprintf(s,"%s qqqqqqqq",s);

#ifdef gtkgui
        statustext(s);
// gtk_label_set_text(GTK_LABEL(status_bar_label), s);
#else
// printf("%s\n",s);
#endif
          printf("%s\n",s);
    }
}

void dev_disconnect (void) {
    strcpy(s, "Disconnected.");
#ifdef gtkgui
    statustext(s);
#else
    printf("%s\n",s);
#endif
    if (dev_is_connected == 0)
        return;
    dev_is_connected = 0;
    close(sock);
}

int idle_function () {
    if (state==0) {
        gtk_entry_set_text(GTK_ENTRY(entry_filename), filename);
        state=1;
        dev_connect();
        while (gtk_events_pending ()) gtk_main_iteration ();
        return(TRUE);
    }
    if (state==1) {
        state=2;
        if (dev_is_connected==1) {
            detect();
        }
        return(FALSE); // this is last state and we stop subsequent calls of this function.
    }
    return (TRUE);
}

int main( int   argc,
        char *argv[] )
{
    FILE *fp;
// char path[1035];
    int err;
    int i;
    int pos; // position of substr

// get own path + exe name
// http://stackoverflow.com/questions/4025370/can-an-executable-discover-its-own-path-linux
    char path[PATH_MAX];
    char dest[PATH_MAX];
// struct stat info;
    pid_t pid = getpid();

    printf("Jopka: Hi!\n");

    active_size = 0;
    max_size = 0;

    eep_daughbrd_type = 0;
    eeprom_ready = FALSE;
    fileread_ready = FALSE;

// first, try to process config ini file.
//if config file not exist then create default.
        printf("Checking for '%s' config file exists...\n", inifile);
        if (!(file_exists(inifile))) {
            printf("File not found. I will now create default configuration for you.\n");
            if (ini_settings_update()==EXIT_FAILURE) return(EXIT_FAILURE);
            fprintf(stdout, "Default configuration successfully written to: %s\n", inifile);
        } else {
            printf("Config file found.\n");
        }
// Read the file. If there is an error, report it and exit.

        if(! config_read_file(&cfg, inifile))
        {
            fprintf(stderr, "%s:%d - %s\n", inifile, //config_error_file(&cfg),
                    config_error_line(&cfg), config_error_text(&cfg));
            fprintf(stderr, "You may need to check or detete it.\n");
            config_destroy(&cfg);
            return(EXIT_FAILURE);
        }
// Get the values
        inierr=0;

// These settings required and raise error if not exist.
// if (!(config_lookup_float(&cfg, "freq", &freq))) { inierr=1; }
        if (!(config_lookup_string(&cfg, "ip", &oscar_ip_readonly))) {
            inierr=1;

        } else {
            strcpy(oscar_ip_readwrite, oscar_ip_readonly);
        }

//printf("inierr=%d\n",inierr);

// not work when i switch to 64-bit
// if (!(config_lookup_int64(&cfg, "port", &oscar_port))) { inierr=1; }
// so i change it to something that work
        if (!(config_lookup_int(&cfg, "port", &oscar_port))) { inierr=1; }
// These settings optional and used defaults if not exist.
/* for (i=0; i<max_regs; i++) {
 sprintf (s, "reg_string%d",i);
 if (!(config_lookup_string(&cfg, s, &reg_string_readonly))) {
 strcpy(reg_string[i], "00000000000000000000000000000000");
 } else {
 strcpy(reg_string[i], reg_string_readonly);
 }
 }*/

//printf("inierr=%d\n",inierr);
//return(0);

// done reading settings
        if (inierr==1) {
            fprintf(stderr, "Broken config file. You may need to check or detete it.\n");
            config_destroy(&cfg);
            return(EXIT_FAILURE);
        } else {
            printf("Config file parsed.\n");
        }
//done processing ini file.

// main work. some 'ini' settings may change, like this:
// test: it work!
//freq=222.2;

    sprintf(path, "/proc/%d/exe", pid);
    if (readlink(path, dest, PATH_MAX) == -1) {
        perror("readlink");
        exit(EXIT_FAILURE);
    } else {
        printf("%s\n", dest);
    }

// split it to path and name. But dirname() and basename() use pointers so it is too hard to use. So write own procedure.
    if (strchr(dest, '/') != NULL) {
        pos = 0;
        for (i=0; i<strlen(dest); i++) {
            if (dest[i]=='/') { pos=i; } // find last delimiter
// reuse variable
            strncpy(path, dest, pos+1);
            path[pos+1]='\0';
        }
    } else {
        strcpy(path, "./\0");
    }
    printf("%s\n", path);

    chksum_crc32gentab ();

    dtx=0;
    drx=0;

// gnome_execute_shell(NULL, "sh -c 'killall -STOP gnome-screensaver'");

// typical run string from ise:
// -intstyle ise -f yyyyyy.ut yyyyyy.ncd
// i.e. it not contain .bit filename.

    automode=0;
    strcpy(filename,"./rom.dat");

    strcpy(s, " ");
    for (i=1; i<argc; i++) {
        strcat(s, " ");
        strcat(s, argv[i]);
        if ((argv[i][0])=='-') { // -parameter detected - then it calls from webpack prpbably.
            if (automode==0) printf("Jopka: Automatic mode started due to call from ext program i see.\n");
            automode=1;
        }

        if (strchr(argv[i], '.')!=NULL) {  // probably filename with extension
// replaced 21-03-2013 for unknown reason :
// if ((automode==1)&&(strchr(argv[i], '.')!=NULL)) { // probably filename with extension

            if (automode==1) {
// replace extension to '.bit'
/*
 j=0; // pos
 while ((argv[i][j])!='.') {
 j=j+1;
 }
 strncpy(filename, argv[i], j);*/
// search from end
// else errors due to path contain '.' /home/test/lscc/iCEcube2.2014.04/sbt_backend/Projects/testoj/testoj_Implmnt/sbt/outputs/bitmap/uart_bitmap.bin
                j=strlen(argv[i])-1;
                while ((argv[i][j])!='.') {
                    j=j-1;
                }
                strncpy(filename, argv[i], j);
                filename[j]='\0';
                strcat(filename, ".bit");
            } else {
// do not change extension
// j=strlen(argv[i]);
                strcpy(filename, argv[i]);
                filename[strlen(argv[i])]='\0';
            }
            printf("Jopka: Filename reconstructed: '%s'\n",filename);
        }
    }

// gtk_entry_set_text(GTK_ENTRY(entry_filename), filename);

    char commandline[512];
    if (automode==1) {
// sprintf(commandline, "/opt/Xilinx/13.3/ISE_DS/ISE/bin/lin/bitgen %s", s);
        sprintf(commandline, "%sbitgen %s", path, s);
        printf("Jopka: launch '%s'\n",commandline);
        // system((char *)temp); its work

// Open the command for reading.
        fp = popen(commandline, "r");
        if (fp == NULL) {
            printf("Jopka: Failed to run command '%s'\n",commandline);
            return EXIT_FAILURE;
        }

// Read the output a line at a time - output it.
        err=0;
        while (fgets(path, sizeof(path)-1, fp) != NULL) {
            printf("%s", path);
            if (strncmp(path, "ERROR", 5)==0)
            {
                err=1;
            }
        }
        pclose(fp);

        if (err==1) {
            printf("Jopka: errors found, quitting.\n");
            return EXIT_FAILURE;
        }
    }

    sprintf(commandline, "Ethernet serial eeprom prog: %s\n", s);

    gtk_init (&argc, &argv);
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW(window), commandline);
    gtk_container_set_border_width(GTK_CONTAINER(window), 2);

    vbcontrol = gtk_vbox_new (FALSE, 2);
    // gtk_container_add (GTK_CONTAINER (hb), vbcontrol);
    lbl[1][0] = gtk_label_new("");
    gtk_label_set_markup (GTK_LABEL (lbl[1][0]), "<big>Programmer</big>");
// gtk_table_attach(GTK_TABLE(table), lbl[1][0], 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0,0 );
// gtk_widget_set_size_request (GTK_WIDGET (lbl[1][0]), 128, 24);
    gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][0], FALSE, FALSE, 0);

    lbl[1][3] = gtk_label_new("OSCaR IP addr:");
    gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][3], FALSE, FALSE, 0);
    entry_ip = gtk_entry_new();
    gtk_entry_set_text(GTK_ENTRY(entry_ip), oscar_ip_readwrite);
// only width need to set (limit) here, else widget too wide and stretch middle column.
// but not know how to limit only widtn, not height.
    gtk_widget_set_size_request (GTK_WIDGET (entry_ip), 96, 32);
    gtk_box_pack_start (GTK_BOX (vbcontrol), entry_ip, FALSE, FALSE, 0);

    lbl[1][9] = gtk_label_new("Port:");
    gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][9], FALSE, FALSE, 0);
    spin_port = gtk_spin_button_new_with_range (1, 65535, 1);
    gtk_spin_button_set_value ((GtkSpinButton*) spin_port, oscar_port);
    gtk_box_pack_start (GTK_BOX (vbcontrol), spin_port, FALSE, FALSE, 4);

/* lbl[1][10] = gtk_label_new("Status:");
 gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][10], FALSE, FALSE, 0);
 lbl[1][11] = gtk_label_new("-");
 gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][11], FALSE, FALSE, 0);*/

    btn[1][2] = gtk_button_new_with_label("Connect");
    gtk_signal_connect(GTK_OBJECT(btn[1][2]), "clicked", GTK_SIGNAL_FUNC(dev_connect), NULL);
    gtk_box_pack_start (GTK_BOX (vbcontrol), btn[1][2], FALSE, FALSE, 0);
    btn[1][3] = gtk_button_new_with_label("Disconnect");
    gtk_signal_connect(GTK_OBJECT(btn[1][3]), "clicked", GTK_SIGNAL_FUNC(dev_disconnect), NULL);
    gtk_box_pack_start (GTK_BOX (vbcontrol), btn[1][3], FALSE, FALSE, 0);

    lbl[1][11] = gtk_label_new(" "); // separator
    gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][11], FALSE, FALSE, 0);

    lbl[1][4] = gtk_label_new("Read chip,\nwrite to file:");
    gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][4], FALSE, FALSE, 0);

    btn[1][0] = gtk_button_new_with_label ("\n<===\n");
    gtk_box_pack_start (GTK_BOX (vbcontrol), btn[1][0], FALSE, FALSE, 0);
    // g_signal_connect_swapped (G_OBJECT (btn[1][0]), "clicked", G_CALLBACK (eeprom_read), G_OBJECT (window));

// g_signal_connect (G_OBJECT (btn[1][0]), "clicked", G_CALLBACK (eeprom_read), G_OBJECT (window));

    lbl[1][5] = gtk_label_new(" ");
    gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][5], FALSE, FALSE, 0);
    lbl[1][6] = gtk_label_new("Read file,\nprogram chip:");
    gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][6], FALSE, FALSE, 0);

    cbt[1][1]=gtk_check_button_new_with_label ("Full");
    gtk_box_pack_start (GTK_BOX (vbcontrol), cbt[1][1], FALSE, FALSE, 0);
    cbt[1][2]=gtk_check_button_new_with_label ("Wrt RST pol.");
    gtk_box_pack_start (GTK_BOX (vbcontrol), cbt[1][2], FALSE, FALSE, 0);
    cbt[1][3]=gtk_check_button_new_with_label ("Disable OSC");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbt[1][3]),1);
    gtk_box_pack_start (GTK_BOX (vbcontrol), cbt[1][3], FALSE, FALSE, 0);

    btn[1][1] = gtk_button_new_with_label ("\n===>\n");
    gtk_box_pack_start (GTK_BOX (vbcontrol), btn[1][1], FALSE, FALSE, 0);
    // g_signal_connect_swapped (G_OBJECT (btn[1][1]), "clicked", G_CALLBACK (eeprom_write), G_OBJECT (window));
    g_signal_connect (G_OBJECT (btn[1][1]), "clicked", G_CALLBACK (eeprom_write), G_OBJECT (window));

    lbl[1][7] = gtk_label_new("\nCompare result:");
    gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][7], FALSE, FALSE, 0);

    lbl[1][8] = gtk_label_new("\nlbl[1][8]");
    gtk_box_pack_start (GTK_BOX (vbcontrol), lbl[1][8], FALSE, FALSE, 0);

    GtkWidget *table;
    table = gtk_table_new(10, 3, FALSE);
    gtk_table_set_row_spacings(GTK_TABLE(table), 2); //2
    gtk_table_set_col_spacings(GTK_TABLE(table), 8); //2

    lbl[0][0] = gtk_label_new("");
    gtk_label_set_markup (GTK_LABEL (lbl[0][0]), "<big>FILE</big>");
    gtk_table_attach(GTK_TABLE(table), lbl[0][0], 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );

    entry_filename = gtk_entry_new();
    gtk_entry_set_text(GTK_ENTRY(entry_filename), "yyy");
// gtk_widget_set_size_request (GTK_WIDGET (entry_filename), 96, 32);
    gtk_table_attach(GTK_TABLE(table), entry_filename, 0, 1, 1, 2,GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );

    cbt[0][0]= gtk_check_button_new_with_label ("Foundation header");
// cbt[0][0]= gtk_radio_button_new_with_label (NULL, "Foundation header");
// rb[0][1] = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (rb[0][0]),".bin (raw bytes)");
    gtk_table_attach(GTK_TABLE(table), cbt[0][0], 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );

    btn[0][0] = gtk_button_new_with_label ("Re-read");
    g_signal_connect (G_OBJECT (btn[0][0]), "clicked", G_CALLBACK (readfile), G_OBJECT (window));
    gtk_table_attach(GTK_TABLE(table), btn[0][0], 0, 1, 3, 4,GTK_EXPAND | GTK_FILL | GTK_FILL, GTK_SHRINK,  0,0 );

    scrollview = gtk_scrolled_window_new( NULL, NULL );
    textview = gtk_text_view_new ();
    buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
    gtk_widget_set_size_request (GTK_WIDGET (textview), 128, 128);
    gtk_text_buffer_set_text (buffer, "Read-only =)\n", -1);
    gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
    gtk_container_add(GTK_CONTAINER (scrollview), textview);
    gtk_table_attach(GTK_TABLE(table), scrollview, 0, 1, 4, 5, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );

    dr[0] = gtk_drawing_area_new();
    gtk_widget_set_size_request (GTK_WIDGET (dr[0]), 256, 256);
    g_signal_connect (G_OBJECT (dr[0]), "expose_event", G_CALLBACK (expose_event), (int*) 0);
    // g_signal_connect (G_OBJECT (lbl[0][4]),"configure_event", G_CALLBACK (configure_event), (int*) 0);
    gtk_table_attach(GTK_TABLE(table), GTK_WIDGET (dr[0]), 0, 1, 5, 6, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,  0,0 );

    /* lbl[0][4] = gtk_label_new ("lbl[0][4]");
 gtk_widget_set_size_request (GTK_WIDGET (lbl[0][4]), 256, 255);
 g_signal_connect (G_OBJECT (lbl[0][4]), "expose_event", G_CALLBACK (expose_event), (int*) 0);
// g_signal_connect (G_OBJECT (lbl[0][4]),"configure_event", G_CALLBACK (configure_event), (int*) 0);
 gtk_table_attach(GTK_TABLE(table), lbl[0][4], 0, 1, 5, 6, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0,0 );
 */

    lbl[0][5] = gtk_label_new("lbl[0][5]");
    gtk_table_attach(GTK_TABLE(table), lbl[0][5], 0, 1, 6, 7, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );
    lbl[0][6] = gtk_label_new("lbl[0][6]");
    gtk_table_attach(GTK_TABLE(table), lbl[0][6], 0, 1, 7, 8, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );

    gtk_table_attach(GTK_TABLE(table), vbcontrol, 1, 2, 0, 9 ,GTK_SHRINK, GTK_EXPAND | GTK_FILL,  0,0 );

    /*
 cbt[1][0]=gtk_check_button_new_with_label ("Fast");
 gtk_table_attach(GTK_TABLE(table), cbt[1][0], 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0 );

 lbl[1][3] = gtk_label_new("---");
 lbl[1][4] = gtk_label_new("Read chip,\nwrite to file:");
 gtk_table_attach(GTK_TABLE(table), lbl[1][3], 1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 0,0 );
 gtk_table_attach(GTK_TABLE(table), lbl[1][4], 1, 2, 3, 4, GTK_SHRINK, GTK_SHRINK, 0,0 );

 btn[1][0] = gtk_button_new_with_label ("\n<===\n");
// g_signal_connect_swapped (G_OBJECT (btn[1][0]), "clicked", G_CALLBACK (eeprom_read), G_OBJECT (window));
 g_signal_connect (G_OBJECT (btn[1][0]), "clicked", G_CALLBACK (eeprom_read), G_OBJECT (window));
 gtk_table_attach(GTK_TABLE(table), btn[1][0], 1, 2, 4, 5, GTK_SHRINK, GTK_SHRINK, 0,0 );

 lbl[1][4] = gtk_label_new ("lbl[1][4]");
 gtk_table_attach(GTK_TABLE(table), lbl[1][4], 1, 2, 5, 6 ,GTK_SHRINK, GTK_EXPAND | GTK_FILL, 0,0 );

 */

    lbl[2][0] = gtk_label_new("");
    gtk_label_set_markup (GTK_LABEL (lbl[2][0]), "<big>EEPROM chip</big>");
    gtk_table_attach(GTK_TABLE(table), lbl[2][0], 2, 3, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );

    lbl[2][1] = gtk_label_new("lbl[2][1]");
// lbl[2][2] = gtk_label_new("lbl[2][2]");
    gtk_table_attach(GTK_TABLE(table), lbl[2][1], 2, 3, 1, 2, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );
// gtk_table_attach(GTK_TABLE(table), lbl[2][2], 2, 3, 2, 3, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0,0 );

    dr[2] = gtk_drawing_area_new();
    // lbl[2][4] = gtk_label_new ("lbl[2][4]");
// gtk_widget_set_size_request (GTK_WIDGET (dr[2]), 256, 255);
    gtk_widget_set_size_request (GTK_WIDGET (dr[2]), 256, 256);
    g_signal_connect (G_OBJECT (dr[2]), "expose_event", G_CALLBACK (expose_event), (int*) 2);
    // g_signal_connect (G_OBJECT (lbl[0][4]),"configure_event", G_CALLBACK (configure_event), (int*) 0);
    gtk_table_attach(GTK_TABLE(table), dr[2], 2, 3, 5, 6 ,GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,  0,0 );

/* pb[2] = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, 256, 256);
 gtk_widget_set_size_request (GTK_WIDGET (pb[2]), 256, 255);
 g_signal_connect (G_OBJECT (pb[2]), "expose_event", G_CALLBACK (expose_event), (int*) 2);
 // g_signal_connect (G_OBJECT (lbl[0][4]),"configure_event", G_CALLBACK (configure_event), (int*) 0);
 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET (pb[2]), 2, 3, 5, 6 ,GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0,0 );
*/

    lbl[2][5] = gtk_label_new("lbl[2][5]");
    gtk_table_attach(GTK_TABLE(table), lbl[2][5], 2, 3, 6, 7, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );
    lbl[2][6] = gtk_label_new("lbl[2][6]");
    gtk_table_attach(GTK_TABLE(table), lbl[2][6], 2, 3, 7, 8, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );

    btn[2][0] = gtk_button_new_with_label ("Refresh");
    // gtk_box_pack_start (GTK_BOX (vbchip[0]), btn[2][0], FALSE, FALSE, 0);
    // g_signal_connect_swapped (G_OBJECT (btn[2][0]), "clicked", G_CALLBACK (detect), G_OBJECT (window));
    g_signal_connect (G_OBJECT (btn[2][0]), "clicked", G_CALLBACK (detect), G_OBJECT (window));
    gtk_table_attach(GTK_TABLE(table), btn[2][0], 2, 3, 3, 4,GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );

    vbx=gtk_vbox_new (FALSE, 0);
    for (i=0; i<romq; i++) {
        cbt[2][i]=gtk_check_button_new_with_label (romparams[i+1].name);
        gtk_box_pack_start (GTK_BOX (vbx), cbt[2][i], FALSE, FALSE, 0);
    }
    // gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbt[2][5]),1); // test
    gtk_table_attach(GTK_TABLE(table), vbx, 2, 3, 4, 5, GTK_EXPAND | GTK_FILL, GTK_SHRINK,  0,0 );

    main_vbox = gtk_vbox_new (FALSE, 1);
    gtk_container_add (GTK_CONTAINER (window), main_vbox);
    gtk_widget_show (main_vbox);

    gtk_box_pack_start (GTK_BOX (main_vbox), table, TRUE, TRUE, 0);

// it is a pain to work with gtk_statusbar due to its extremely complex,
// byt i need only to display text!
// status_bar = gtk_statusbar_new ();

    status_bar_label = gtk_label_new ("-");
    statustext ("Waiting for IP connection...");

// it work, we need to create procedure "statustext" to display status in italic,
// but it's not Pascal, so impossible to pass string value to procedure, so we cry and leave all
// statusbar writing as just `status_bar_label` text changes.
// gtk_label_set_markup (GTK_LABEL (status_bar_label), "<i>test</i>");
    gtk_box_pack_start (GTK_BOX (main_vbox), status_bar_label, FALSE, FALSE , 0);

    gtk_widget_show_all (window);

// without this - code after dtk_main() not run.
// g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
    g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtkgui_close), NULL);

    stop=0;
    romtype=255;
    setrom();

// once=0;
    state=0;
// dont forget to place "while (gtk_events_pending ()) gtk_main_iteration ();" in call func!
// first_auto_run == 0
    g_idle_add ((GSourceFunc) idle_function, NULL);

    gtk_main ();

// gnome_execute_shell(NULL, "sh -c 'killall -CONT gnome-screensaver'");
// close(fd);

// all values should be saved in .ini file.
    if (ini_settings_update()==EXIT_FAILURE) return(EXIT_FAILURE);
    fprintf(stdout, "Configuration successfully written to: %s\n", inifile);

    printf("Jopka: Bye!\n");
    return 0;
}