GTK+/Kalkulator 0.0.1 - gui.cpp
< GTK+
#include "gui.hpp"
#include <string.h>
#include <gdk/gdkkeysyms.h>
//#define DEBUG
//#define INFO
GUIKalkulator::GUIKalkulator()
{
#ifdef INFO
__debug("GUIKalkulator konstruktor",false);
#endif
combocount = 0;
}
GUIKalkulator::~GUIKalkulator()
{
#ifdef INFO
__debug("GUIKalkulator destruktor",false);
#endif
}
void GUIKalkulator::init(int argc, char** argv)
{
#ifdef INFO
__debug("GUIKalkulator init()",false);
#endif
gtk_init(&argc, &argv);
}
void GUIKalkulator::build()
{
#ifdef INFO
__debug("GUIKalkulator bulid()",false);
#endif
mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(mainwindow),"delete_event",G_CALLBACK(delete_event),this);
g_signal_connect(G_OBJECT(mainwindow),"destroy",G_CALLBACK(destroy),this);
gtk_widget_set_events (mainwindow, GDK_KEY_PRESS_MASK);
g_signal_connect (G_OBJECT (mainwindow),"key_press_event",G_CALLBACK(mainwindow_key_press_event),this);
gtk_window_set_title(GTK_WINDOW(mainwindow),"Kalkulator");
gtk_window_set_resizable(GTK_WINDOW(mainwindow),FALSE);
// tabela
/*
0/0 - 1 - 2 - 3 - 4 - 5 - 6
1 | _ | _ | _ | _ | _ | _ |
2 | _ | _ | _ | _ | _ | _ |
3 | _ | _ | _ | _ | _ | _ |
4 | _ | _ | _ | _ | _ | _ |
5 | _ | _ | _ | _ | _ | _ | Add
*/
table = gtk_table_new(5,6,TRUE);
gtk_container_set_border_width(GTK_CONTAINER(table),5);
//gtk_container_add(GTK_CONTAINER(mainwindow),table);
// entry
entry = gtk_entry_new();
gtk_entry_set_alignment(GTK_ENTRY(entry),1);
GdkColor entry_color; // kolor
gdk_color_parse("#eaf8d9",&entry_color);
gtk_widget_modify_base(entry,GTK_STATE_NORMAL,&entry_color);
// 0,6 - szerokość od 0 do 6
// 0,1 - wysokość od 0 do 1
gtk_table_attach_defaults(GTK_TABLE(table),entry,0,6,0,1);
gtk_widget_set_size_request(entry,-1,30);
//czcionka
pangofont = pango_font_description_new();
pango_font_description_set_size(pangofont,17 * PANGO_SCALE );
pango_font_description_set_weight(pangofont,PANGO_WEIGHT_BOLD);
gtk_widget_modify_font(entry,pangofont);
pango_font_description_free(pangofont);
//bez zaznaczania
gtk_editable_set_editable(GTK_EDITABLE(entry),false);
// przyciski 1
// 0,1 - szerokość od 0 do 1
// 1,2 - wysokość od 1 do 2
button1 = gtk_button_new_with_label("1");
g_signal_connect(G_OBJECT(button1),"clicked",G_CALLBACK(btn_1_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button1,0,1,1,2);
// przyciski 2
button2 = gtk_button_new_with_label("2");
g_signal_connect(G_OBJECT(button2),"clicked",G_CALLBACK(btn_2_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button2,1,2,1,2);
// przyciski 3
button3 = gtk_button_new_with_label("3");
g_signal_connect(G_OBJECT(button3),"clicked",G_CALLBACK(btn_3_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button3,2,3,1,2);
// drugi wiersz
// przyciski 4
button4 = gtk_button_new_with_label("4");
g_signal_connect(G_OBJECT(button4),"clicked",G_CALLBACK(btn_4_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button4,0,1,2,3);
// przyciski 5
button5 = gtk_button_new_with_label("5");
g_signal_connect(G_OBJECT(button5),"clicked",G_CALLBACK(btn_5_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button5,1,2,2,3);
// przyciski 6
button6 = gtk_button_new_with_label("6");
g_signal_connect(G_OBJECT(button6),"clicked",G_CALLBACK(btn_6_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button6,2,3,2,3);
// trzeci wiersz
// przyciski 7
button7 = gtk_button_new_with_label("7");
g_signal_connect(G_OBJECT(button7),"clicked",G_CALLBACK(btn_7_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button7,0,1,3,4);
// przyciski 8
button8 = gtk_button_new_with_label("8");
g_signal_connect(G_OBJECT(button8),"clicked",G_CALLBACK(btn_8_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button8,1,2,3,4);
// przyciski 9
button9 = gtk_button_new_with_label("9");
g_signal_connect(G_OBJECT(button9),"clicked",G_CALLBACK(btn_9_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button9,2,3,3,4);
// przyciski 0
button0 = gtk_button_new_with_label("0");
g_signal_connect(G_OBJECT(button0),"clicked",G_CALLBACK(btn_0_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),button0,3,4,3,4);
// przyciski <-
buttonback = gtk_button_new_with_label("<-");
g_signal_connect(G_OBJECT(buttonback),"clicked",G_CALLBACK(btn_back_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttonback,3,4,2,3);
// przyciski AC
buttonclear = gtk_button_new_with_label("AC");
g_signal_connect(G_OBJECT(buttonclear),"clicked",G_CALLBACK(btn_clear_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttonclear,3,4,1,2);
// przyciski +
buttonadd = gtk_button_new_with_label("+");
g_signal_connect(G_OBJECT(buttonadd),"clicked",G_CALLBACK(btn_add_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttonadd,4,5,1,2);
// przyciski -
buttonsub = gtk_button_new_with_label("-");
g_signal_connect(G_OBJECT(buttonsub),"clicked",G_CALLBACK(btn_sub_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttonsub,4,5,2,3);
// przyciski *
buttonmulti = gtk_button_new_with_label("*");
g_signal_connect(G_OBJECT(buttonmulti),"clicked",G_CALLBACK(btn_multi_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttonmulti,4,5,3,4);
// przyciski /
buttondiv = gtk_button_new_with_label("/");
g_signal_connect(G_OBJECT(buttondiv),"clicked",G_CALLBACK(btn_div_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttondiv,5,6,1,2);
// przyciski =
buttonresult = gtk_button_new_with_label("=");
g_signal_connect(G_OBJECT(buttonresult),"clicked",G_CALLBACK(btn_result_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttonresult,5,6,3,4);
// przyciski ,
buttoncomma = gtk_button_new_with_label(",");
g_signal_connect(G_OBJECT(buttoncomma),"clicked",G_CALLBACK(btn_comma_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttoncomma,5,6,2,3);
// przyciski -/+
buttonsigned = gtk_button_new_with_label("-/+");
g_signal_connect(G_OBJECT(buttonsigned),"clicked",G_CALLBACK(btn_signed_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttonsigned,0,1,4,5);
// przyciski M+
buttonaddmem = gtk_button_new_with_label("M+");
g_signal_connect(G_OBJECT(buttonaddmem),"clicked",G_CALLBACK(btn_addmem_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttonaddmem,1,2,4,5);
// lista z zapamietanymi liczbami
comboreadmem = gtk_combo_box_new_text();
gtk_table_attach_defaults(GTK_TABLE(table),comboreadmem,2,5,4,5);
gtk_combo_box_append_text(GTK_COMBO_BOX(comboreadmem),"Czytaj z pamięci");
combocount++;
gtk_combo_box_set_active(GTK_COMBO_BOX(comboreadmem),0);
g_signal_connect(G_OBJECT(comboreadmem),"changed",G_CALLBACK(btn_readmem_clicked),this);
gtk_widget_set_sensitive(comboreadmem,FALSE);
atk_object_set_name(
gtk_widget_get_accessible(comboreadmem),
"Zapamietane liczby");
atk_object_set_description(
gtk_widget_get_accessible(comboreadmem),
"Ustaw poziom efektu kontrast");
// przyciski MC
buttonclearmem = gtk_button_new_with_label("MC");
g_signal_connect(G_OBJECT(buttonclearmem),"clicked",G_CALLBACK(btn_clearmem_clicked),this);
gtk_table_attach_defaults(GTK_TABLE(table),buttonclearmem,5,6,4,5);
gtk_widget_set_sensitive(buttonclearmem,FALSE);
/*
GtkMenuBar
GtkMenuItem
GtkMenu
GtkImageMenuItem
GtkMenuItem
GtkMenuItem
GtkMenu
GtkMenuItem
GtkMenuItem
GtkMenuItem
GtkMenu
GtkMenuItem
*/
menubar = gtk_menu_bar_new();
menu_kalkulator = gtk_menu_new();
menuitem_close = gtk_menu_item_new_with_label("Zamknij");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_kalkulator),menuitem_close);
g_signal_connect(G_OBJECT(menuitem_close),"activate",G_CALLBACK(menu_item_close),this);
menu_help = gtk_menu_new();
menuitem_help = gtk_menu_item_new_with_label("Pomoc");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_help),menuitem_help);
g_signal_connect(G_OBJECT(menuitem_help),"activate",G_CALLBACK(menu_item_help),this);
menuitem_bar_kalkulator = gtk_menu_item_new_with_label("Kalkulator");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem_bar_kalkulator),menu_kalkulator);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menuitem_bar_kalkulator);
menuitem_bar_about = gtk_menu_item_new_with_label("O programie");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem_bar_about),menu_help);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menuitem_bar_about);
vbox_menu = gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox_menu),menubar,FALSE,TRUE,0);
vbox = gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),vbox_menu,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),table,FALSE,FALSE,0);
gtk_container_add(GTK_CONTAINER(mainwindow),vbox);
}
void GUIKalkulator::run()
{
#ifdef INFO
__debug("GUIKalkulator run()",false);
#endif
gtk_widget_show_all(mainwindow);
gtk_main();
}
gboolean GUIKalkulator::delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
//GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
#ifdef INFO
//gui_kalkulator->__debug("GUIKalkulator delete_event()",false);
static_cast<GUIKalkulator*>(data)->__debug("GUIKalkulator delete_event()",false);
#endif
return FALSE;
}
void GUIKalkulator::destroy(GtkWidget *widget, gpointer data)
{
#ifdef INFO
static_cast<GUIKalkulator*>(data)->__debug("GUIKalkulator destroy(gtk_main_quit)",false);
#endif
gtk_main_quit();
}
void GUIKalkulator::_numeric_btn_clicked_event(btn_id button, GUIKalkulator* gui_kalkulator)
{
const char *number = _btn_id_to_char(button);
#ifdef INFO
__debug("GUIKalkulator _numeric_btn_clicked_event()",false);
g_print("clicked: %s\n",number);
#endif
int len(0);
gint8 test(0);
// 1 - poprzednio wciśnięto '=' na wyświetlaczu jest wynik, można na nim wynkonać nowe działania,
// ale wybrano nową cyfre, co sugeruje przerwanie dotychczasowego działania i
// rezpoczęcie nowego - wszystko jest zerowane podobnie jak podczas 'AC'
// 2 - na wyswietlaczu jest wynik, np. po wywołaniu jednego z przycisków działań ('+'),
// wybrano nową cyfrę, więc definiujemy value2 - wyświetlacz jest czyszczony
// 3 - na wyświetlaczu jest wynik, przed kolejnymi działaniami zostaje modyfikowany
// przez dodanie części ułamkowej, czyli wciśnięto przycisk ','
// 4 - zaczynamy wprowadzań drugą wartość po przycisku działania
if (get_is_result() && get_prev_button() == Button_result)
{
test = 1;
#ifdef DEBUG
g_print("\ntest 1 ;)\n");
#endif
}
else if (get_is_result() &&
(get_prev_button() == Button_add ||
get_prev_button() == Button_sub ||
get_prev_button() == Button_multi ||
get_prev_button() == Button_div) )
{
test = 2;
#ifdef DEBUG
g_print("\ntest 2 ;)\n");
#endif
}
else if (get_is_result() == false &&
get_button_cache_comma() == Button_comma &&
get_button_cache_result() == Button_result)
{
test = 3;
#ifdef DEBUG
g_print("\ntest 3 ;)\n");
#endif
}
else if (get_prev_button() == Button_add ||
get_prev_button() == Button_sub ||
get_prev_button() == Button_multi ||
get_prev_button() == Button_div )
{
test = 4;
#ifdef DEBUG
g_print("\ntest 4 ;)\n");
#endif
}
switch (test)
{
case 1:
if (get_is_value1())
del_value1();
if (get_is_value2())
del_value2();
set_operation(NoSelectOprt);
set_prev_operation(NoSelectOprt);
set_is_result(FALSE);
set_prev_button(NoSelectBtn);
gtk_entry_set_text(GTK_ENTRY(entry),"");
len = strlen(GTK_ENTRY(entry)->text);
gtk_editable_insert_text(GTK_EDITABLE(entry),number,1,&len);
break;
case 2:
gtk_entry_set_text(GTK_ENTRY(entry),"");
set_is_result(FALSE);
len = strlen(GTK_ENTRY(entry)->text);
gtk_editable_insert_text(GTK_EDITABLE(entry),number,1,&len);
break;
case 3:
len = strlen(GTK_ENTRY(entry)->text);
gtk_editable_insert_text(GTK_EDITABLE(entry),number,1,&len);
set_value1(gtk_entry_get_text(GTK_ENTRY(entry)));
break;
case 4:
gtk_entry_set_text(GTK_ENTRY(entry),"");
len = strlen(GTK_ENTRY(entry)->text);
gtk_editable_insert_text(GTK_EDITABLE(entry),number,1,&len);
set_is_result(FALSE);
break;
default:
len = strlen(GTK_ENTRY(entry)->text);
gtk_editable_insert_text(GTK_EDITABLE(entry),number,1,&len);
}
set_prev_button(button);
#ifdef DEBUG
__debug("GUIKalkulator _numeric_btn_clicked_event()",true);
#endif
}
void GUIKalkulator::_calculate_btn_clicked_event(operation_id operation)
{
#ifdef INFO
__debug("GUIKalkulator _calculate_btn_clicked_event()",false);
g_print("clicked: %s\n",_operation_id_to_char(operation));
#endif
gint8 test = 0,
prev_operation_tmp = FALSE;
gchar *text_entry = GTK_ENTRY(entry)->text;
// +,-,*,/
set_operation(operation);
// test
if (get_is_value1() == FALSE &&
get_is_value2() == FALSE &&
strlen(text_entry) > 0)
{
// nalezy ustawić value1
test = 1;
#ifdef DEBUG
g_print("\ntest 1\n");
#endif
}
else if (get_is_value1() == TRUE &&
get_is_value2() == FALSE &&
strlen(text_entry) > 0 &&
get_prev_button() != Button_add &&
get_prev_button() != Button_sub &&
get_prev_button() != Button_multi &&
get_prev_button() != Button_div &&
get_prev_button() != Button_result &&
get_prev_button() != Button_back && // po <- * zle!
(get_button_cache_comma()!= Button_comma || get_button_cache_result() != Button_result) && // ,
((get_prev_button() == Button_signed && get_button_cache_result() != Button_result) || // -/+
get_prev_button() != Button_signed)
)
{
test = 2;
#ifdef DEBUG
g_print("\ntest 2\n");
#endif
}
else if (get_button_cache_result() == Button_result &&
get_prev_button() == Button_back)
{
set_value1(gtk_entry_get_text(GTK_ENTRY(entry)));
}
switch (test)
{
case 1:
set_value1(gtk_entry_get_text(GTK_ENTRY(entry)));
gtk_entry_set_text(GTK_ENTRY(entry),"");
break;
case 2:
set_value2(gtk_entry_get_text(GTK_ENTRY(entry)));
#ifdef DEBUG
g_print("\nval1: %s",get_value1());
g_print("\nval2: %s",get_value2());
#endif
// gdy po wielokrotnych operacji następuje zmiana
// wynik obliczyć według poprzednio wybranej operacji
// np. 5 + 5 (10)- 5 = 15
if (get_operation() != get_prev_operation())
prev_operation_tmp = TRUE;
calculate(prev_operation_tmp);
del_value2();
/*
* kalkulator->value1 (wynik)
* kalkulator->value2 (puste)
*/
set_is_result(true);
gtk_entry_set_text(GTK_ENTRY(entry), get_value1());
set_button_cache_result(Button_result);
break;
}
set_prev_button(_operation_id_to_btn_id(operation));
set_button_cache_comma(NoSelectBtn);
set_button_cache_result(NoSelectBtn);
// zabezpiecza nas przed tym:
// np. 1 + 5 * daje w wyniku 5 ponieważ wykonał rodzaj operacji
// domyślny dla obecnie (statnlio) wciśniętego przycisku, czyli *
set_prev_operation(get_operation());
#ifdef DEBUG
__debug("GUIKalkulator _calculate_btn_clicked_event()",true);
#endif
}
void GUIKalkulator::btn_1_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_1, NULL);
}
void GUIKalkulator::btn_2_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_2, NULL);
}
void GUIKalkulator::btn_3_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_3, NULL);
}
void GUIKalkulator::btn_4_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_4, NULL);
}
void GUIKalkulator::btn_5_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_5, NULL);
}
void GUIKalkulator::btn_6_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_6, NULL);
}
void GUIKalkulator::btn_7_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_7, NULL);
}
void GUIKalkulator::btn_8_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_8, NULL);
}
void GUIKalkulator::btn_9_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_9, NULL);
}
void GUIKalkulator::btn_0_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gui_kalkulator->_numeric_btn_clicked_event(Button_0, NULL);
}
void GUIKalkulator::btn_comma_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
int len(0);
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator clicked: ,",false);
#endif
bool cachecomma = false;
if (gui_kalkulator->get_button_cache_comma()!= Button_comma)
{
if (strlen(GTK_ENTRY(gui_kalkulator->entry)->text) != 0)
{
len = strlen(GTK_ENTRY(gui_kalkulator->entry)->text);
gtk_editable_insert_text(GTK_EDITABLE(gui_kalkulator->entry),",",1,&len);
// synchronizacja wyniku (value1) ze zmianami na wyświetlaczu
if (gui_kalkulator->get_is_result() &&
gui_kalkulator->get_prev_button() == Button_result)
{
gui_kalkulator->set_value1(gtk_entry_get_text(GTK_ENTRY(gui_kalkulator->entry)));
gui_kalkulator->set_is_result(FALSE); // to już nie jest wynik, to nowa wartość! ale potrzebne aby poszło do value2
}
cachecomma = true;
}
else
{
gui_kalkulator->dialog = gtk_message_dialog_new(GTK_WINDOW(gui_kalkulator->mainwindow),
GTK_DIALOG_MODAL,GTK_MESSAGE_WARNING,GTK_BUTTONS_OK,
"Przecinek nie może być wprowadzony jako pierwszy!\nPowinien wystepować po liczbie.");
gtk_dialog_run (GTK_DIALOG (gui_kalkulator->dialog));
gtk_widget_destroy (gui_kalkulator->dialog);
}
}
else
{
gui_kalkulator->dialog = gtk_message_dialog_new(GTK_WINDOW(gui_kalkulator->mainwindow),
GTK_DIALOG_MODAL,GTK_MESSAGE_WARNING,GTK_BUTTONS_OK,
"Wprowadzona liczba zawiera już przecinek!\nNie można wprowadzić przecinka drugi raz.");
gtk_dialog_run (GTK_DIALOG (gui_kalkulator->dialog));
gtk_widget_destroy (gui_kalkulator->dialog);
}
if (cachecomma)
gui_kalkulator->set_button_cache_comma(Button_comma);
gui_kalkulator->set_prev_button(Button_comma);
#ifdef DEBUG
gui_kalkulator->__debug("GUIKalkulator btn_comma_clicked()",true);
#endif
}
void GUIKalkulator::btn_back_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
GString *tmp=NULL;
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator clicked: <-",false);
#endif
tmp = g_string_new(gtk_entry_get_text(GTK_ENTRY(gui_kalkulator->entry)));
tmp = g_string_truncate(tmp,tmp->len-1);
gtk_entry_set_text(GTK_ENTRY(gui_kalkulator->entry), g_string_free(tmp,FALSE));
// synchronizacja wyniku (value1) ze zmianami na wyświetlaczu
if (gui_kalkulator->get_is_result())
{
gui_kalkulator->set_is_result(FALSE); // to już nie jest wynik, to nowa wartość!
}
gui_kalkulator->set_prev_button(Button_back);
}
void GUIKalkulator::btn_clear_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator clicked: C",false);
#endif
if (gui_kalkulator->get_is_value1())
gui_kalkulator->del_value1();
if (gui_kalkulator->get_is_value2())
gui_kalkulator->del_value2();
gui_kalkulator->set_operation(NoSelectOprt);
gui_kalkulator->set_prev_operation(NoSelectOprt);
gui_kalkulator->set_is_result(FALSE);
gui_kalkulator->set_prev_button(NoSelectBtn);
gui_kalkulator->set_button_cache_comma(NoSelectBtn);
gui_kalkulator->set_button_cache_result(NoSelectBtn);
gtk_entry_set_text(GTK_ENTRY(gui_kalkulator->entry),"");
gui_kalkulator->set_prev_button(Button_clear);
#ifdef DEBUG
gui_kalkulator->__debug("GUIKalkulator clicked: C",true);
#endif
}
void GUIKalkulator::btn_add_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_calculate_btn_clicked_event(Add);
}
void GUIKalkulator::btn_sub_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_calculate_btn_clicked_event(Sub);
}
void GUIKalkulator::btn_multi_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_calculate_btn_clicked_event(Multi);
}
void GUIKalkulator::btn_div_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_calculate_btn_clicked_event(Div);
}
void GUIKalkulator::btn_result_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
gchar *text_entry = GTK_ENTRY(gui_kalkulator->entry)->text;
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator clicked: =",false);
#endif
if (gui_kalkulator->get_is_value1() == TRUE &&
gui_kalkulator->get_is_value2() == FALSE &&
strlen (text_entry) > 0 &&
gui_kalkulator->get_prev_button() != Button_add &&
gui_kalkulator->get_prev_button() != Button_sub &&
gui_kalkulator->get_prev_button() != Button_multi &&
gui_kalkulator->get_prev_button() != Button_div &&
gui_kalkulator->get_prev_button() != Button_result &&
gui_kalkulator->get_prev_button() != Button_comma )
{
gui_kalkulator->set_value2(gtk_entry_get_text(GTK_ENTRY(gui_kalkulator->entry)));
gui_kalkulator->calculate(FALSE);
gui_kalkulator->del_value2();
/*
* kalkulator->value1 (wynik)
* kalkulator->value2 (puste)
*/
gtk_entry_set_text(GTK_ENTRY(gui_kalkulator->entry), gui_kalkulator->get_value1());
gui_kalkulator->set_button_cache_result(Button_result);
}
gui_kalkulator->set_prev_button(Button_result);
gui_kalkulator->set_button_cache_comma(NoSelectBtn);
#ifdef DEBUG
gui_kalkulator->__debug("GUIKalkulator clicked: =",true);
#endif
}
void GUIKalkulator::btn_signed_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
int *pos = new int(0);
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator clicked: -/+",false);
#endif
char *sig = gtk_editable_get_chars(GTK_EDITABLE(gui_kalkulator->entry),0,1);
if (strcmp(sig,"-")) // 0 == equal
gtk_editable_insert_text(GTK_EDITABLE(gui_kalkulator->entry),"-",1,pos);
else
gtk_editable_delete_text(GTK_EDITABLE(gui_kalkulator->entry),0,1);
// synchronizacja wyniku (value1) ze zmianami na wyświetlaczu
//if (gui_kalkulator->get_is_result()) // checkit!
{
gui_kalkulator->set_value1(gtk_entry_get_text(GTK_ENTRY(gui_kalkulator->entry)));
}
g_free(sig);
gui_kalkulator->set_prev_button(Button_signed);
#ifdef DEBUG
gui_kalkulator->__debug("GUIKalkulator clicked: -/+",true);
#endif
}
void GUIKalkulator::btn_addmem_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator clicked: M+",false);
#endif
if (strlen(GTK_ENTRY(gui_kalkulator->entry)->text) == 0)
{
gui_kalkulator->dialog = gtk_message_dialog_new(GTK_WINDOW(gui_kalkulator->mainwindow),
GTK_DIALOG_MODAL,GTK_MESSAGE_WARNING,GTK_BUTTONS_OK,
"Brak wartości do wprowadzenia!\nWyświetlacz jest pusty.");
gtk_dialog_run (GTK_DIALOG (gui_kalkulator->dialog));
gtk_widget_destroy (gui_kalkulator->dialog);
}
else
{
gui_kalkulator->add_to_memory(gtk_entry_get_text(GTK_ENTRY(gui_kalkulator->entry)));
gtk_combo_box_append_text(GTK_COMBO_BOX(gui_kalkulator->comboreadmem),gtk_entry_get_text(GTK_ENTRY(gui_kalkulator->entry)));
gui_kalkulator->combocount++;
gtk_widget_set_sensitive(gui_kalkulator->buttonclearmem,TRUE);
gtk_widget_set_sensitive(gui_kalkulator->comboreadmem,TRUE);
}
gui_kalkulator->set_prev_button(Button_addmem);
#ifdef DEBUG
gui_kalkulator->__debug("GUIKalkulator clicked: M+",true);
if (gui_kalkulator->memory_count() == gui_kalkulator->combocount-1) // -pierwsza pozycja nie bedąca liczbą
{
cout << "\nIlość elementów listy zgadza się z ilością elementów w combobox" << endl
<< "combocount: " << gui_kalkulator->combocount << endl
<< "memory_count(): " << gui_kalkulator->memory_count() << endl;
}
else
cout << "\nIlość elementów listy NIE zgadza się z ilością elementów w combobox" << endl;
#endif
}
void GUIKalkulator::btn_readmem_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator clicked: readmem",false);
#endif
gchar *select;
select = gtk_combo_box_get_active_text(GTK_COMBO_BOX(gui_kalkulator->comboreadmem));
if (select[0] != 'C' && select[1] != 'z' && select[2] != 'y')
{
if ((strlen(GTK_ENTRY(gui_kalkulator->entry)->text) == 0) ||
(strlen(GTK_ENTRY(gui_kalkulator->entry)->text) != 0 &&
(gui_kalkulator->get_prev_button() == Button_add ||
gui_kalkulator->get_prev_button() == Button_sub ||
gui_kalkulator->get_prev_button() == Button_multi ||
gui_kalkulator->get_prev_button() == Button_div)))
{
gtk_entry_set_text(GTK_ENTRY(gui_kalkulator->entry),select);
g_free(select);
// umożliwia wybranie drugi raz tej samej liczby
gtk_combo_box_set_active(GTK_COMBO_BOX(gui_kalkulator->comboreadmem),0);
gtk_widget_set_sensitive(gui_kalkulator->comboreadmem,TRUE);
}
else
{
gui_kalkulator->dialog = gtk_message_dialog_new(GTK_WINDOW(gui_kalkulator->mainwindow),
GTK_DIALOG_MODAL,GTK_MESSAGE_WARNING,GTK_BUTTONS_OK,
"Wprowadzono już liczbę!\nJeżeli nie jest to kolejna liczba następująca po działaniu (+,-,*,/) wyświetlacz musi być pusty.");
gtk_dialog_run (GTK_DIALOG (gui_kalkulator->dialog));
gtk_widget_destroy (gui_kalkulator->dialog);
// umożliwia wybranie drugi raz tej samej liczby
gtk_combo_box_set_active(GTK_COMBO_BOX(gui_kalkulator->comboreadmem),0);
gtk_widget_set_sensitive(gui_kalkulator->comboreadmem,TRUE);
}
}
gui_kalkulator->set_prev_button(Button_readmem);
#ifdef DEBUG
gui_kalkulator->__debug("GUIKalkulator clicked: -/+",true);
#endif
}
void GUIKalkulator::btn_clearmem_clicked(GtkWidget *widget, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator clicked: MC",false);
#endif
gui_kalkulator->memory_free();
// combocoun liczone od 1
// index w funkcji od 0
// dlatego pozwalamy sobie na natychmiastowe zmniejszenie --combocount
gtk_combo_box_set_active(GTK_COMBO_BOX(gui_kalkulator->comboreadmem),0);
// zapobiega naruszeniu pamięci
while(gui_kalkulator->combocount>1)
gtk_combo_box_remove_text(GTK_COMBO_BOX(gui_kalkulator->comboreadmem),--gui_kalkulator->combocount);
gtk_widget_set_sensitive(gui_kalkulator->buttonclearmem,FALSE);
gtk_widget_set_sensitive(gui_kalkulator->comboreadmem,FALSE);
gui_kalkulator->set_prev_button(Button_clearmem);
#ifdef DEBUG
gui_kalkulator->__debug("GUIKalkulator clicked: MC",true);
#endif
}
void GUIKalkulator::menu_item_close(GtkMenuItem *menuitem, gpointer data)
{
//GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
#ifdef INFO
//gui_kalkulator->__debug("GUIKalkulator: MENU->close",false);
static_cast<GUIKalkulator*>(data)->__debug("GUIKalkulator: MENU->close",false);
#endif
gtk_main_quit();
}
void GUIKalkulator::menu_item_help(GtkMenuItem *menuitem, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator: MENU->about",false);
#endif
static const gchar *authors = "Grzegorz Kuczyński <gk180984@interia.pl>";
static const gchar comments[] = "Jest to program demonstracyjny, \nnapisany w celach edukacyjnych GTK+.\n\nPo prostu dla zabawy :)";
static const gchar copyright[] = "Copyright \xc2\xa9 2009 Grzegorz Kuczyńśki\n";
gui_kalkulator->dialog = gtk_about_dialog_new();
gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(gui_kalkulator->dialog),"Kalkulator");
gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(gui_kalkulator->dialog),"0.0.1");
gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(gui_kalkulator->dialog),comments);
gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(gui_kalkulator->dialog),&authors);
gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(gui_kalkulator->dialog),copyright);
gtk_dialog_run (GTK_DIALOG (gui_kalkulator->dialog));
gtk_widget_destroy (gui_kalkulator->dialog);
}
gboolean GUIKalkulator::mainwindow_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
GUIKalkulator *gui_kalkulator = static_cast<GUIKalkulator*>(data);
#ifdef INFO
gui_kalkulator->__debug("GUIKalkulator: key press",false);
#endif
GdkEvent ev;
ev.key.keyval = event->keyval;
// Można by było tak...
/**********************
switch(event->keyval)
{
case GDK_KP_0: gui_kalkulator->_numeric_btn_clicked_event(Button_0,NULL); break;
case GDK_KP_1: gui_kalkulator->_numeric_btn_clicked_event(Button_1,NULL); break;
case GDK_KP_2: gui_kalkulator->_numeric_btn_clicked_event(Button_2,NULL); break;
case GDK_KP_3: gui_kalkulator->_numeric_btn_clicked_event(Button_3,NULL); break;
case GDK_KP_4: gui_kalkulator->_numeric_btn_clicked_event(Button_4,NULL); break;
case GDK_KP_5: gui_kalkulator->_numeric_btn_clicked_event(Button_5,NULL); break;
case GDK_KP_6: gui_kalkulator->_numeric_btn_clicked_event(Button_6,NULL); break;
case GDK_KP_7: gui_kalkulator->_numeric_btn_clicked_event(Button_7,NULL); break;
case GDK_KP_8: gui_kalkulator->_numeric_btn_clicked_event(Button_8,NULL); break;
case GDK_KP_9: gui_kalkulator->_numeric_btn_clicked_event(Button_9,NULL); break;
case GDK_KP_Add: gui_kalkulator->_calculate_btn_clicked_event(Add); break;
case GDK_KP_Divide: gui_kalkulator->_calculate_btn_clicked_event(Div); break;
case GDK_KP_Subtract: gui_kalkulator->_calculate_btn_clicked_event(Sub); break;
case GDK_KP_Multiply: gui_kalkulator->_calculate_btn_clicked_event(Multi); break;
case GDK_KP_Enter: gui_kalkulator->btn_result_clicked(gui_kalkulator->buttonresult,gui_kalkulator); break;
case GDK_comma: gui_kalkulator->btn_comma_clicked(gui_kalkulator->buttoncomma,gui_kalkulator); break;
case GDK_BackSpace: gui_kalkulator->btn_back_clicked(gui_kalkulator->buttonback,gui_kalkulator); break;
}
**********************/
// ...ale trzeba by było w każdym wypadku ustawić wszystkie zmienne typu set_prev_button itp
// ponieważ wszystkie obliczenia i sterowanie opiera się na informacjach zawartych
// własnie w tych zmienneych.
//
// Tak jest lepiej ponieważ symulujemy wciśnięcie tych przycisków, tak jak byśmy je wciskali
// sami, więc nie trzeba się martwić przepływem sterowania.
switch(event->keyval)
{
case GDK_KP_0: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button0),"clicked");break;
case GDK_KP_1: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button1),"clicked");break;
case GDK_KP_2: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button2),"clicked");break;
case GDK_KP_3: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button3),"clicked");break;
case GDK_KP_4: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button4),"clicked");break;
case GDK_KP_5: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button5),"clicked");break;
case GDK_KP_6: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button6),"clicked");break;
case GDK_KP_7: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button7),"clicked");break;
case GDK_KP_8: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button8),"clicked");break;
case GDK_KP_9: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->button9),"clicked");break;
case GDK_KP_Add: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->buttonadd),"clicked");break;
case GDK_KP_Divide: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->buttondiv),"clicked");break;
case GDK_KP_Subtract: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->buttonsub),"clicked");break;
case GDK_KP_Multiply: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->buttonmulti),"clicked");break;
case GDK_KP_Enter: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->buttonresult),"clicked");break;
case GDK_KP_Separator: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->buttoncomma),"clicked");break;
case GDK_BackSpace: g_signal_emit_by_name(G_OBJECT(gui_kalkulator->buttonback),"clicked");break;
}
return true;
}