classicladder_gtk.c

电路仿真程序 Classic Ladder is coded 100％ in C.It can be used for educational purposes or anything you wan

{
    /* From the example in gtkdialog help */
    GtkWidget *dialog, *label, *okay_button;
    /* Create the widgets */
    dialog = gtk_dialog_new();
    label = gtk_label_new (text);
    okay_button = gtk_button_new_with_label(button);
    /* Ensure that the dialog box is destroyed when the user clicks ok. */
    gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
                               GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT(dialog));
    gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
                       okay_button);
    gtk_widget_grab_focus(okay_button);
    /* Add the label, and show everything we've added to the dialog. */
    gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
                       label);
    gtk_window_set_modal(GTK_WINDOW(dialog),TRUE);
    gtk_window_set_title(GTK_WINDOW(dialog),title);
    gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_CENTER);
    gtk_widget_show_all (dialog);
}

void DoFunctionOfConfirmationBox(void * (*function_to_do)(void *))
{
    gtk_widget_destroy(ConfirmDialog);
    (function_to_do)(NULL);
}
void ShowConfirmationBox(char * title,char * text,void * function_if_yes)
{
    /* From the example in gtkdialog help */
    GtkWidget *label, *yes_button, *no_button;
    /* Create the widgets */
    ConfirmDialog = gtk_dialog_new();
    label = gtk_label_new (text);
    yes_button = gtk_button_new_with_label("Yes");
    no_button = gtk_button_new_with_label("No");
    /* Ensure that the dialog box is destroyed when the user clicks ok. */
    gtk_signal_connect_object (GTK_OBJECT (no_button), "clicked",
                               GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT(ConfirmDialog));
    gtk_signal_connect_object (GTK_OBJECT (yes_button), "clicked",
                               GTK_SIGNAL_FUNC (DoFunctionOfConfirmationBox), function_if_yes);
    gtk_container_add (GTK_CONTAINER (GTK_DIALOG(ConfirmDialog)->action_area),
                       yes_button);
    gtk_container_add (GTK_CONTAINER (GTK_DIALOG(ConfirmDialog)->action_area),
                       no_button);
    gtk_widget_grab_focus(no_button);
    /* Add the label, and show everything we've added to the dialog. */
    gtk_container_add (GTK_CONTAINER (GTK_DIALOG(ConfirmDialog)->vbox),
                       label);
    gtk_window_set_modal(GTK_WINDOW(ConfirmDialog),TRUE);
    gtk_window_set_title(GTK_WINDOW(ConfirmDialog),title);
    gtk_window_set_position(GTK_WINDOW(ConfirmDialog),GTK_WIN_POS_CENTER);
    gtk_widget_show_all (ConfirmDialog);
}

void RungWindowInitGtk()
{
    GtkWidget *window;
    GtkWidget *vbox,*hboxtop,*hboxbottom;
    GtkWidget *ButtonQuit;
    GtkWidget *ButtonNew,*ButtonLoad,*ButtonSave,*ButtonSaveAs,*ButtonAbout;

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title ((GtkWindow *)window, "Rung Display");

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

    gtk_signal_connect (GTK_OBJECT (window), "destroy",
                        GTK_SIGNAL_FUNC (quit_appli), NULL);
    hboxtop = gtk_hbox_new (FALSE,0);
    gtk_container_add (GTK_CONTAINER (vbox), hboxtop);
    gtk_widget_show(hboxtop);
    gtk_box_set_child_packing(GTK_BOX(vbox), hboxtop,
        /*expand*/ FALSE, /*fill*/ FALSE, /*pad*/ 0, GTK_PACK_START);

    entrylabel = gtk_entry_new();
    gtk_widget_set_usize((GtkWidget *)entrylabel,80,0);
    gtk_entry_set_max_length((GtkEntry *)entrylabel,LGT_LABEL-1);
    gtk_entry_prepend_text((GtkEntry *)entrylabel,"");
    gtk_box_pack_start (GTK_BOX (hboxtop), entrylabel, FALSE, FALSE, 0);
    gtk_widget_show(entrylabel);
    entrycomment = gtk_entry_new();
    gtk_entry_set_max_length((GtkEntry *)entrycomment,LGT_COMMENT-1);
    gtk_entry_prepend_text((GtkEntry *)entrylabel,"");
    gtk_box_pack_start (GTK_BOX (hboxtop), entrycomment, FALSE, FALSE, 0);
    gtk_widget_show(entrycomment);

    ButtonPrev = gtk_button_new_with_label ("Prev");
    gtk_box_pack_start (GTK_BOX (hboxtop), ButtonPrev, FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT (ButtonPrev), "clicked",
                        (GtkSignalFunc) ButtonPrev_click, 0);
    gtk_widget_show (ButtonPrev);
    ButtonNext = gtk_button_new_with_label ("Next");
    gtk_box_pack_start (GTK_BOX (hboxtop), ButtonNext, FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT (ButtonNext), "clicked",
                        (GtkSignalFunc) ButtonNext_click, 0);
    gtk_widget_show (ButtonNext);

    /* Create the drawing area */
    drawing_area = gtk_drawing_area_new ();
    gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area) ,
                            BLOCK_WIDTH_DEF*RUNG_WIDTH+OFFSET_X+5 ,
                            BLOCK_HEIGHT_DEF*RUNG_HEIGHT+OFFSET_Y);
    gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
    gtk_widget_show (drawing_area);

    hboxbottom = gtk_hbox_new (FALSE,0);
    gtk_container_add (GTK_CONTAINER (vbox), hboxbottom);
    gtk_widget_show(hboxbottom);
    gtk_box_set_child_packing(GTK_BOX(vbox), hboxbottom,
        /*expand*/ FALSE, /*fill*/ FALSE, /*pad*/ 0, GTK_PACK_START);

    ButtonNew = gtk_button_new_with_label ("New");
    gtk_box_pack_start (GTK_BOX (hboxbottom), ButtonNew, TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (ButtonNew), "clicked",
                        (GtkSignalFunc) ButtonNew_click, 0);
    gtk_widget_show (ButtonNew);
    ButtonLoad = gtk_button_new_with_label ("Load");
    gtk_box_pack_start (GTK_BOX (hboxbottom), ButtonLoad, TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (ButtonLoad), "clicked",
                        (GtkSignalFunc) ButtonLoad_click, 0);
    gtk_widget_show (ButtonLoad);
    ButtonSave = gtk_button_new_with_label ("Save");
    gtk_box_pack_start (GTK_BOX (hboxbottom), ButtonSave, TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (ButtonSave), "clicked",
                        (GtkSignalFunc) ButtonSave_click, 0);
    gtk_widget_show (ButtonSave);
    ButtonSaveAs = gtk_button_new_with_label ("Save As");
    gtk_box_pack_start (GTK_BOX (hboxbottom), ButtonSaveAs, TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (ButtonSaveAs), "clicked",
                        (GtkSignalFunc) ButtonSaveAs_click, 0);
    gtk_widget_show (ButtonSaveAs);
    ButtonRunStop = gtk_button_new_with_label ("Stop");
    gtk_box_pack_start (GTK_BOX (hboxbottom), ButtonRunStop, TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (ButtonRunStop), "clicked",
                        (GtkSignalFunc) ButtonRunStop_click, 0);
    gtk_widget_show (ButtonRunStop);
    ButtonAbout = gtk_button_new_with_label ("About");
    gtk_box_pack_start (GTK_BOX (hboxbottom), ButtonAbout, TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (ButtonAbout), "clicked",
                        (GtkSignalFunc) ButtonAbout_click, 0);
    gtk_widget_show (ButtonAbout);
    ButtonQuit = gtk_button_new_with_label ("Quit");
    gtk_box_pack_start (GTK_BOX (hboxbottom), ButtonQuit, TRUE, TRUE, 0);
    gtk_signal_connect_object (GTK_OBJECT (ButtonQuit), "clicked",
                                GTK_SIGNAL_FUNC (gtk_widget_destroy),
                                GTK_OBJECT (window));
    gtk_widget_show (ButtonQuit);


    /* Signals used to handle backing pixmap */
    gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
                        (GtkSignalFunc) expose_event, NULL);
    gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
                        (GtkSignalFunc) configure_event, NULL);

    /* Event signals */
    gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
                        (GtkSignalFunc) button_press_event, NULL);

    gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
                            | GDK_LEAVE_NOTIFY_MASK
                            | GDK_BUTTON_PRESS_MASK
                            | GDK_POINTER_MOTION_MASK
                            | GDK_POINTER_MOTION_HINT_MASK);

    gtk_widget_show (window);
}

void VarsWindowInitGtk()
{
    GtkWidget *windowvars;
    GtkWidget *vboxvars,*vboxvars2,*hboxvars;
    int NumVar,ColumnVar,NumVarSpy;

    windowvars = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title ((GtkWindow *)windowvars, "Vars");
    hboxvars = gtk_hbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (windowvars), hboxvars);
    gtk_widget_show (hboxvars);
    vboxvars = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hboxvars), vboxvars);
    vboxvars2 = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (hboxvars), vboxvars2);
    gtk_widget_show (vboxvars);
    gtk_widget_show (vboxvars2);

    /* 2x20 Vars Bits + 3x Spy of any vars */
    NumVar = 0;
    NumVarSpy = 0;
    for(ColumnVar=0; ColumnVar<2; ColumnVar++)
    {
        int OffVar;
        for(OffVar=0; OffVar<23; OffVar++)
        {
            if (OffVar<20)
            {
                char BufNumVar[20];
                sprintf(BufNumVar,"Bit %d",NumVar);
                chkvar[NumVar] = gtk_check_button_new_with_label(BufNumVar);
                gtk_box_pack_start ((ColumnVar==0)?GTK_BOX (vboxvars):GTK_BOX (vboxvars2), chkvar[NumVar], FALSE, FALSE, 0);
                gtk_widget_show(chkvar[NumVar]);
                gtk_signal_connect(GTK_OBJECT (chkvar[NumVar]), "toggled",
                                    (GtkSignalFunc) chkvar_press_event, (void*)NumVar);
                NumVar++;
            }
            else
            {
                int NumEntry = OffVar-20 + ((ColumnVar==1)?3:0);
                EntryVarSpy[NumEntry] = gtk_entry_new();
                gtk_widget_set_usize((GtkWidget *)EntryVarSpy[NumEntry],30,0);
                gtk_box_pack_start ((ColumnVar==0)?GTK_BOX (vboxvars):GTK_BOX (vboxvars2), EntryVarSpy[NumEntry], FALSE, FALSE, 0);
                gtk_widget_show(EntryVarSpy[NumEntry]);
                if (ColumnVar==0)
                {
                    gtk_entry_set_text((GtkEntry *)EntryVarSpy[NumEntry],DisplayInfo(VarSpy[NumEntry][0],VarSpy[NumEntry][1]));
                    gtk_signal_connect(GTK_OBJECT (EntryVarSpy[NumEntry]), "activate",
                                        (GtkSignalFunc) EntryVarSpy_activate_event, &VarSpy[NumEntry][0]);
                }
                NumVarSpy++;
            }
        }
    }
    gtk_widget_show (windowvars);
}

void DisplayVarSpy()
{
    int NumEntry;
    int Value;
    char BufferValue[30];
    for (NumEntry=0; NumEntry<3; NumEntry++)
    {
        Value = ReadVar(VarSpy[NumEntry][0],VarSpy[NumEntry][1]);
        sprintf(BufferValue,"%d",Value);
        gtk_entry_set_text((GtkEntry *)EntryVarSpy[NumEntry+3],BufferValue);
    }
}


void RefreshAllVarBits()
{
    int NumVar;
    for (NumVar=0; NumVar<40; NumVar++)
    {
        gtk_toggle_button_set_active( (GtkToggleButton *)chkvar[NumVar], ReadVar(VAR_MEM_BIT,NumVar)?TRUE:FALSE );
    }
}

void quit_appli()
{
    InfosGene->LadderState = STATE_LOADING;
    ClassicLadderFreeAll();

    gtk_exit (0);
}

static gint cyclic_refresh(gpointer data)
{
    if (InfosGene->LadderState==STATE_RUN)
    {
#ifndef RTLINUX_SUPPORT
        RefreshAllRungs();
#endif
        if (InfosGene->CmdRefreshVarsBits)
        {
            RefreshAllVarBits();
            InfosGene->CmdRefreshVarsBits = FALSE;
        }
        DisplayVarSpy();
    }
//    DumpRung(&RungArray[0]);
    if (InfosGene->LadderState!=STATE_LOADING)
    {
        if (!EditDatas.ModeEdit)
            DrawRung(&RungArray[InfosGene->CurrentRung],FALSE);
        else
            DrawRung(&EditDatas.Rung,TRUE);
    }
    return 1;
}

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

        gtk_init (&argc, &argv);

        RungWindowInitGtk();
        VarsWindowInitGtk();
        EditorInitGtk();
        PropertiesInitGtk();

        LoadAllLadderDatas(LadderDirectory, argc, argv);
        DrawRung(&RungArray[InfosGene->CurrentRung],TRUE);
        refresh_label_comment(&RungArray[InfosGene->CurrentRung]);

#ifndef RTLINUX_SUPPORT
        printf("Init. cyclic refresh of rungs with GTK timer !\n");
#endif
        gtk_timeout_add(TIME_REFRESH_RUNG_MS,cyclic_refresh,NULL);

        InfosGene->LadderState = STATE_RUN;

        gtk_main();

    }
    else
    {
        ClassicLadderFreeAll();
    }

    return 0;
}