add_function_dlg.cpp

graph是一款linux/unix下绘制数据曲线图形的程序

/*
 * add_function_dlg.cpp - диалог добавления функции, и вообще,
 * все что с этим связано. 
 * Copyright (C) 2007 lester
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 * 
 */

#include "add_function_dlg.h"
#include "tree_view.h"
#include "function.h"
#include "mathdrawer.h"
#include <iostream>
#include <string>

enum
{
    COLOR_NAME,
    COLOR_PIXBUF,
    NUM_CELLS
};

struct _color
{
    gchar *mglcolor;
    gchar *name;
    guint32 clr;
} colors[] = {
    { "k", _("Чёрный") , 0x000000 },
    { "r", _("Красный"), 0xFF3737 },
    { "R", _("Тёмно красный"), 0x800000 },
    { "g", _("Зелёный"), 0x3FFF3F },
    { "G", _("Темно зелёный"), 0x4FA74F },
    { "b", _("Синий"),  0x3737FF },
    { "B", _("Тёмно синий"), 0x4F4FA7 },
    { "c", _("Голубой"), 0x65FFFF },
    { "C", _("Тёмно голубой"), 0x4FA7A7 },
    { "m", _("Пурпурный"), 0xFF96FF },
    { "M", _("Тёмно пурпурный"), 0x912291 },
    { "y", _("Жёлтый"), 0xFFFF4F },
    { "Y", _("Тёмно жёлтый (золотой)"), 0xA7A74F },
    { "h", _("Серый"), 0xD2D2D2 },
    { "H", _("Тёмно серый"), 0xB9B9B9 },
    { "w", _("Белый"), 0xffffff },
    { "W", _("Светло серый"), 0xF8F8F8 },
    { "l", _("Сине-зелёный"), 0x00FF80 },
    { "L", _("Тёмно-сине-зелёный"), 0x098447 },
    { "e", _("Жёлто-зелёный"), 0x80FF00 },
    { "E", _("Тёмно-жёлто-зелёный"), 0x408000 },
    { "n", _("Небесно-синий"), 0x6BB5FF },
    { "N", _("Тёмно-небесно-синий"), 0x004080 },
    { "u", _("Сине-фиолетовый"), 0xCC99FF },
    { "U", _("Тёмно-сине-фиолетовый"), 0x3F007F },
    { "p", _("Фиолетовый"), 0xFF73B9 },
    { "P", _("Тёмно-фиолетовый"), 0x8E1C55 },
    { "q", _("Оранжевый"), 0xFF9123 },
    { "Q", _("Тёмно-оранжевый"), 0x804000 },
    { NULL, NULL, 0x00 }
    };

struct _funcs
{
    gchar *name;
    gchar *desc;
} funcs[] =
    {
    { _("Действия"), NULL },
        { "+", _("Сложение") },
        { "-", _("Вычитание") },
        { "*", _("Умножение") },
        { "/", _("Деление") },
        { "^", _("Возведение в степень") },
    { _("Простые"), NULL },
        { "sqrt(x)", _("Корень квадратный из x") },
        { "pow(x,y)", _("Возведение x в степень y") },
        { "ln(x)", _("Натуральный логарифм из x") },
        { "lg(x)", _("Десятичный логарифм из x") },
        { "log(a,x)", _("Логарифм из x по основанию a") },
        { "abs(x)", _("Модуль числа x") },
        { "sign(x)", _("Знак числа x") },
        { "mod(x,y)", _("Остаток от деления x на y") },
        { "step(x)", _("Ступенчатая функция") },
    { _("Переменные"), NULL },
        { "rnd", _("Случайное число") },
        { "pi", _("Число Пи") },
    { _("Тригонометрические"), NULL },
        { "sin(x)", _("Синус x") },
        { "cos(x)", _("Косинус x") },
        { "tg(x)", _("Тангенс x") },
        { "asin(x)", _("Арксинус x") },
        { "acos(x)", _("Арккосинус x") },
        { "atan(x)", _("Арктангенс x") },
        { "sh(x)", _("Гиперболический синус x") },
        { "ch(x)", _("Гиперболический косинус x") },
        { "th(x)", _("Гиперболический тангенс x") },
        { "asinh(x)", _("Гиперболический арксинус x") },
        { "acosh(x)", _("Гиперболический арккосинус x") },
        { "atanh(x)", _("Гиперболический арктангенс x") },
    { _("Специальные показательные"), NULL },
        { "gamma(x)", _("Гамма функция Г(x)") },
        { "psi(x)", _("Дигамма функция от x") },
        { "ai(x)", _("Функция Эйри Ai(x)") },
        { "bi(x)", _("Функция Эйри Bi(x)") },
        { "cl(x)", _("Функция Клаузена") },
        { "li2(x)", _("Дилогарифм от x") },
        { "sinc(x)", _("sin(pi*x)/pi*x") },
        { "zeta(x)", _("Зетта функция Реймана") },
        { "eta(x)", _("Эта функция (1-2^(1-s))*zeta(s)") },
        { "lp(l,x)", _("Полином Лежандра") },
        { "w0(x)", _("Главная ветвь функции Ламберта W") },
        { "w1(x)", _("Ветвь функции Ламберта W(x)\nРешение уравнения (W*exp(W)=x)") },
    { _("Интегральные показательные"), NULL },
        { "ci(x)", _("Интегральный косинус x") },
        { "si(x)", _("Интегральный синус x") },
        { "erf(x)", _("Интеграл вероятности x") },
        { "ei(x)", _("Интегральная показательная функция Ei(x)") },
        { "e1(x)", _("Интегральная показательная функция E1(x)") },
        { "e2(x)", _("Интегральная показательная функция E2(x)") },
        { "e3(x)", _("Интегральная показательная функция E3(x)") },
        { "j(nu, x)", _("Функция Бесселя 1-го рода для дробного порядка nu") },
        { "y(nu, x)", _("Функция Бесселя 2-го рода для дробного порядка nu") },
        { "i(nu, x)", _("Функция Бесселя модифицированная\n1-го рода для дробного порядка nu") },
        { "k(nu, x)", _("Функция Бесселя модифицированная\n2-го рода для дробного порядка nu") },
        { "ee(k)", _("Полный эллиптический интеграл E(k)=E(pi/2,k)") },
        { "ek(k)", _("Полный эллиптический интеграл K(k)=F(pi/2,k)") },
        { "e(phi,k)", _("Эллиптический интеграл") },
        { "f(phi,k)", _("Эллиптический интеграл") },
    { _("Функции Якоби"), NULL },
        { "sn(u,m)", "" },
        { "cn(u,m)", "" },
        { "dn(u,m)", "" },
        { "sc(u,m)", "" },
        { "sd(u,m)", "" },
        { "ns(u,m)", "" },
        { "cs(u,m)", "" },
        { "cd(u,m)", "" },
        { "nc(u,m)", "" },
        { "ds(u,m)", "" },
        { "dc(u,m)", "" },
        { "nd(u,m)", "" },
        { NULL, NULL }
    };


struct _method
{
    gchar *name;
    DRAW_METHOD method;
} methods[] =
    {
        { "График", DM_PLOT },
        { "Заполненная кривая", DM_AREA },
        { "Вертикальные линии", DM_STEM },
        { "Ступеньки", DM_STEP },
        { "Прямоугольники", DM_BARS },
        { NULL, DM_COUNT }
    };


gint
color_find_color (const gchar *style)
{
    for (gint i = 0; colors[i].name != NULL; ++i)
    {
        if (!g_strcasecmp (colors[i].mglcolor, style))
        {
            return colors[i].clr;
        }
    }
    return -1;
}


void
on_funcs_menu_select (GtkMenuItem *item, gpointer data)
{
    GtkWidget *label = gtk_bin_get_child(GTK_BIN(item));
    GtkWidget *entry = GTK_WIDGET(data);

    const gchar *text = gtk_label_get_text ( GTK_LABEL(label));

    gtk_entry_append_text (GTK_ENTRY(entry), text);

    std::cout << text << std::endl;

}

GtkWidget *
create_funcs_menu (GtkWidget *entry)
{
  GtkWidget *menu, *menu2 = NULL;
  GtkWidget *menuitem;
  int i;

    menu = gtk_menu_new ();

    menuitem = gtk_tearoff_menu_item_new ();
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
    gtk_widget_show (menuitem);

    for (i = 0; funcs[i].name || funcs[i].desc; ++i)
    {
        if (funcs[i].name && !funcs[i].desc)
        {
            menuitem = gtk_menu_item_new_with_label (funcs[i].name);
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
            gtk_widget_show (menuitem);

            menu2 = gtk_menu_new ();
            gtk_menu_item_set_submenu (GTK_MENU_ITEM(menuitem), menu2);
        } else {
            menuitem = gtk_menu_item_new_with_label (funcs[i].name);
            gtk_menu_shell_append (GTK_MENU_SHELL(menu2), menuitem);

            gtk_widget_set_tooltip_text (menuitem, funcs[i].desc );

            g_signal_connect (G_OBJECT(menuitem), "activate",
                            G_CALLBACK( on_funcs_menu_select), entry);

            gtk_widget_show (menuitem);
        }
    }

        return menu;

}

void
on_funcs_menu_popup (GtkWidget *widget, gpointer data)
{
    GtkMenu *menu = GTK_MENU(data);
    std::cout << "Popup!" << std::endl;
    gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 0, 0);
}

GtkTreeModel *
combo_create_color_model ()
{

    GtkTreeModel *store;
    GdkPixbuf *pixbuf;
    GtkTreeIter iter;
    gint i;

    store = GTK_TREE_MODEL(gtk_list_store_new (2, G_TYPE_STRING, GDK_TYPE_PIXBUF));

        for (i = 0; colors[i].name != NULL; ++i)
            {

            pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, false, 8, 20, 20);

            gdk_pixbuf_fill (pixbuf, colors[i].clr << 8
            );

            gtk_list_store_append (GTK_LIST_STORE(store), &iter);

            gtk_list_store_set (GTK_LIST_STORE(store), &iter,
                    COLOR_NAME, colors[i].name,
                    COLOR_PIXBUF, pixbuf,
                        -1);
            g_object_unref (pixbuf);
        }


    return store;
}

void
combo_append_methods (GtkComboBox *box)
{
    GtkTreeIter iter;
    GtkListStore *store = gtk_list_store_new (1, G_TYPE_STRING);

    for (gint i = 0; methods[i].name != NULL; ++i)
    {
        gtk_list_store_append (store, &iter);
        gtk_list_store_set (store, &iter, 0, methods[i].name, -1);
    }

    gtk_combo_box_set_model (box, GTK_TREE_MODEL(store) );

    g_object_unref (store);
}

CDECL void
validate_data_on_ok(GtkWidget *widget, gint resp, gpointer data)
{
    if (resp == GTK_RESPONSE_OK)
    {
        GladeXML *xml = (GladeXML*)data;

        GtkWidget *w= glade_xml_get_widget(xml, "dlg_function_entry");
        assert(G_IS_OBJECT(w));

        std::string str = gtk_entry_get_text(GTK_ENTRY(w));

        if (!g_ascii_strcasecmp(str.c_str(),""))
        {
            show_message(widget, "Функция не может быть пустой!");
            return;
        }

        w = glade_xml_get_widget(xml, "x_min_spin");
        assert(G_IS_OBJECT(w));

        gdouble xmin = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));

        w = glade_xml_get_widget(xml, "x_max_spin");
        assert(G_IS_OBJECT(w));

        gdouble xmax = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));

        if (xmax < xmin)
        {
            show_message(widget, "Xmax не может быть меньше Xmin!");
            return;
        }

        w = glade_xml_get_widget(xml, "step_spin");
        assert(G_IS_OBJECT(w));

        gdouble res = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));

        w = glade_xml_get_widget (xml, "color_combo");
        assert (G_IS_OBJECT(w));

        Function *f = functions_add_function_with_dims1(xmin, xmax, res);

        gint i = gtk_combo_box_get_active (GTK_COMBO_BOX(w));

        tree_add_item(str.c_str(), colors[i].clr << 8, TRUE);

        f->style = g_strdup (colors[i].mglcolor);

        w = glade_xml_get_widget (xml, "type_combo");
        assert (G_IS_OBJECT(w));

        i = gtk_combo_box_get_active (GTK_COMBO_BOX(w));

        f->dmethod = methods[i].method;

        functions_modify_function1 (f, str);

        set_modified (TRUE);

        graph_render_to_pixbuf();

    }

    gtk_widget_hide (GTK_WIDGET(widget));

}

CDECL void
on_tlb_delete_graph_clicked (GtkWidget *widget, gpointer data)
{
    if ( functions_get_count () > 0 )
    {
    gint i = tree_view_delete_item ();
    functions_delete_function ( i );

    set_modified (TRUE);

    graph_render_to_pixbuf ();
    }

}

void
prepare_function_dlg (GladeXML *xml)
{
    GtkWidget *dlg= glade_xml_get_widget (xml, "add_function_dialog");
    assert (G_IS_OBJECT(dlg));

    g_signal_connect (G_OBJECT(dlg), "response", G_CALLBACK(validate_data_on_ok), (gpointer)xml);

    /*
     *  комбобокс цвет графика
     */

    GtkWidget *combo = glade_xml_get_widget (xml, "color_combo");
    assert (G_IS_OBJECT(combo));

    GtkTreeModel *model = combo_create_color_model ();

    gtk_combo_box_set_model (GTK_COMBO_BOX(combo), model);

    GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new ();

    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
				    "pixbuf", COLOR_PIXBUF,
				    NULL);
    gtk_combo_box_set_active (GTK_COMBO_BOX(combo), 0);

    /*
     *  комбобокс тип графика
     */

    combo = glade_xml_get_widget (xml, "type_combo");
    assert (G_IS_OBJECT(combo));

    combo_append_methods (GTK_COMBO_BOX(combo));

    gtk_combo_box_set_active (GTK_COMBO_BOX(combo), 0);

    /*
     *  Выпадающее меню с функциями
     */

     combo = glade_xml_get_widget (xml, "dlg_function_entry" );

    GtkMenu *menu = GTK_MENU( create_funcs_menu (combo));

    GtkWidget *b = glade_xml_get_widget (xml, "funcs_popup_button");
    assert (G_IS_OBJECT(b));

    g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK(on_funcs_menu_popup), menu);


}