edit_gtk.c

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

/* Classic Ladder Project */
/* Copyright (C) 2001 Marc Le Douarain */
/* [e-mail] */
/* http://www.multimania.com/mavati/classicladder */
/* May 2001 */
/* Last update : 21 January 2002 */
/* --------------------------- */
/* Editor - GTK interface part */
/* --------------------------- */
/* This library is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU Lesser General Public */
/* License as published by the Free Software Foundation; either */
/* version 2.1 of the License, or (at your option) any later version. */

/* This library is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU */
/* Lesser General Public License for more details. */

/* You should have received a copy of the GNU Lesser General Public */
/* License along with this library; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#include <gtk/gtk.h>
#include <stdio.h>
#include "classicladder.h"
#include "global.h"
#include "drawing.h"
#include "edit.h"
#include "classicladder_gtk.h"
#include "edit_gtk.h"

static GdkPixmap *EditorPixmap = NULL;
GtkWidget *EditorDrawingArea;
GtkWidget *EditorButtonValid,*EditorButtonCancel;
GtkWidget *EditorButtonAdd,*EditorButtonIns,*EditorButtonDel;
GtkWidget *EditorButtonModify;
#define NBR_ELE_TOOLBAR_Y 9
static short int ToolBarElements[NBR_ELE_TOOLBAR_Y+1][2] =
            { {ELE_INPUT , ELE_INPUT_NOT} ,
              {ELE_RISING_INPUT , ELE_FALLING_INPUT} ,
              {ELE_CONNECTION , EDIT_CNX_WITH_TOP} ,
              {EDIT_LONG_CONNECTION , ELE_COMPAR} ,
              {ELE_TIMER , ELE_MONOSTABLE} ,
              {ELE_OUTPUT , ELE_OUTPUT_NOT} ,
              {ELE_OUTPUT_SET , ELE_OUTPUT_RESET} ,
              {ELE_OUTPUT_JUMP, ELE_OUTPUT_OPERATE} ,
              {0 , EDIT_POINTER} ,
              {-1,-1}/*end*/ };
static short int ToolBarYMaxi = 0;

/* Draw the tool bar of elements */
void DrawToolBarElements()
{
    StrElement ToolBarEle;
    int ToolBarX,ToolBarY;
    ToolBarX = 0;
    ToolBarY = 0;
    do
    {
        ToolBarYMaxi = ToolBarY;
        ToolBarEle.Type = ToolBarElements[ToolBarY][ToolBarX];
        ToolBarEle.ConnectedWithTop = 0;
        DrawElement(EditorPixmap,ToolBarX*(BLOCK_WIDTH_DEF+2) +2 , ToolBarY*(BLOCK_HEIGHT_DEF+2) +2,
                    BLOCK_WIDTH_DEF, BLOCK_HEIGHT_DEF, ToolBarEle, TRUE);
        ToolBarX++;
        if (ToolBarX>1)
        {
            ToolBarX = 0;
            ToolBarY++;
        }
    }
    while( ToolBarElements[ToolBarY][ToolBarX]!=-1 );
}

/* Create a new backing pixmap of the appropriate size */
static gint EditorConfigureEvent( GtkWidget         *widget,
                            GdkEventConfigure *event )
{
    if (EditorPixmap)
        gdk_pixmap_unref(EditorPixmap);

    EditorPixmap = gdk_pixmap_new(widget->window,
                            widget->allocation.width,
                            widget->allocation.height,
                            -1);
    gdk_draw_rectangle (EditorPixmap,
                        widget->style->white_gc,
                        TRUE,
                        0, 0,
                        widget->allocation.width,
                        widget->allocation.height);
    DrawToolBarElements();
    return TRUE;
}

/* Redraw the screen from the backing pixmap */
static gint EditorExposeEvent( GtkWidget      *widget,
                        GdkEventExpose *event )
{
    gdk_draw_pixmap(widget->window,
                    widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                    EditorPixmap,
                    event->area.x, event->area.y,
                    event->area.x, event->area.y,
                    event->area.width, event->area.height);

    return FALSE;
}


/* Draw a rectangle on the screen */
static void draw_brush( GtkWidget *widget,
                        gdouble    x,
                        gdouble    y,
                        GdkGC * color)
{
    GdkRectangle update_rect;

    update_rect.x = x;
    update_rect.y = y;
    update_rect.width = BLOCK_WIDTH_DEF+1;
    update_rect.height = BLOCK_HEIGHT_DEF+1;
    gdk_draw_rectangle (EditorPixmap,
                        color,
                        FALSE,
                        update_rect.x, update_rect.y,
                        update_rect.width-1, update_rect.height-1);
    gtk_widget_draw (widget, &update_rect);
}


static gint EditorSelectElement( GtkWidget      *widget,
                                GdkEventButton *event )
{
    static int ToolBarX = -1;
    static int ToolBarY = -1;
    if (EditDatas.ModeEdit)
    {
        if (event->button == 1 && pixmap != NULL)
        {
            if ( (ToolBarX!=-1) && (ToolBarY!=-1) )
                draw_brush (widget, ToolBarX*(BLOCK_WIDTH_DEF+2) +2, ToolBarY*(BLOCK_HEIGHT_DEF+2) +2, widget->style->white_gc);
            ToolBarX = event->x/BLOCK_WIDTH_DEF;
            ToolBarY = event->y/BLOCK_HEIGHT_DEF;
            if (ToolBarX>1)
                ToolBarX = 1;
            draw_brush (widget, ToolBarX*(BLOCK_WIDTH_DEF+2) +2, ToolBarY*(BLOCK_HEIGHT_DEF+2) +2, widget->style->black_gc);
            if (ToolBarY<=ToolBarYMaxi)
                EditDatas.NumElementSelectedInToolBar = ToolBarElements[ToolBarY][ToolBarX];
            else
                EditDatas.NumElementSelectedInToolBar = ELE_FREE;
        }
    }
    return TRUE;
}


void ButtonsForStart()
{
    gtk_widget_hide (EditorButtonAdd);
    gtk_widget_hide (EditorButtonIns);
    gtk_widget_hide (EditorButtonDel);
    gtk_widget_hide (EditorButtonModify);
    gtk_widget_show (EditorButtonValid);
    gtk_widget_show (EditorButtonCancel);
}
void ButtonsForEnd()
{
    gtk_widget_show (EditorButtonAdd);
    gtk_widget_show (EditorButtonIns);
    gtk_widget_show (EditorButtonDel);
    gtk_widget_show (EditorButtonModify);
    gtk_widget_hide (EditorButtonValid);
    gtk_widget_hide (EditorButtonCancel);
}

void ButtonAddRung()
{
    AddRung();
    ButtonsForStart();
}
void ButtonInsertRung()
{
    InsertRung();
    ButtonsForStart();
}
void ButtonDeleteCurrentRung()
{
    ShowConfirmationBox("Delete","Do you really want to delete the current rung ?",DeleteCurrentRung);
}
void ButtonModifyCurrentRung()
{
    ModifyCurrentRung();
    ButtonsForStart();
}
void ButtonValidCurrentRung()
{
    ApplyRungEdited();
    ButtonsForEnd();
}
void ButtonCancelCurrentRung()
{
    CancelRungEdited();
    ButtonsForEnd();
}


void EditorInitGtk()
{
    GtkWidget *EditWindow;
    GtkWidget *vbox;

    EditWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title ((GtkWindow *)EditWindow, "Editor");

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

    EditorButtonAdd = gtk_button_new_with_label ("Add");
    gtk_box_pack_start (GTK_BOX (vbox), EditorButtonAdd, FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT (EditorButtonAdd), "clicked",
                        (GtkSignalFunc) ButtonAddRung, 0);
    gtk_widget_show (EditorButtonAdd);
    EditorButtonIns = gtk_button_new_with_label ("Insert");
    gtk_box_pack_start (GTK_BOX (vbox), EditorButtonIns, FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT (EditorButtonIns), "clicked",
                        (GtkSignalFunc) ButtonInsertRung, 0);
    gtk_widget_show (EditorButtonIns);
    EditorButtonDel = gtk_button_new_with_label ("Delete");
    gtk_box_pack_start (GTK_BOX (vbox), EditorButtonDel, FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT (EditorButtonDel), "clicked",
                        (GtkSignalFunc) ButtonDeleteCurrentRung, 0);
    gtk_widget_show (EditorButtonDel);
    EditorButtonModify = gtk_button_new_with_label ("Modify");
    gtk_box_pack_start (GTK_BOX (vbox), EditorButtonModify, FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT (EditorButtonModify), "clicked",
                        (GtkSignalFunc) ButtonModifyCurrentRung, 0);
    gtk_widget_show (EditorButtonModify);
    EditorButtonValid = gtk_button_new_with_label ("Valid.");
    gtk_box_pack_start (GTK_BOX (vbox), EditorButtonValid, FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT (EditorButtonValid), "clicked",
                        (GtkSignalFunc) ButtonValidCurrentRung, 0);
    EditorButtonCancel = gtk_button_new_with_label ("Cancel");
    gtk_box_pack_start (GTK_BOX (vbox), EditorButtonCancel, FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT (EditorButtonCancel), "clicked",
                        (GtkSignalFunc) ButtonCancelCurrentRung, 0);

    /* Create the drawing area */
    EditorDrawingArea = gtk_drawing_area_new ();
    gtk_drawing_area_size (GTK_DRAWING_AREA (EditorDrawingArea) ,
                            (BLOCK_WIDTH_DEF+2)*2 + 2 ,
                            (BLOCK_HEIGHT_DEF+2)*NBR_ELE_TOOLBAR_Y + 2);
    gtk_box_pack_start (GTK_BOX (vbox), EditorDrawingArea, TRUE, TRUE, 0);
    gtk_widget_show (EditorDrawingArea);

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

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

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

    gtk_widget_show (EditWindow);

    EditDatas.NumElementSelectedInToolBar = -1;
}