#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>

#include "readdata.c"


static void enter_callback( GtkWidget *widget,
                            GtkWidget *entry )
{
  const gchar *entry_text;
  entry_text = gtk_entry_get_text (GTK_ENTRY (entry));
  printf ("Entry contents: %s\n", entry_text);
}


int main( int argc, char *argv[] )
{

    GdkColor colorGrey;
    GdkColor colorBlack;

    gdk_color_parse ("grey", &colorGrey);
    gdk_color_parse ("black", &colorBlack);


    GtkWidget *window;
    GtkWidget *vbox, *vboxa,*vboxb,*vboxc,*vboxd,*vboxe,*vboxf,*vboxg,*vboxh,*vboxi,*vboxj,*vboxk,*vboxl, *hbox;
    GtkWidget *label,*label0,*label1,*label2,*label3,*label4,*label5,*label6,*label7,*label8,*label9,*label10,*label11;
    GtkWidget *label12,*label13,*label14,*label15,*label16,*label17;
    GtkWidget *labela,*labelb,*labelc,*labeld,*labele,*labelf,*labelg,*labelh,*labeli,*labelj,*labelk,*labell;
    GtkWidget *cella0,*cellb0,*cellc0,*celld0,*celle0,*cellf0,*cellg0,*cellh0,*celli0,*cellj0,*cellk0,*celll0;
    GtkWidget *cella1,*cellb1,*cellc1,*celld1,*celle1,*cellf1,*cellg1,*cellh1,*celli1,*cellj1,*cellk1,*celll1;
    GtkWidget *cella2,*cellb2,*cellc2,*celld2,*celle2,*cellf2,*cellg2,*cellh2,*celli2,*cellj2,*cellk2,*celll2;
    GtkWidget *cella3,*cellb3,*cellc3,*celld3,*celle3,*cellf3,*cellg3,*cellh3,*celli3,*cellj3,*cellk3,*celll3;
    GtkWidget *cella4,*cellb4,*cellc4,*celld4,*celle4,*cellf4,*cellg4,*cellh4,*celli4,*cellj4,*cellk4,*celll4;
    GtkWidget *cella5,*cellb5,*cellc5,*celld5,*celle5,*cellf5,*cellg5,*cellh5,*celli5,*cellj5,*cellk5,*celll5;
    GtkWidget *cella6,*cellb6,*cellc6,*celld6,*celle6,*cellf6,*cellg6,*cellh6,*celli6,*cellj6,*cellk6,*celll6;
    GtkWidget *cella7,*cellb7,*cellc7,*celld7,*celle7,*cellf7,*cellg7,*cellh7,*celli7,*cellj7,*cellk7,*celll7;
    GtkWidget *cella8,*cellb8,*cellc8,*celld8,*celle8,*cellf8,*cellg8,*cellh8,*celli8,*cellj8,*cellk8,*celll8;
    GtkWidget *cella9,*cellb9,*cellc9,*celld9,*celle9,*cellf9,*cellg9,*cellh9,*celli9,*cellj9,*cellk9,*celll9;
    GtkWidget *cella10,*cellb10,*cellc10,*celld10,*celle10,*cellf10,*cellg10,*cellh10,*celli10,*cellj10,*cellk10,*celll10;
    GtkWidget *cella11,*cellb11,*cellc11,*celld11,*celle11,*cellf11,*cellg11,*cellh11,*celli11,*cellj11,*cellk11,*celll11;
    GtkWidget *cella12,*cellb12,*cellc12,*celld12,*celle12,*cellf12,*cellg12,*cellh12,*celli12,*cellj12,*cellk12,*celll12;
    GtkWidget *cella13,*cellb13,*cellc13,*celld13,*celle13,*cellf13,*cellg13,*cellh13,*celli13,*cellj13,*cellk13,*celll13;
    GtkWidget *cella14,*cellb14,*cellc14,*celld14,*celle14,*cellf14,*cellg14,*cellh14,*celli14,*cellj14,*cellk14,*celll14;
    GtkWidget *cella15,*cellb15,*cellc15,*celld15,*celle15,*cellf15,*cellg15,*cellh15,*celli15,*cellj15,*cellk15,*celll15;
    GtkWidget *cella16,*cellb16,*cellc16,*celld16,*celle16,*cellf16,*cellg16,*cellh16,*celli16,*cellj16,*cellk16,*celll16;
    GtkWidget *cella17,*cellb17,*cellc17,*celld17,*celle17,*cellf17,*cellg17,*cellh17,*celli17,*cellj17,*cellk17,*celll17;
    gtk_init (&argc, &argv);

    strcpy(filename,argv[1]);
    

    read_data();

    /* create a new window */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    //gtk_widget_set_size_request (GTK_WIDGET (window), 1000, 430);
    gtk_window_set_title (GTK_WINDOW (window), "GTK GLaSS view");
    g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
    g_signal_connect_swapped (window, "delete-event", G_CALLBACK (gtk_widget_destroy), window);

    hbox = gtk_hbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER(window), hbox);

    vbox = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vbox);
    gtk_widget_show (vbox);

    vboxa = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxa);
    gtk_widget_show (vboxa);

    vboxb = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxb);
    gtk_widget_show (vboxb);

    vboxc = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxc);
    gtk_widget_show (vboxc);

    vboxd = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxd);
    gtk_widget_show (vboxd);

    vboxe = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxe);
    gtk_widget_show (vboxe);

    vboxf = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxf);
    gtk_widget_show (vboxf);

    vboxg = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxg);
    gtk_widget_show (vboxg);

    vboxh = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxh);
    gtk_widget_show (vboxh);

    vboxi = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxi);
    gtk_widget_show (vboxi);

    vboxj = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxj);
    gtk_widget_show (vboxj);

    vboxk = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hbox), vboxk);
    gtk_widget_show (vboxk);

    vboxl = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(hbox),vboxl);
    gtk_widget_show(vboxl);

    label = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label)," ");
    gtk_entry_set_width_chars(GTK_ENTRY(label),3);
    gtk_editable_set_editable(GTK_EDITABLE(label),0);
    gtk_widget_modify_base(label, GTK_STATE_NORMAL, &colorBlack);
    gtk_widget_show (label);

    label0 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label0, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label0),"0");
    gtk_entry_set_width_chars(GTK_ENTRY(label0),3);
    gtk_editable_set_editable(GTK_EDITABLE(label0),FALSE);
    gtk_widget_modify_base(label0, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label0);

    label1 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label1, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label1),"1");
    gtk_entry_set_width_chars(GTK_ENTRY(label1),3);
    gtk_editable_set_editable(GTK_EDITABLE(label1),FALSE);
    gtk_widget_modify_base(label1, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label1);

    label2 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label2, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label2),"2");
    gtk_entry_set_width_chars(GTK_ENTRY(label2),3);
    gtk_editable_set_editable(GTK_EDITABLE(label2),FALSE);
    gtk_widget_modify_base(label2, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label2);

    label3 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label3, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label3),"3");
    gtk_entry_set_width_chars(GTK_ENTRY(label3),3);
    gtk_editable_set_editable(GTK_EDITABLE(label3),FALSE);
    gtk_widget_modify_base(label3, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label3);

    label4 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label4, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label4),"4");
    gtk_entry_set_width_chars(GTK_ENTRY(label4),3);
    gtk_editable_set_editable(GTK_EDITABLE(label4),FALSE);
    gtk_widget_modify_base(label4, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label4);

    label5 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label5, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label5),"5");
    gtk_entry_set_width_chars(GTK_ENTRY(label5),3);
    gtk_editable_set_editable(GTK_EDITABLE(label5),FALSE);
    gtk_widget_modify_base(label5, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label5);

    label6 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label6, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label6),"6");
    gtk_entry_set_width_chars(GTK_ENTRY(label6),3);
    gtk_editable_set_editable(GTK_EDITABLE(label6),FALSE);
    gtk_widget_modify_base(label6, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label6);

    label7 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label7, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label7),"7");
    gtk_entry_set_width_chars(GTK_ENTRY(label7),3);
    gtk_editable_set_editable(GTK_EDITABLE(label7),FALSE);
    gtk_widget_modify_base(label7, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label7);

    label8 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label8, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label8),"8");
    gtk_entry_set_width_chars(GTK_ENTRY(label8),3);
    gtk_editable_set_editable(GTK_EDITABLE(label8),FALSE);
    gtk_widget_modify_base(label8, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label8);

    label9 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label9, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label9),"9");
    gtk_entry_set_width_chars(GTK_ENTRY(label9),3);
    gtk_editable_set_editable(GTK_EDITABLE(label9),FALSE);
    gtk_widget_modify_base(label9, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label9);

    label10 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label10, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label10),"10");
    gtk_entry_set_width_chars(GTK_ENTRY(label10),3);
    gtk_editable_set_editable(GTK_EDITABLE(label10),FALSE);
    gtk_widget_modify_base(label10, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label10);

    label11 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label11, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label11),"11");
    gtk_entry_set_width_chars(GTK_ENTRY(label11),3);
    gtk_editable_set_editable(GTK_EDITABLE(label11),FALSE);
    gtk_widget_modify_base(label11, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label11);

    label12 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label12, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label12),"12");
    gtk_entry_set_width_chars(GTK_ENTRY(label12),3);
    gtk_editable_set_editable(GTK_EDITABLE(label12),FALSE);
    gtk_widget_modify_base(label12, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label12);

    label13 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label13, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label13),"13");
    gtk_entry_set_width_chars(GTK_ENTRY(label13),3);
    gtk_editable_set_editable(GTK_EDITABLE(label13),FALSE);
    gtk_widget_modify_base(label13, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label13);

    label14 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label14, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label14),"14");
    gtk_entry_set_width_chars(GTK_ENTRY(label14),3);
    gtk_editable_set_editable(GTK_EDITABLE(label14),FALSE);
    gtk_widget_modify_base(label14, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label14);

    label15 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label15, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label15),"15");
    gtk_entry_set_width_chars(GTK_ENTRY(label15),3);
    gtk_editable_set_editable(GTK_EDITABLE(label15),FALSE);
    gtk_widget_modify_base(label15, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label15);

    label16 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label16, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label16),"16");
    gtk_entry_set_width_chars(GTK_ENTRY(label16),3);
    gtk_editable_set_editable(GTK_EDITABLE(label16),FALSE);
    gtk_widget_modify_base(label16, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label16);

    label17 = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vbox), label17, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(label17),"17");
    gtk_entry_set_width_chars(GTK_ENTRY(label17),3);
    gtk_editable_set_editable(GTK_EDITABLE(label17),FALSE);
    gtk_widget_modify_base(label17, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (label17);


///*** column A
    labela = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxa), labela, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labela),"A");
    gtk_editable_set_editable(GTK_EDITABLE(labela),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labela),cell_width);
    gtk_widget_modify_base(labela, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labela);

    cella0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella0), 50);
    g_signal_connect (cella0, "activate", G_CALLBACK (enter_callback), cella0);
    gtk_entry_set_text (GTK_ENTRY (cella0), value[0][0]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella0),cell_width);
    gtk_widget_show (cella0);

    cella1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella1), 50);
    g_signal_connect (cella1, "activate", G_CALLBACK (enter_callback), cella1);
    gtk_entry_set_text (GTK_ENTRY (cella1), value[0][1]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella1),cell_width);
    gtk_widget_show (cella1);

    cella2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella2), 50);
    g_signal_connect (cella2, "activate", G_CALLBACK (enter_callback), cella2);
    gtk_entry_set_text (GTK_ENTRY (cella2), value[0][2]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella2),cell_width);
    gtk_widget_show (cella2);

    cella3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella3), 50);
    g_signal_connect (cella3, "activate", G_CALLBACK (enter_callback), cella3);
    gtk_entry_set_text (GTK_ENTRY (cella3), value[0][3]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella3),cell_width);
    gtk_widget_show (cella3);

    cella4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella4), 50);
    g_signal_connect (cella4, "activate", G_CALLBACK (enter_callback), cella4);
    gtk_entry_set_text (GTK_ENTRY (cella4), value[0][4]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella4),cell_width);
    gtk_widget_show (cella4);

    cella5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella5), 50);
    g_signal_connect (cella5, "activate", G_CALLBACK (enter_callback), cella5);
    gtk_entry_set_text (GTK_ENTRY (cella5), value[0][5]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella5),cell_width);
    gtk_widget_show (cella5);

    cella6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella6), 50);
    g_signal_connect (cella6, "activate", G_CALLBACK (enter_callback), cella6);
    gtk_entry_set_text (GTK_ENTRY (cella6), value[0][6]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella6),cell_width);
    gtk_widget_show (cella6);

    cella7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella7), 50);
    g_signal_connect (cella7, "activate", G_CALLBACK (enter_callback), cella7);
    gtk_entry_set_text (GTK_ENTRY (cella7), value[0][7]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella7),cell_width);
    gtk_widget_show (cella7);

    cella8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella8), 50);
    g_signal_connect (cella8, "activate", G_CALLBACK (enter_callback), cella8);
    gtk_entry_set_text (GTK_ENTRY (cella8), value[0][8]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella8),cell_width);
    gtk_widget_show (cella8);

    cella9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella9), 50);
    g_signal_connect (cella9, "activate", G_CALLBACK (enter_callback), cella9);
    gtk_entry_set_text (GTK_ENTRY (cella9), value[0][9]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella9),cell_width);
    gtk_widget_show (cella9);

    cella10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella10), 50);
    g_signal_connect (cella10, "activate", G_CALLBACK (enter_callback), cella10);
    gtk_entry_set_text (GTK_ENTRY (cella10), value[0][10]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella10),cell_width);
    gtk_widget_show (cella10);

    cella11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella11), 50);
    g_signal_connect (cella11, "activate", G_CALLBACK (enter_callback), cella11);
    gtk_entry_set_text (GTK_ENTRY (cella11), value[0][11]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella11),cell_width);
    gtk_widget_show (cella11);

    cella12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella12), 50);
    g_signal_connect (cella12, "activate", G_CALLBACK (enter_callback), cella12);
    gtk_entry_set_text (GTK_ENTRY (cella12), value[0][12]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella12),cell_width);
    gtk_widget_show (cella12);

    cella13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella13), 50);
    g_signal_connect (cella13, "activate", G_CALLBACK (enter_callback), cella13);
    gtk_entry_set_text (GTK_ENTRY (cella13), value[0][13]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella13),cell_width);
    gtk_widget_show (cella13);

    cella14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella14), 50);
    g_signal_connect (cella14, "activate", G_CALLBACK (enter_callback), cella14);
    gtk_entry_set_text (GTK_ENTRY (cella14), value[0][14]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella14),cell_width);
    gtk_widget_show (cella14);

    cella15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella15), 50);
    g_signal_connect (cella15, "activate", G_CALLBACK (enter_callback), cella15);
    gtk_entry_set_text (GTK_ENTRY (cella15), value[0][15]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella15),cell_width);
    gtk_widget_show (cella15);

    cella16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella16), 50);
    g_signal_connect (cella16, "activate", G_CALLBACK (enter_callback), cella16);
    gtk_entry_set_text (GTK_ENTRY (cella16), value[0][16]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella16),cell_width);
    gtk_widget_show (cella16);

    cella17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cella17), 50);
    g_signal_connect (cella17, "activate", G_CALLBACK (enter_callback), cella17);
    gtk_entry_set_text (GTK_ENTRY (cella17), value[0][17]);
    gtk_box_pack_start (GTK_BOX (vboxa), cella17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cella17),cell_width);
    gtk_widget_show (cella17);


    ///*** column B col=1
    labelb = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxb), labelb, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labelb),"B");
    gtk_editable_set_editable(GTK_EDITABLE(labelb),FALSE);
    gtk_widget_modify_base(labelb, GTK_STATE_NORMAL, &colorGrey);
    gtk_entry_set_width_chars(GTK_ENTRY(labelb),cell_width);
    gtk_widget_show (labelb);

    cellb0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb0), 50);
    g_signal_connect (cellb0, "activate", G_CALLBACK (enter_callback), cellb0);
    gtk_entry_set_text (GTK_ENTRY (cellb0), value[1][0]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb0),cell_width);
    gtk_widget_show (cellb0);

    cellb1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb1), 50);
    g_signal_connect (cellb1, "activate", G_CALLBACK (enter_callback), cellb1);
    gtk_entry_set_text (GTK_ENTRY (cellb1), value[1][1]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb1),cell_width);
    gtk_widget_show (cellb1);

    cellb2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb2), 50);
    g_signal_connect (cellb2, "activate", G_CALLBACK (enter_callback), cellb2);
    gtk_entry_set_text (GTK_ENTRY (cellb2), value[1][2]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb2),cell_width);
    gtk_widget_show (cellb2);

    cellb3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb3), 50);
    g_signal_connect (cellb3, "activate", G_CALLBACK (enter_callback), cellb3);
    gtk_entry_set_text (GTK_ENTRY (cellb3), value[1][3]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb3),cell_width);
    gtk_widget_show (cellb3);

    cellb4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb4), 50);
    g_signal_connect (cellb4, "activate", G_CALLBACK (enter_callback), cellb4);
    gtk_entry_set_text (GTK_ENTRY (cellb4), value[1][4]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb4),cell_width);
    gtk_widget_show (cellb4);

    cellb5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb5), 50);
    g_signal_connect (cellb5, "activate", G_CALLBACK (enter_callback), cellb5);
    gtk_entry_set_text (GTK_ENTRY (cellb5), value[1][5]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb5),cell_width);
    gtk_widget_show (cellb5);

    cellb6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb6), 50);
    g_signal_connect (cellb6, "activate", G_CALLBACK (enter_callback), cellb6);
    gtk_entry_set_text (GTK_ENTRY (cellb6), value[1][6]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb6),cell_width);
    gtk_widget_show (cellb6);

    cellb7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb7), 50);
    g_signal_connect (cellb7, "activate", G_CALLBACK (enter_callback), cellb7);
    gtk_entry_set_text (GTK_ENTRY (cellb7), value[1][7]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb7),cell_width);
    gtk_widget_show (cellb7);

    cellb8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb8), 50);
    g_signal_connect (cellb8, "activate", G_CALLBACK (enter_callback), cellb8);
    gtk_entry_set_text (GTK_ENTRY (cellb8), value[1][8]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb8),cell_width);
    gtk_widget_show (cellb8);

    cellb9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb9), 50);
    g_signal_connect (cellb9, "activate", G_CALLBACK (enter_callback), cellb9);
    gtk_entry_set_text (GTK_ENTRY (cellb9), value[1][9]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb9),cell_width);
    gtk_widget_show (cellb9);

    cellb10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb10), 50);
    g_signal_connect (cellb10, "activate", G_CALLBACK (enter_callback), cellb10);
    gtk_entry_set_text (GTK_ENTRY (cellb10), value[1][10]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb10),cell_width);
    gtk_widget_show (cellb10);

    cellb11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb11), 50);
    g_signal_connect (cellb11, "activate", G_CALLBACK (enter_callback), cellb11);
    gtk_entry_set_text (GTK_ENTRY (cellb11), value[1][11]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb11),cell_width);
    gtk_widget_show (cellb11);

    cellb12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb12), 50);
    g_signal_connect (cellb12, "activate", G_CALLBACK (enter_callback), cellb12);
    gtk_entry_set_text (GTK_ENTRY (cellb12), value[1][12]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb12),cell_width);
    gtk_widget_show (cellb12);

    cellb13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb13), 50);
    g_signal_connect (cellb13, "activate", G_CALLBACK (enter_callback), cellb13);
    gtk_entry_set_text (GTK_ENTRY (cellb13), value[1][13]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb13),cell_width);
    gtk_widget_show (cellb13);

    cellb14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb14), 50);
    g_signal_connect (cellb14, "activate", G_CALLBACK (enter_callback), cellb14);
    gtk_entry_set_text (GTK_ENTRY (cellb14), value[1][14]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb14),cell_width);
    gtk_widget_show (cellb14);

    cellb15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb15), 50);
    g_signal_connect (cellb15, "activate", G_CALLBACK (enter_callback), cellb15);
    gtk_entry_set_text (GTK_ENTRY (cellb15), value[1][15]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb15),cell_width);
    gtk_widget_show (cellb15);

    cellb16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb16), 50);
    g_signal_connect (cellb16, "activate", G_CALLBACK (enter_callback), cellb16);
    gtk_entry_set_text (GTK_ENTRY (cellb16), value[1][16]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb16),cell_width);
    gtk_widget_show (cellb16);

    cellb17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellb17), 50);
    g_signal_connect (cellb17, "activate", G_CALLBACK (enter_callback), cellb17);
    gtk_entry_set_text (GTK_ENTRY (cellb17), value[1][17]);
    gtk_box_pack_start (GTK_BOX (vboxb), cellb17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellb17),cell_width);
    gtk_widget_show (cellb17);


   ///*** column C
    labelc = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxc), labelc, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labelc),"C");
    gtk_editable_set_editable(GTK_EDITABLE(labelc),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labelc),cell_width);
    gtk_widget_modify_base(labelc, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labelc);

    cellc0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc0), 50);
    g_signal_connect (cellc0, "activate", G_CALLBACK (enter_callback), cellc0);
    gtk_entry_set_text (GTK_ENTRY (cellc0), value[2][0]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc0),cell_width);
    gtk_widget_show (cellc0);

    cellc1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc1), 50);
    g_signal_connect (cellc1, "activate", G_CALLBACK (enter_callback), cellc1);
    gtk_entry_set_text (GTK_ENTRY (cellc1), value[2][1]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc1),cell_width);
    gtk_widget_show (cellc1);

    cellc2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc2), 50);
    g_signal_connect (cellc2, "activate", G_CALLBACK (enter_callback), cellc2);
    gtk_entry_set_text (GTK_ENTRY (cellc2), value[2][2]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc2),cell_width);
    gtk_widget_show (cellc2);

    cellc3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc3), 50);
    g_signal_connect (cellc3, "activate", G_CALLBACK (enter_callback), cellc3);
    gtk_entry_set_text (GTK_ENTRY (cellc3), value[2][3]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc3),cell_width);
    gtk_widget_show (cellc3);

    cellc4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc4), 50);
    g_signal_connect (cellc4, "activate", G_CALLBACK (enter_callback), cellc4);
    gtk_entry_set_text (GTK_ENTRY (cellc4), value[2][4]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc4),cell_width);
    gtk_widget_show (cellc4);

    cellc5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc5), 50);
    g_signal_connect (cellc5, "activate", G_CALLBACK (enter_callback), cellc5);
    gtk_entry_set_text (GTK_ENTRY (cellc5), value[2][5]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc5),cell_width);
    gtk_widget_show (cellc5);

    cellc6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc6), 50);
    g_signal_connect (cellc6, "activate", G_CALLBACK (enter_callback), cellc6);
    gtk_entry_set_text (GTK_ENTRY (cellc6), value[2][6]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc6),cell_width);
    gtk_widget_show (cellc6);

    cellc7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc7), 50);
    g_signal_connect (cellc7, "activate", G_CALLBACK (enter_callback), cellc7);
    gtk_entry_set_text (GTK_ENTRY (cellc7), value[2][7]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc7),cell_width);
    gtk_widget_show (cellc7);

    cellc8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc8), 50);
    g_signal_connect (cellc8, "activate", G_CALLBACK (enter_callback), cellc8);
    gtk_entry_set_text (GTK_ENTRY (cellc8), value[2][8]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc8),cell_width);
    gtk_widget_show (cellc8);

    cellc9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc9), 50);
    g_signal_connect (cellc9, "activate", G_CALLBACK (enter_callback), cellc9);
    gtk_entry_set_text (GTK_ENTRY (cellc9), value[2][9]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc9),cell_width);
    gtk_widget_show (cellc9);

    cellc10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc10), 50);
    g_signal_connect (cellc10, "activate", G_CALLBACK (enter_callback), cellc10);
    gtk_entry_set_text (GTK_ENTRY (cellc10), value[2][10]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc10),cell_width);
    gtk_widget_show (cellc10);

    cellc11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc11), 50);
    g_signal_connect (cellc11, "activate", G_CALLBACK (enter_callback), cellc11);
    gtk_entry_set_text (GTK_ENTRY (cellc11), value[2][11]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc11),cell_width);
    gtk_widget_show (cellc11);

    cellc12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc12), 50);
    g_signal_connect (cellc12, "activate", G_CALLBACK (enter_callback), cellc12);
    gtk_entry_set_text (GTK_ENTRY (cellc12), value[2][12]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc12),cell_width);
    gtk_widget_show (cellc12);

    cellc13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc13), 50);
    g_signal_connect (cellc13, "activate", G_CALLBACK (enter_callback), cellc13);
    gtk_entry_set_text (GTK_ENTRY (cellc13), value[2][13]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc13),cell_width);
    gtk_widget_show (cellc13);

    cellc14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc14), 50);
    g_signal_connect (cellc14, "activate", G_CALLBACK (enter_callback), cellc14);
    gtk_entry_set_text (GTK_ENTRY (cellc14), value[2][14]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc14),cell_width);
    gtk_widget_show (cellc14);

    cellc15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc15), 50);
    g_signal_connect (cellb15, "activate", G_CALLBACK (enter_callback), cellc15);
    gtk_entry_set_text (GTK_ENTRY (cellc15), value[2][15]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc15),cell_width);
    gtk_widget_show (cellc15);

    cellc16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc16), 50);
    g_signal_connect (cellb16, "activate", G_CALLBACK (enter_callback), cellc16);
    gtk_entry_set_text (GTK_ENTRY (cellc16), value[2][16]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc16),cell_width);
    gtk_widget_show (cellc16);

    cellc17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellc17), 50);
    g_signal_connect (cellb17, "activate", G_CALLBACK (enter_callback), cellc17);
    gtk_entry_set_text (GTK_ENTRY (cellc17), value[2][17]);
    gtk_box_pack_start (GTK_BOX (vboxc), cellc17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellc17),cell_width);
    gtk_widget_show (cellc17);

  ///*** column D (col 3)
    labeld = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxd), labeld, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labeld),"D");
    gtk_editable_set_editable(GTK_EDITABLE(labeld),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labeld),cell_width);
    gtk_widget_modify_base(labeld, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labeld);

    celld0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld0), 50);
    g_signal_connect (celld0, "activate", G_CALLBACK (enter_callback), celld0);
    gtk_entry_set_text (GTK_ENTRY (celld0), value[3][0]);
    gtk_box_pack_start (GTK_BOX (vboxd), celld0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld0),cell_width);
    gtk_widget_show (celld0);

    celld1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld1), 50);
    g_signal_connect (celld1, "activate", G_CALLBACK (enter_callback), celld1);
    gtk_entry_set_text (GTK_ENTRY (celld1), value[3][1]);
    gtk_box_pack_start (GTK_BOX (vboxd), celld1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld1),cell_width);
    gtk_widget_show (celld1);

    celld2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld2), 50);
    g_signal_connect (celld2, "activate", G_CALLBACK (enter_callback), celld2);
    gtk_entry_set_text (GTK_ENTRY (celld2), value[3][2]);
    gtk_box_pack_start (GTK_BOX (vboxd), celld2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld2),cell_width);
    gtk_widget_show (celld2);

    celld3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld3), 50);
    g_signal_connect (celld3, "activate", G_CALLBACK (enter_callback), celld3);
    gtk_entry_set_text (GTK_ENTRY (celld3), value[3][3]);
    gtk_box_pack_start (GTK_BOX (vboxd), celld3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld3),cell_width);
    gtk_widget_show (celld3);

    celld4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld4), 50);
    g_signal_connect (celld4, "activate", G_CALLBACK (enter_callback), celld4);
    gtk_entry_set_text (GTK_ENTRY (celld4), value[3][4]);
    gtk_box_pack_start (GTK_BOX (vboxd), celld4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld4),cell_width);
    gtk_widget_show (celld4);

    celld5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld5), 50);
    g_signal_connect (celld5, "activate", G_CALLBACK (enter_callback), celld5);
    gtk_entry_set_text (GTK_ENTRY (celld5), value[3][5]);
    gtk_box_pack_start (GTK_BOX (vboxd), celld5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld5),cell_width);
    gtk_widget_show (celld5);

    celld6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld6), 50);
    g_signal_connect (celld6, "activate", G_CALLBACK (enter_callback), celld6);
    gtk_entry_set_text (GTK_ENTRY (celld6), value[3][6]);
    gtk_box_pack_start (GTK_BOX (vboxd), celld6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld6),cell_width);
    gtk_widget_show (celld6);

    celld7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld7), 50);
    g_signal_connect (celld7, "activate", G_CALLBACK (enter_callback), celld7);
    gtk_box_pack_start (GTK_BOX (vboxd), celld7, TRUE, TRUE, 0);
    gtk_entry_set_text (GTK_ENTRY (celld7), value[3][7]);
    gtk_entry_set_width_chars(GTK_ENTRY(celld7),cell_width);
    gtk_widget_show (celld7);

    celld8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld8), 50);
    g_signal_connect (celld8, "activate", G_CALLBACK (enter_callback), celld8);
    gtk_entry_set_text (GTK_ENTRY (celld8), value[3][8]);
    gtk_box_pack_start (GTK_BOX (vboxd), celld8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld8),cell_width);
    gtk_widget_show (celld8);

    celld9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld9), 50);
    g_signal_connect (celld9, "activate", G_CALLBACK (enter_callback), celld9);
    gtk_entry_set_text (GTK_ENTRY (celld9), value[3][9]);
    gtk_box_pack_start (GTK_BOX (vboxd), celld9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld9),cell_width);
    gtk_widget_show (celld9);

    celld10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld10), 50);
    g_signal_connect (celld10, "activate", G_CALLBACK (enter_callback), celld10);
    gtk_box_pack_start (GTK_BOX (vboxd), celld10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld10),cell_width);
    gtk_widget_show (celld10);

    celld11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld11), 50);
    g_signal_connect (celld11, "activate", G_CALLBACK (enter_callback), celld11);
    gtk_box_pack_start (GTK_BOX (vboxd), celld11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld11),cell_width);
    gtk_widget_show (celld11);

    celld12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld12), 50);
    g_signal_connect (celld12, "activate", G_CALLBACK (enter_callback), celld12);
    gtk_box_pack_start (GTK_BOX (vboxd), celld12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld12),cell_width);
    gtk_widget_show (celld12);

    celld13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld13), 50);
    g_signal_connect (celld13, "activate", G_CALLBACK (enter_callback), celld13);
    gtk_box_pack_start (GTK_BOX (vboxd), celld13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld13),cell_width);
    gtk_widget_show (celld13);

    celld14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld14), 50);
    g_signal_connect (celld14, "activate", G_CALLBACK (enter_callback), celld14);
    gtk_box_pack_start (GTK_BOX (vboxd), celld14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld14),cell_width);
    gtk_widget_show (celld14);

    celld15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld15), 50);
    g_signal_connect (celld15, "activate", G_CALLBACK (enter_callback), celld15);
    gtk_box_pack_start (GTK_BOX (vboxd), celld15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld15),cell_width);
    gtk_widget_show (celld15);

    celld16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld16), 50);
    g_signal_connect (celld16, "activate", G_CALLBACK (enter_callback), celld16);
    gtk_box_pack_start (GTK_BOX (vboxd), celld16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld16),cell_width);
    gtk_widget_show (celld16);

    celld17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld17), 50);
    g_signal_connect (celld17, "activate", G_CALLBACK (enter_callback), celld17);
    gtk_box_pack_start (GTK_BOX (vboxd), celld17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celld17),cell_width);
    gtk_widget_show (celld17);

  ///*** column E
    labele = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxe), labele, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labele),"E");
    gtk_editable_set_editable(GTK_EDITABLE(labele),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labele),cell_width);
    gtk_widget_modify_base(labele, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labele);

    celle0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle0), 50);
    g_signal_connect (celle0, "activate", G_CALLBACK (enter_callback), celle0);
    gtk_entry_set_text (GTK_ENTRY (celle0), value[4][0]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle0),cell_width);
    gtk_widget_show (celle0);

    celle1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle1), 50);
    g_signal_connect (celle1, "activate", G_CALLBACK (enter_callback), celle1);
    gtk_entry_set_text (GTK_ENTRY (celle1), value[4][1]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle1),cell_width);
    gtk_widget_show (celle1);

    celle2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle2), 50);
    g_signal_connect (celle2, "activate", G_CALLBACK (enter_callback), celle2);
    gtk_entry_set_text (GTK_ENTRY (celle2), value[4][2]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle2),cell_width);
    gtk_widget_show (celle2);

    celle3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle3), 50);
    g_signal_connect (celle3, "activate", G_CALLBACK (enter_callback), celle3);
    gtk_entry_set_text (GTK_ENTRY (celle3), value[4][3]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle3),cell_width);
    gtk_widget_show (celle3);

    celle4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle4), 50);
    g_signal_connect (celle4, "activate", G_CALLBACK (enter_callback), celle4);
    gtk_entry_set_text (GTK_ENTRY (celle4), value[4][4]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle4),cell_width);
    gtk_widget_show (celle4);

    celle5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle5), 50);
    g_signal_connect (celle5, "activate", G_CALLBACK (enter_callback), celle5);
    gtk_entry_set_text (GTK_ENTRY (celle5), value[4][5]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle5),cell_width);
    gtk_widget_show (celle5);

    celle6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle6), 50);
    g_signal_connect (celle6, "activate", G_CALLBACK (enter_callback), celle6);
    gtk_entry_set_text (GTK_ENTRY (celle6), value[4][6]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle6),cell_width);
    gtk_widget_show (celle6);

    celle7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle7), 50);
    g_signal_connect (celle7, "activate", G_CALLBACK (enter_callback), celle7);
    gtk_entry_set_text (GTK_ENTRY (celle7), value[4][7]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle7),cell_width);
    gtk_widget_show (celle7);

    celle8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle8), 50);
    g_signal_connect (celle8, "activate", G_CALLBACK (enter_callback), celle8);
    gtk_entry_set_text (GTK_ENTRY (celle8), value[4][8]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle8),cell_width);
    gtk_widget_show (celle8);

    celle9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle9), 50);
    g_signal_connect (celle9, "activate", G_CALLBACK (enter_callback), celle9);
    gtk_entry_set_text (GTK_ENTRY (celle9), value[4][9]);
    gtk_box_pack_start (GTK_BOX (vboxe), celle9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle9),cell_width);
    gtk_widget_show (celle9);

    celle10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld10), 50);
    g_signal_connect (celle10, "activate", G_CALLBACK (enter_callback), celle10);
    gtk_box_pack_start (GTK_BOX (vboxe), celle10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle10),cell_width);
    gtk_widget_show (celle10);

    celle11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celld11), 50);
    g_signal_connect (celle11, "activate", G_CALLBACK (enter_callback), celle11);
    gtk_box_pack_start (GTK_BOX (vboxe), celle11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle11),cell_width);
    gtk_widget_show (celle11);

    celle12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle12), 50);
    g_signal_connect (celle12, "activate", G_CALLBACK (enter_callback), celle12);
    gtk_box_pack_start (GTK_BOX (vboxe), celle12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle12),cell_width);
    gtk_widget_show (celle12);

    celle13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle13), 50);
    g_signal_connect (celle13, "activate", G_CALLBACK (enter_callback), celle13);
    gtk_box_pack_start (GTK_BOX (vboxe), celle13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle13),cell_width);
    gtk_widget_show (celle13);

    celle14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle14), 50);
    g_signal_connect (celle14, "activate", G_CALLBACK (enter_callback), celle14);
    gtk_box_pack_start (GTK_BOX (vboxe), celle14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle14),cell_width);
    gtk_widget_show (celle14);

    celle15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle15), 50);
    g_signal_connect (celle15, "activate", G_CALLBACK (enter_callback), celle15);
    gtk_box_pack_start (GTK_BOX (vboxe), celle15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle15),cell_width);
    gtk_widget_show (celle15);

    celle16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle16), 50);
    g_signal_connect (celle16, "activate", G_CALLBACK (enter_callback), celle16);
    gtk_box_pack_start (GTK_BOX (vboxe), celle16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle16),cell_width);
    gtk_widget_show (celle16);

    celle17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celle17), 50);
    g_signal_connect (celle17, "activate", G_CALLBACK (enter_callback), celle17);
    gtk_box_pack_start (GTK_BOX (vboxe), celle17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celle17),cell_width);
    gtk_widget_show (celle17);


  ///*** column F (col 5)
    labelf = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxf), labelf, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labelf),"F");
    gtk_editable_set_editable(GTK_EDITABLE(labelf),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labelf),cell_width);
    gtk_widget_modify_base(labelf, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labelf);

    cellf0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf0), 50);
    g_signal_connect (cellf0, "activate", G_CALLBACK (enter_callback), cellf0);
    gtk_entry_set_text (GTK_ENTRY (cellf0), value[5][0]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf0),cell_width);
    gtk_widget_show (cellf0);

    cellf1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf1), 50);
    g_signal_connect (cellf1, "activate", G_CALLBACK (enter_callback), cellf1);
    gtk_entry_set_text (GTK_ENTRY (cellf1), value[5][1]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf1),cell_width);
    gtk_widget_show (cellf1);

    cellf2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf2), 50);
    g_signal_connect (cellf2, "activate", G_CALLBACK (enter_callback), cellf2);
    gtk_entry_set_text (GTK_ENTRY (cellf2), value[5][2]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf2),cell_width);
    gtk_widget_show (cellf2);

    cellf3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf3), 50);
    g_signal_connect (cellf3, "activate", G_CALLBACK (enter_callback), cellf3);
    gtk_entry_set_text (GTK_ENTRY (cellf3), value[5][3]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf3),cell_width);
    gtk_widget_show (cellf3);

    cellf4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf4), 50);
    g_signal_connect (cellf4, "activate", G_CALLBACK (enter_callback), cellf4);
    gtk_entry_set_text (GTK_ENTRY (cellf4), value[5][4]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf4),cell_width);
    gtk_widget_show (cellf4);

    cellf5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf5), 50);
    g_signal_connect (cellf5, "activate", G_CALLBACK (enter_callback), cellf5);
    gtk_entry_set_text (GTK_ENTRY (cellf5), value[5][5]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf5),cell_width);
    gtk_widget_show (cellf5);

    cellf6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf6), 50);
    g_signal_connect (cellf6, "activate", G_CALLBACK (enter_callback), cellf6);
    gtk_entry_set_text (GTK_ENTRY (cellf6), value[5][6]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf6),cell_width);
    gtk_widget_show (cellf6);

    cellf7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf7), 50);
    g_signal_connect (cellf7, "activate", G_CALLBACK (enter_callback), cellf7);
    gtk_entry_set_text (GTK_ENTRY (cellf7), value[5][7]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf7),cell_width);
    gtk_widget_show (cellf7);

    cellf8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf8), 50);
    g_signal_connect (cellf8, "activate", G_CALLBACK (enter_callback), cellf8);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf8, TRUE, TRUE, 0);
    gtk_entry_set_text (GTK_ENTRY (cellf8), value[5][8]);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf8),cell_width);
    gtk_widget_show (cellf8);

    cellf9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf9), 50);
    g_signal_connect (cellf9, "activate", G_CALLBACK (enter_callback), cellf9);
    gtk_entry_set_text (GTK_ENTRY (cellf9), value[5][9]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf9),cell_width);
    gtk_widget_show (cellf9);

    cellf10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf10), 50);
    g_signal_connect (cellf10, "activate", G_CALLBACK (enter_callback), cellf10);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf10),cell_width);
    gtk_widget_show (cellf10);

    cellf11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf11), 50);
    g_signal_connect (cellf11, "activate", G_CALLBACK (enter_callback), cellf11);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf11),cell_width);
    gtk_widget_show (cellf11);

    cellf12= gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf12), 50);
    g_signal_connect (cellf12, "activate", G_CALLBACK (enter_callback), cellf12);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf12),cell_width);
    gtk_widget_show (cellf12);

    cellf13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf13), 50);
    g_signal_connect (cellf13, "activate", G_CALLBACK (enter_callback), cellf13);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf13),cell_width);
    gtk_widget_show (cellf13);

    cellf14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf14), 50);
    g_signal_connect (cellf14, "activate", G_CALLBACK (enter_callback), cellf14);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf14),cell_width);
    gtk_widget_show (cellf14);

    cellf15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf15), 50);
    g_signal_connect (cellf15, "activate", G_CALLBACK (enter_callback), cellf15);
    gtk_entry_set_text (GTK_ENTRY (cellf15), value[5][15]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf15),cell_width);
    gtk_widget_show (cellf15);

    cellf16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf16), 50);
    g_signal_connect (cellf16, "activate", G_CALLBACK (enter_callback), cellf16);
    gtk_entry_set_text (GTK_ENTRY (cellf16), value[5][16]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf16),cell_width);
    gtk_widget_show (cellf16);

    cellf17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellf17), 50);
    g_signal_connect (cellf17, "activate", G_CALLBACK (enter_callback), cellf17);
    gtk_entry_set_text (GTK_ENTRY (cellf17), value[5][17]);
    gtk_box_pack_start (GTK_BOX (vboxf), cellf17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellf17),cell_width);
    gtk_widget_show (cellf17);


    ///*** column G (col 6)
    labelg = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxg), labelg, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labelg),"G");
    gtk_editable_set_editable(GTK_EDITABLE(labelg),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labelg),cell_width);
    gtk_widget_modify_base(labelg, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labelg);

    cellg0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg0), 50);
    g_signal_connect (cellg0, "activate", G_CALLBACK (enter_callback), cellg0);
    gtk_entry_set_text (GTK_ENTRY (cellg0), value[6][0]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg0),cell_width);
    gtk_widget_show (cellg0);

    cellg1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg1), 50);
    g_signal_connect (cellg1, "activate", G_CALLBACK (enter_callback), cellg1);
    gtk_entry_set_text (GTK_ENTRY (cellg1), value[6][1]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg1),cell_width);
    gtk_widget_show (cellg1);

    cellg2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg2), 50);
    g_signal_connect (cellg2, "activate", G_CALLBACK (enter_callback), cellg2);
    gtk_entry_set_text (GTK_ENTRY (cellg2), value[6][2]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg2),cell_width);
    gtk_widget_show (cellg2);

    cellg3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg3), 50);
    g_signal_connect (cellg3, "activate", G_CALLBACK (enter_callback), cellg3);
    gtk_entry_set_text (GTK_ENTRY (cellg3), value[6][3]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg3),cell_width);
    gtk_widget_show (cellg3);

    cellg4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg4), 50);
    g_signal_connect (cellg4, "activate", G_CALLBACK (enter_callback), cellg4);
    gtk_entry_set_text (GTK_ENTRY (cellg4), value[6][4]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg4),cell_width);
    gtk_widget_show (cellg4);

    cellg5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg5), 50);
    g_signal_connect (cellg5, "activate", G_CALLBACK (enter_callback), cellg5);
    gtk_entry_set_text (GTK_ENTRY (cellg5), value[6][5]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg5),cell_width);
    gtk_widget_show (cellg5);

    cellg6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg6), 50);
    g_signal_connect (cellg6, "activate", G_CALLBACK (enter_callback), cellg6);
    gtk_entry_set_text (GTK_ENTRY (cellg6), value[6][6]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg6),cell_width);
    gtk_widget_show (cellg6);

    cellg7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg7), 50);
    g_signal_connect (cellg7, "activate", G_CALLBACK (enter_callback), cellg7);
    gtk_entry_set_text (GTK_ENTRY (cellg7), value[6][7]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg7),cell_width);
    gtk_widget_show (cellg7);

    cellg8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg8), 50);
    g_signal_connect (cellg8, "activate", G_CALLBACK (enter_callback), cellg8);
    gtk_entry_set_text (GTK_ENTRY (cellg8), value[6][8]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg8),cell_width);
    gtk_widget_show (cellg8);

    cellg9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg9), 50);
    g_signal_connect (cellg9, "activate", G_CALLBACK (enter_callback), cellg9);
    gtk_entry_set_text (GTK_ENTRY (cellg9), value[6][9]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg9),cell_width);
    gtk_widget_show (cellg9);

    cellg10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg10), 50);
    g_signal_connect (cellg10, "activate", G_CALLBACK (enter_callback), cellg10);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg10),cell_width);
    gtk_widget_show (cellg10);

    cellg11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg11), 50);
    g_signal_connect (cellg11, "activate", G_CALLBACK (enter_callback), cellg11);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg11),cell_width);
    gtk_widget_show (cellg11);

    cellg12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg12), 50);
    g_signal_connect (cellg12, "activate", G_CALLBACK (enter_callback), cellg12);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg12),cell_width);
    gtk_widget_show (cellg12);

    cellg13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg13), 50);
    g_signal_connect (cellg13, "activate", G_CALLBACK (enter_callback), cellg13);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg13),cell_width);
    gtk_widget_show (cellg13);

    cellg14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg14), 50);
    g_signal_connect (cellg14, "activate", G_CALLBACK (enter_callback), cellg14);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg14),cell_width);
    gtk_widget_show (cellg14);

    cellg15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg15), 50);
    g_signal_connect (cellg15, "activate", G_CALLBACK (enter_callback), cellg15);
    gtk_entry_set_text (GTK_ENTRY (cellg15), value[6][15]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg15),cell_width);
    gtk_widget_show (cellg15);

    cellg16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg16), 50);
    g_signal_connect (cellg16, "activate", G_CALLBACK (enter_callback), cellg16);
    gtk_entry_set_text (GTK_ENTRY (cellg16), value[6][16]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg16),cell_width);
    gtk_widget_show (cellg16);

    cellg17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellg17), 50);
    g_signal_connect (cellg17, "activate", G_CALLBACK (enter_callback), cellg17);
    gtk_entry_set_text (GTK_ENTRY (cellg17), value[6][17]);
    gtk_box_pack_start (GTK_BOX (vboxg), cellg17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellg17),cell_width);
    gtk_widget_show (cellg17);


    ///*** column H
    labelh = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxh), labelh, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labelh),"H");
    gtk_editable_set_editable(GTK_EDITABLE(labelh),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labelh),cell_width);
    gtk_widget_modify_base(labelh, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labelh);

    cellh0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh0), 50);
    g_signal_connect (cellh0, "activate", G_CALLBACK (enter_callback), cellh0);
    gtk_entry_set_text (GTK_ENTRY (cellh0), value[7][0]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh0),cell_width);
    gtk_widget_show (cellh0);

    cellh1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh1), 50);
    g_signal_connect (cellh1, "activate", G_CALLBACK (enter_callback), cellh1);
    gtk_entry_set_text (GTK_ENTRY (cellh1), value[7][1]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh1),cell_width);
    gtk_widget_show (cellh1);

    cellh2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh2), 50);
    g_signal_connect (cellh2, "activate", G_CALLBACK (enter_callback), cellh2);
    gtk_entry_set_text (GTK_ENTRY (cellh2), value[7][2]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh2),cell_width);
    gtk_widget_show (cellh2);

    cellh3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh3), 50);
    g_signal_connect (cellh3, "activate", G_CALLBACK (enter_callback), cellh3);
    gtk_entry_set_text (GTK_ENTRY (cellh3), value[7][3]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh3),cell_width);
    gtk_widget_show (cellh3);

    cellh4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh4), 50);
    g_signal_connect (cellh4, "activate", G_CALLBACK (enter_callback), cellh4);
    gtk_entry_set_text (GTK_ENTRY (cellh4), value[7][4]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh4),cell_width);
    gtk_widget_show (cellh4);

    cellh5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh5), 50);
    g_signal_connect (cellh5, "activate", G_CALLBACK (enter_callback), cellh5);
    gtk_entry_set_text (GTK_ENTRY (cellh5), value[7][5]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh5),cell_width);
    gtk_widget_show (cellh5);

    cellh6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh6), 50);
    g_signal_connect (cellh6, "activate", G_CALLBACK (enter_callback), cellh6);
    gtk_entry_set_text (GTK_ENTRY (cellh6), value[7][6]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh6),cell_width);
    gtk_widget_show (cellh6);

    cellh7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh7), 50);
    g_signal_connect (cellh7, "activate", G_CALLBACK (enter_callback), cellh7);
    gtk_entry_set_text (GTK_ENTRY (cellh7), value[7][7]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh7),cell_width);
    gtk_widget_show (cellh7);

    cellh8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh8), 50);
    g_signal_connect (cellh8, "activate", G_CALLBACK (enter_callback), cellh8);
    gtk_entry_set_text (GTK_ENTRY (cellh8), value[7][8]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh8),cell_width);
    gtk_widget_show (cellh8);

    cellh9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh9), 50);
    g_signal_connect (cellh9, "activate", G_CALLBACK (enter_callback), cellh9);
    gtk_entry_set_text (GTK_ENTRY (cellh9), value[7][9]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh9),cell_width);
    gtk_widget_show (cellh9);

    cellh10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh10), 50);
    g_signal_connect (cellh10, "activate", G_CALLBACK (enter_callback), cellh10);
    gtk_entry_set_text (GTK_ENTRY (cellh10), value[7][10]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh10),cell_width);
    gtk_widget_show (cellh10);

    cellh11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh11), 50);
    g_signal_connect (cellh11, "activate", G_CALLBACK (enter_callback), cellh11);
    gtk_entry_set_text (GTK_ENTRY (cellh11), value[7][11]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh11),cell_width);
    gtk_widget_show (cellh11);

    cellh12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh12), 50);
    g_signal_connect (cellh12, "activate", G_CALLBACK (enter_callback), cellh12);
    gtk_entry_set_text (GTK_ENTRY (cellh12), value[7][12]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh12),cell_width);
    gtk_widget_show (cellh12);

    cellh13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh13), 50);
    g_signal_connect (cellh13, "activate", G_CALLBACK (enter_callback), cellh13);
    gtk_entry_set_text (GTK_ENTRY (cellh13), value[7][13]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh13),cell_width);
    gtk_widget_show (cellh13);

    cellh14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh14), 50);
    g_signal_connect (cellh14, "activate", G_CALLBACK (enter_callback), cellh14);
    gtk_entry_set_text (GTK_ENTRY (cellh14), value[7][14]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh14),cell_width);
    gtk_widget_show (cellh14);

    cellh15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh15), 50);
    g_signal_connect (cellh15, "activate", G_CALLBACK (enter_callback), cellh15);
    gtk_entry_set_text (GTK_ENTRY (cellh15), value[9][15]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh15),cell_width);
    gtk_widget_show (cellh15);

    cellh16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh16), 50);
    g_signal_connect (cellh16, "activate", G_CALLBACK (enter_callback), cellh16);
    gtk_entry_set_text (GTK_ENTRY (cellh16), value[9][16]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh16),cell_width);
    gtk_widget_show (cellh16);

    cellh17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellh17), 50);
    g_signal_connect (cellh17, "activate", G_CALLBACK (enter_callback), cellh17);
    gtk_entry_set_text (GTK_ENTRY (cellh17), value[9][17]);
    gtk_box_pack_start (GTK_BOX (vboxh), cellh17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellh17),cell_width);
    gtk_widget_show (cellh17);


 ///*** column I
    labeli = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxi), labeli, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labeli),"I");
    gtk_editable_set_editable(GTK_EDITABLE(labeli),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labeli),cell_width);
    gtk_widget_modify_base(labeli, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labeli);

    celli0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli0), 50);
    g_signal_connect (celli0, "activate", G_CALLBACK (enter_callback), celli0);
    gtk_entry_set_text (GTK_ENTRY (celli0), value[8][0]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli0),cell_width);
    gtk_widget_show (celli0);

    celli1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli1), 50);
    g_signal_connect (celli1, "activate", G_CALLBACK (enter_callback), celli1);
    gtk_entry_set_text (GTK_ENTRY (celli1), value[8][1]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli1),cell_width);
    gtk_widget_show (celli1);

    celli2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli2), 50);
    g_signal_connect (celli2, "activate", G_CALLBACK (enter_callback), celli2);
    gtk_entry_set_text (GTK_ENTRY (celli2), value[8][2]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli2),cell_width);
    gtk_widget_show (celli2);

    celli3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli3), 50);
    g_signal_connect (celli3, "activate", G_CALLBACK (enter_callback), celli3);
    gtk_entry_set_text (GTK_ENTRY (celli3), value[8][3]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli3),cell_width);
    gtk_widget_show (celli3);

    celli4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli4), 50);
    g_signal_connect (celli4, "activate", G_CALLBACK (enter_callback), celli4);
    gtk_entry_set_text (GTK_ENTRY (celli4), value[8][4]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli4),cell_width);
    gtk_widget_show (celli4);

    celli5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli5), 50);
    g_signal_connect (celli5, "activate", G_CALLBACK (enter_callback), celli5);
    gtk_entry_set_text (GTK_ENTRY (celli5), value[8][5]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli5),cell_width);
    gtk_widget_show (celli5);

    celli6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli6), 50);
    g_signal_connect (celli6, "activate", G_CALLBACK (enter_callback), celli6);
    gtk_entry_set_text (GTK_ENTRY (celli6), value[8][6]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli6),cell_width);
    gtk_widget_show (celli6);

    celli7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli7), 50);
    g_signal_connect (celli7, "activate", G_CALLBACK (enter_callback), celli7);
    gtk_entry_set_text (GTK_ENTRY (celli7), value[8][7]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli7),cell_width);
    gtk_widget_show (celli7);

    celli8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli8), 50);
    g_signal_connect (celli8, "activate", G_CALLBACK (enter_callback), celli8);
    gtk_entry_set_text (GTK_ENTRY (celli8), value[8][8]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli8),cell_width);
    gtk_widget_show (celli8);

    celli9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli9), 50);
    g_signal_connect (celli9, "activate", G_CALLBACK (enter_callback), celli9);
    gtk_entry_set_text (GTK_ENTRY (celli9), value[8][9]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli9),cell_width);
    gtk_widget_show (celli9);

    celli10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli10), 50);
    g_signal_connect (celli10, "activate", G_CALLBACK (enter_callback), celli10);
    gtk_entry_set_text (GTK_ENTRY (celli10), value[8][10]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli10),cell_width);
    gtk_widget_show (celli10);

    celli11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli11), 50);
    g_signal_connect (celli11, "activate", G_CALLBACK (enter_callback), celli11);
    gtk_entry_set_text (GTK_ENTRY (celli11), value[8][11]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli11),cell_width);
    gtk_widget_show (celli11);

    celli12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli12), 50);
    g_signal_connect (celli12, "activate", G_CALLBACK (enter_callback), celli12);
    gtk_entry_set_text (GTK_ENTRY (celli12), value[8][12]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli12),cell_width);
    gtk_widget_show (celli12);

    celli13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli13), 50);
    g_signal_connect (celli13, "activate", G_CALLBACK (enter_callback), celli13);
    gtk_entry_set_text (GTK_ENTRY (celli13), value[8][13]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli13),cell_width);
    gtk_widget_show (celli13);

    celli14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli14), 50);
    g_signal_connect (celli14, "activate", G_CALLBACK (enter_callback), celli14);
    gtk_entry_set_text (GTK_ENTRY (celli14), value[8][14]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli14),cell_width);
    gtk_widget_show (celli14);

    celli15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli15), 50);
    g_signal_connect (celli15, "activate", G_CALLBACK (enter_callback), celli15);
    gtk_entry_set_text (GTK_ENTRY (celli15), value[8][15]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli15),cell_width);
    gtk_widget_show (celli15);

    celli16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli16), 50);
    g_signal_connect (celli16, "activate", G_CALLBACK (enter_callback), celli16);
    gtk_entry_set_text (GTK_ENTRY (celli16), value[8][16]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli16),cell_width);
    gtk_widget_show (celli16);

    celli17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celli17), 50);
    g_signal_connect (celli17, "activate", G_CALLBACK (enter_callback), celli17);
    gtk_entry_set_text (GTK_ENTRY (celli17), value[8][17]);
    gtk_box_pack_start (GTK_BOX (vboxi), celli17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celli17),cell_width);
    gtk_widget_show (celli17);

///*** column J
    labelj = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxj), labelj, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labelj),"J");
    gtk_editable_set_editable(GTK_EDITABLE(labelj),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labelj),cell_width);
    gtk_widget_modify_base(labelj, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labelj);

    cellj0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj0), 50);
    g_signal_connect (cellj0, "activate", G_CALLBACK (enter_callback), cellj0);
    gtk_entry_set_text (GTK_ENTRY (cellj0), value[9][0]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj0),cell_width);
    gtk_widget_show (cellj0);

    cellj1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj1), 50);
    g_signal_connect (cellj1, "activate", G_CALLBACK (enter_callback), cellj1);
    gtk_entry_set_text (GTK_ENTRY (cellj1), value[9][1]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj1),cell_width);
    gtk_widget_show (cellj1);

    cellj2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj2), 50);
    g_signal_connect (cellj2, "activate", G_CALLBACK (enter_callback), cellj2);
    gtk_entry_set_text (GTK_ENTRY (cellj2), value[9][2]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj2),cell_width);
    gtk_widget_show (cellj2);

    cellj3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj3), 50);
    g_signal_connect (cellj3, "activate", G_CALLBACK (enter_callback), cellj3);
    gtk_entry_set_text (GTK_ENTRY (cellj3), value[9][3]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj3),cell_width);
    gtk_widget_show (cellj3);

    cellj4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj4), 50);
    g_signal_connect (cellj4, "activate", G_CALLBACK (enter_callback), cellj4);
    gtk_entry_set_text (GTK_ENTRY (cellj4), value[9][4]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj4),cell_width);
    gtk_widget_show (cellj4);

    cellj5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj5), 50);
    g_signal_connect (cellj5, "activate", G_CALLBACK (enter_callback), cellj5);
    gtk_entry_set_text (GTK_ENTRY (cellj5), value[9][5]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj5),cell_width);
    gtk_widget_show (cellj5);

    cellj6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj6), 50);
    g_signal_connect (cellj6, "activate", G_CALLBACK (enter_callback), cellj6);
    gtk_entry_set_text (GTK_ENTRY (cellj6), value[9][6]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj6),cell_width);
    gtk_widget_show (cellj6);

    cellj7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj7), 50);
    g_signal_connect (cellj7, "activate", G_CALLBACK (enter_callback), cellj7);
    gtk_entry_set_text (GTK_ENTRY (cellj7), value[9][7]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj7),cell_width);
    gtk_widget_show (cellj7);

    cellj8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj8), 50);
    g_signal_connect (cellj8, "activate", G_CALLBACK (enter_callback), cellj8);
    gtk_entry_set_text (GTK_ENTRY (cellj8), value[9][8]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj8),cell_width);
    gtk_widget_show (cellj8);

    cellj9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj9), 50);
    g_signal_connect (cellj9, "activate", G_CALLBACK (enter_callback), cellj9);
    gtk_entry_set_text (GTK_ENTRY (cellj9), value[9][9]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj9),cell_width);
    gtk_widget_show (cellj9);

    cellj10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj10), 50);
    g_signal_connect (cellj10, "activate", G_CALLBACK (enter_callback), cellj10);
    gtk_entry_set_text (GTK_ENTRY (cellj10), value[9][10]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj10),cell_width);
    gtk_widget_show (cellj10);

    cellj11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj11), 50);
    g_signal_connect (cellj11, "activate", G_CALLBACK (enter_callback), cellj11);
    gtk_entry_set_text (GTK_ENTRY (cellj11), value[9][11]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj11),cell_width);
    gtk_widget_show (cellj11);

    cellj12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj12), 50);
    g_signal_connect (cellj12, "activate", G_CALLBACK (enter_callback), cellj12);
    gtk_entry_set_text (GTK_ENTRY (cellj12), value[9][12]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj12),cell_width);
    gtk_widget_show (cellj12);

    cellj13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj13), 50);
    g_signal_connect (cellj13, "activate", G_CALLBACK (enter_callback), cellj13);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj13),cell_width);
    gtk_widget_show (cellj13);

    cellj14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj14), 50);
    g_signal_connect (cellj14, "activate", G_CALLBACK (enter_callback), cellj14);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj14),cell_width);
    gtk_widget_show (cellj14);

    cellj15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj15), 50);
    g_signal_connect (cellj15, "activate", G_CALLBACK (enter_callback), cellj15);
    gtk_entry_set_text (GTK_ENTRY (cellj15), value[9][15]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj15),cell_width);
    gtk_widget_show (cellj15);

    cellj16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj16), 50);
    g_signal_connect (cellj16, "activate", G_CALLBACK (enter_callback), cellj16);
    gtk_entry_set_text (GTK_ENTRY (cellj16), value[9][16]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj16),cell_width);
    gtk_widget_show (cellj16);

    cellj17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellj17), 50);
    g_signal_connect (cellj17, "activate", G_CALLBACK (enter_callback), cellj17);
    gtk_entry_set_text (GTK_ENTRY (cellj17), value[9][17]);
    gtk_box_pack_start (GTK_BOX (vboxj), cellj17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellj17),cell_width);
    gtk_widget_show (cellj17);



    ///*** column K
    labelk = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxk), labelk, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labelk),"K");
    gtk_editable_set_editable(GTK_EDITABLE(labelk),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labelk),cell_width);
    gtk_widget_modify_base(labelk, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labelk);

    cellk0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk0), 50);
    g_signal_connect (cellk0, "activate", G_CALLBACK (enter_callback), cellk0);
    gtk_entry_set_text (GTK_ENTRY (cellk0), value[10][0]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk0),cell_width);
    gtk_widget_show (cellk0);

    cellk1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk1), 50);
    g_signal_connect (cellk1, "activate", G_CALLBACK (enter_callback), cellk1);
    gtk_entry_set_text (GTK_ENTRY (cellk1), value[10][1]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk1),cell_width);
    gtk_widget_show (cellk1);

    cellk2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk2), 50);
    g_signal_connect (cellk2, "activate", G_CALLBACK (enter_callback), cellk2);
    gtk_entry_set_text (GTK_ENTRY (cellk2), value[10][2]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk2),cell_width);
    gtk_widget_show (cellk2);

    cellk3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk3), 50);
    g_signal_connect (cellk3, "activate", G_CALLBACK (enter_callback), cellk3);
    gtk_entry_set_text (GTK_ENTRY (cellk3), value[10][3]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk3),cell_width);
    gtk_widget_show (cellk3);

    cellk4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk4), 50);
    g_signal_connect (cellk4, "activate", G_CALLBACK (enter_callback), cellk4);
    gtk_entry_set_text (GTK_ENTRY (cellk4), value[10][4]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk4),cell_width);
    gtk_widget_show (cellk4);

    cellk5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk5), 50);
    g_signal_connect (cellk5, "activate", G_CALLBACK (enter_callback), cellk5);
    gtk_entry_set_text (GTK_ENTRY (cellk5), value[10][5]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk5),cell_width);
    gtk_widget_show (cellk5);

    cellk6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk6), 50);
    g_signal_connect (cellk6, "activate", G_CALLBACK (enter_callback), cellk6);
    gtk_entry_set_text (GTK_ENTRY (cellk6), value[10][6]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk6),cell_width);
    gtk_widget_show (cellk6);

    cellk7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk7), 50);
    g_signal_connect (cellk7, "activate", G_CALLBACK (enter_callback), cellk7);
    gtk_entry_set_text (GTK_ENTRY (cellk7), value[10][7]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk7),cell_width);
    gtk_widget_show (cellk7);

    cellk8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk8), 50);
    g_signal_connect (cellk8, "activate", G_CALLBACK (enter_callback), cellk8);
    gtk_entry_set_text (GTK_ENTRY (cellk8), value[10][8]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk8),cell_width);
    gtk_widget_show (cellk8);

    cellk9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk9), 50);
    g_signal_connect (cellk9, "activate", G_CALLBACK (enter_callback), cellk9);
    gtk_entry_set_text (GTK_ENTRY (cellk9), value[10][9]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk9),cell_width);
    gtk_widget_show (cellk9);

    cellk10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk10), 50);
    g_signal_connect (cellk10, "activate", G_CALLBACK (enter_callback), cellk10);
    gtk_entry_set_text (GTK_ENTRY (cellk10), value[10][10]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk10),cell_width);
    gtk_widget_show (cellk10);

    cellk11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk11), 50);
    g_signal_connect (cellk11, "activate", G_CALLBACK (enter_callback), cellk11);
    gtk_entry_set_text (GTK_ENTRY (cellk11), value[10][11]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk11),cell_width);
    gtk_widget_show (cellk11);

    cellk12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk12), 50);
    g_signal_connect (cellk12, "activate", G_CALLBACK (enter_callback), cellk12);
    gtk_entry_set_text (GTK_ENTRY (cellk12), value[10][12]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk12),cell_width);
    gtk_widget_show (cellk12);

    cellk13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk13), 50);
    g_signal_connect (cellk13, "activate", G_CALLBACK (enter_callback), cellk13);
    gtk_entry_set_text (GTK_ENTRY (cellk13), value[10][13]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk13),cell_width);
    gtk_widget_show (cellk13);

    cellk14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk14), 50);
    g_signal_connect (cellk14, "activate", G_CALLBACK (enter_callback), cellk14);
    gtk_entry_set_text (GTK_ENTRY (cellk14), value[10][14]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk14),cell_width);
    gtk_widget_show (cellk14);

    cellk15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk15), 50);
    g_signal_connect (cellk15, "activate", G_CALLBACK (enter_callback), cellk15);
    gtk_entry_set_text (GTK_ENTRY (cellk15), value[10][15]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk15),cell_width);
    gtk_widget_show (cellk15);

    cellk16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk16), 50);
    g_signal_connect (cellk16, "activate", G_CALLBACK (enter_callback), cellk16);
    gtk_entry_set_text (GTK_ENTRY (cellk16), value[10][16]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk16),cell_width);
    gtk_widget_show (cellk16);

    cellk17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk17), 50);
    g_signal_connect (cellk17, "activate", G_CALLBACK (enter_callback), cellk17);
    gtk_entry_set_text (GTK_ENTRY (cellk17), value[10][17]);
    gtk_box_pack_start (GTK_BOX (vboxk), cellk17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(cellk17),cell_width);
    gtk_widget_show (cellk17);


///--------
    ///*** column L
    labell = gtk_entry_new ();
    gtk_box_pack_start (GTK_BOX (vboxl), labell, TRUE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(labell),"L");
    gtk_editable_set_editable(GTK_EDITABLE(labell),FALSE);
    gtk_entry_set_width_chars(GTK_ENTRY(labell),cell_width);
    gtk_widget_modify_base(labell, GTK_STATE_NORMAL, &colorGrey);
    gtk_widget_show (labell);


    celll0 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celll0), 50);
    g_signal_connect (cellk2, "activate", G_CALLBACK (enter_callback), celll0);
    gtk_entry_set_text (GTK_ENTRY (celll0), value[11][0]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll0, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll0),cell_width);
    gtk_widget_show (celll0);

    celll1 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celll1), 50);
    g_signal_connect (celll1, "activate", G_CALLBACK (enter_callback), celll1);
    gtk_entry_set_text (GTK_ENTRY (celll1), value[11][1]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll1, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll1),cell_width);
    gtk_widget_show (celll1);


    celll2 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (celll2), 50);
    g_signal_connect (celll2, "activate", G_CALLBACK (enter_callback), celll2);
    gtk_entry_set_text (GTK_ENTRY (celll2), value[11][2]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll2, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll2),cell_width);
    gtk_widget_show (celll2);

    celll3 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk3), 50);
    g_signal_connect (celll3, "activate", G_CALLBACK (enter_callback), celll3);
    gtk_entry_set_text (GTK_ENTRY (celll3), value[11][3]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll3, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll3),cell_width);
    gtk_widget_show (celll3);

    celll4 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk4), 50);
    g_signal_connect (celll4, "activate", G_CALLBACK (enter_callback), celll4);
    gtk_entry_set_text (GTK_ENTRY (celll4), value[11][4]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll4, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll4),cell_width);
    gtk_widget_show (celll4);

    celll5 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk5), 50);
    g_signal_connect (celll5, "activate", G_CALLBACK (enter_callback), celll5);
    gtk_entry_set_text (GTK_ENTRY (celll5), value[11][5]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll5, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll5),cell_width);
    gtk_widget_show (celll5);

    celll6 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk6), 50);
    g_signal_connect (celll6, "activate", G_CALLBACK (enter_callback), celll6);
    gtk_entry_set_text (GTK_ENTRY (celll6), value[11][6]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll6, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll6),cell_width);
    gtk_widget_show (celll6);

    celll7 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk7), 50);
    g_signal_connect (celll7, "activate", G_CALLBACK (enter_callback), celll7);
    gtk_entry_set_text (GTK_ENTRY (celll7), value[11][7]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll7, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll7),cell_width);
    gtk_widget_show (celll7);

    celll8 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk8), 50);
    g_signal_connect (celll8, "activate", G_CALLBACK (enter_callback), celll8);
    gtk_entry_set_text (GTK_ENTRY (celll8), value[11][8]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll8, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll8),cell_width);
    gtk_widget_show (celll8);

    celll9 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk9), 50);
    g_signal_connect (celll9, "activate", G_CALLBACK (enter_callback), celll9);
    gtk_entry_set_text (GTK_ENTRY (celll9), value[11][9]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll9, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll9),cell_width);
    gtk_widget_show (celll9);

    celll10 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk10), 50);
    g_signal_connect (celll10, "activate", G_CALLBACK (enter_callback), celll10);
    gtk_entry_set_text (GTK_ENTRY (celll10), value[11][10]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll10, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll10),cell_width);
    gtk_widget_show (celll10);

    celll11 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk11), 50);
    g_signal_connect (celll11, "activate", G_CALLBACK (enter_callback), celll11);
    gtk_entry_set_text (GTK_ENTRY (celll11), value[11][11]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll11, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll11),cell_width);
    gtk_widget_show (celll11);

    celll12 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk12), 50);
    g_signal_connect (celll12, "activate", G_CALLBACK (enter_callback), celll12);
    gtk_entry_set_text (GTK_ENTRY (celll12), value[11][12]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll12, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll12),cell_width);
    gtk_widget_show (celll12);

    celll13 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk13), 50);
    g_signal_connect (celll13, "activate", G_CALLBACK (enter_callback), celll13);
    gtk_entry_set_text (GTK_ENTRY (celll13), value[11][13]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll13, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll13),cell_width);
    gtk_widget_show (celll13);

    celll14 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk14), 50);
    g_signal_connect (celll14, "activate", G_CALLBACK (enter_callback), celll14);
    gtk_entry_set_text (GTK_ENTRY (celll14), value[11][14]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll14, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll14),cell_width);
    gtk_widget_show (celll14);

    celll15 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk15), 50);
    g_signal_connect (celll15, "activate", G_CALLBACK (enter_callback), celll15);
    gtk_entry_set_text (GTK_ENTRY (celll15), value[11][15]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll15, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll15),cell_width);
    gtk_widget_show (celll15);

    celll16 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk16), 50);
    g_signal_connect (celll16, "activate", G_CALLBACK (enter_callback), celll16);
    gtk_entry_set_text (GTK_ENTRY (celll16), value[11][16]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll16, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll16),cell_width);
    gtk_widget_show (celll16);

    celll17 = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (cellk17), 50);
    g_signal_connect (celll17, "activate", G_CALLBACK (enter_callback), celll17);
    gtk_entry_set_text (GTK_ENTRY (celll17), value[11][17]);
    gtk_box_pack_start (GTK_BOX (vboxl), celll17, TRUE, TRUE, 0);
    gtk_entry_set_width_chars(GTK_ENTRY(celll17),cell_width);
    gtk_widget_show (celll17);



    gtk_widget_show (hbox);
                                  
    gtk_widget_show (window);

    gtk_main();

    return 0;
}