GTK+/Kalkulator w C++
< GTK+
Jednym z powodów, dla których nie wybiera się użycia biblioteki GTK+ na rzecz innych jest to, że nie dostarcza ona obiektowego interfejsu.
Nie oznacza to, że nie można programować obiektowo np. w C++ z użyciem GTK+. W celu zademonstrowania jak można to zrobić, przepiszemy nasz kalkulator w języku C++.
Posiadamy dwie klasy, jedną na mechanizmy samego kalkulatora, drugą dziedziczącą po pierwszej opisującą tylko mechanizmy samego interfejsu graficznego. Najważniejszy jest tu fakt rozdzielenia kodu programu kalkulatora przez kod budowy interfejsu użytkownika. Ten ostatni dzięki dziedziczeniu po klasie bazowej naszego programu ma bezpośredni dostęp do jego metod. Tworząc okno kalkulatora nasz program posiada już funkcję realizujące właściwe liczenie.
kalkulator.hpp zawiera deklaracje klasy opisującej zadania jakie ma spełniać kalkulator, bez interfejsu graficznego.
Zmiany w organizacji kodu:
- nowy typ wyliczeniowy
btn_idzastępuje umowne wartości dla zmiennejprev_button, obecnie zmienna ta jest typubtn_id. Ponieważ wartościom zmiennejprev_buttontypubtn_iddla przycisków numerycznych z klawiatury kalkulatora odpowiada ta sama liczba jaką reprezentuje przycisk (np. wartość Button_5 = 5). Wykorzystywaliśmy to już poprzednio w funkcji obsługi każdego przycisku numerycznego do wstawiania odpowiadającej mu liczby na wyświetlaczu. W celu ułatwienia tego zadania zdefiniowano nową funkcje:const char* _btn_id_to_char(btn_id val);- zamienia wartość typubtn_idnachar*
- podobnie zdefiniowano nowy typ dla zmiennej
operation. Dodano dwie nowe funkcje konwertujące:const char* _operation_id_to_char(operation_id val);- zamienia wartość typuoperation_idnachar*(wykorzystywana w celach debugujących)btn_id _operation_id_to_btn_id(operation_id val);- zamienia wartość typuoperation_idnabtn_id(używa się jej w funkcjach obsługi działań przycisków +, -, *, /, na podstawie wywołanego działania ustawiana jest zmiennaprev_button)
- funkcja
void __debug(const gchar* event,bool data);zastępuje poprzedniąvoid info (Kalkulator * pkalkulator, gchar* event). - poprzednią funkcję
licz()nazwanovoid calculate(bool);
#include <gtk/gtk.h>
enum btn_id
{
Button_1 = 1, Button_2 = 2, Button_3 = 3, Button_4 = 4, Button_5 = 5,
Button_6 = 6, Button_7 = 7, Button_8 = 8, Button_9 = 9, Button_0 = 0,
Button_add = 10, Button_sub = 11, Button_multi = 12, Button_div = 13,
Button_result = 14,
Button_comma = 15, Button_back = 16, Button_clear = 17,
NoSelectBtn = 20
};
enum operation_id
{
Add = 1, Sub = 2, Multi = 3, Div = 4, NoSelectOprt = 5
};
class Kalkulator
{
private:
GString *value1;
GString *value2;
operation_id operation;
operation_id prev_operation;
gboolean is_value1;
gboolean is_value2;
gboolean is_result;
btn_id prev_button;
public:
Kalkulator();
~Kalkulator();
const char* _btn_id_to_char(btn_id val);
const char* _operation_id_to_char(operation_id val);
btn_id _operation_id_to_btn_id(operation_id val);
void __debug(const gchar* event,bool data);
void calculate(bool);
char* get_value1();
void set_value1(const gchar *val);
bool del_value1();
char* get_value2();
void set_value2(const gchar *val);
bool del_value2();
bool get_is_value1() {return is_value1;};
void set_is_value1(bool val) {is_value1=val;};
bool get_is_value2() {return is_value2;};
void set_is_value2(bool val) {is_value2=val;};
bool get_is_result() {return is_result;};
void set_is_result(bool val) {is_result=val;};
operation_id get_operation() {return operation;};
void set_operation(operation_id val) {operation=val;};
operation_id get_prev_operation() {return prev_operation;};
void set_prev_operation(operation_id val) {prev_operation=val;};
btn_id get_prev_button() {return prev_button;};
void set_prev_button(btn_id val) {prev_button=val;};
};
kalkulator.cpp zawiera definicje metod klasy Kalkulator.
Zmiany w organizacji kodu:
- podczas tworzenia obiektu kalkulatora w konstruktorze nadajemy składowym neutralne wartości
- funkcja
__debug()oferuje dwa poziomy informowania, wyświetla zawartość składowych oraz zdarzenie jakie im towarzyszy, bądź tylko samo zdarzenie. - przekazywana wartość
prev_operation_privfunkcjicalculate()informuje ją o tym czy powinna wykonać obecne działanie czy poprzednie, umożliwia to wielokrotne wykonywanie działań na przemian.
#include <stdlib.h>
#include "kalkulator.hpp"
#define DEBUG
#define INFO
using namespace std;
Kalkulator::Kalkulator()
{
#ifdef INFO
__debug("Kalkulator konstruktor",false);
#endif
value1 = NULL;
value2 = NULL;
operation = NoSelectOprt;
prev_operation = NoSelectOprt;
is_value1 = FALSE;
is_value2 = FALSE;
is_result = FALSE;
prev_button = NoSelectBtn;
}
Kalkulator::~Kalkulator()
{
#ifdef INFO
__debug("Kalkulator destruktor",false);
#endif
}
const char* Kalkulator::_btn_id_to_char(btn_id val)
{
return val==Button_1 ? "1" :
val==Button_2 ? "2" :
val==Button_3 ? "3" :
val==Button_4 ? "4" :
val==Button_5 ? "5" :
val==Button_6 ? "6" :
val==Button_7 ? "7" :
val==Button_8 ? "8" :
val==Button_9 ? "9" :
val==Button_0 ? "0" :
val==Button_add ? "10" :
val==Button_sub ? "11" :
val==Button_multi ? "12" :
val==Button_div ? "13" :
val==Button_result ? "14" :
val==Button_comma ? "15" :
val==Button_back ? "16" :
val==Button_clear ? "17" :
"NoSelectBtn(20)";
}
const char* Kalkulator::_operation_id_to_char(operation_id val)
{
return val==Add ? "+" :
val==Sub ? "-" :
val==Multi ? "*" :
val==Div ? "/" :
"NoSelectOprt(5)";
}
btn_id Kalkulator::_operation_id_to_btn_id(operation_id val)
{
return val==Add ? Button_add :
val==Sub ? Button_sub :
val==Multi ? Button_multi :
val==Div ? Button_div :
NoSelectBtn;
}
void Kalkulator::__debug(const gchar* event, bool data)
{
if (data)
printf (
"\n =============\n \
event: %s \n \
- - - - -\n \
Struktura:\n \
value1: %s \n \
value2: %s \n \
operation: %d \n \
is_value1: %d \n \
is_value2: %d \n \
is_result: %d \n \
prev_button: %d \n \
prev_operation: %d \n \
- - - - -\n",
event,
is_value1? value1->str :"",
is_value2? value2->str :"",
operation,
is_value1,
is_value2,
is_result,
prev_button,
prev_operation);
else
cout << event << endl;
}
void Kalkulator::calculate(bool prev_operation_priv)
{
double d_value1=0,
d_value2=0,
d_result=0;
int len, test(0);
char s_result[50];
// char* -> double
d_value1 = strtod( value1->str, NULL );
d_value2 = strtod( value2->str, NULL );
if (prev_operation_priv)
{
test = prev_operation==Add ? 1 :
prev_operation==Sub ? 2 :
prev_operation==Multi ? 3 :
prev_operation==Div ? 4 :
NoSelectOprt;
}
else
{
test = operation==Add ? 1 :
operation==Sub ? 2 :
operation==Multi ? 3 :
operation==Div ? 4 :
NoSelectOprt;
}
switch(test)
{
case 1:
d_result = d_value1 + d_value2;
break;
case 2:
d_result = d_value1 - d_value2;
break;
case 3:
d_result = d_value1 * d_value2;
break;
case 4:
if ( d_value2 != 0.0 )
d_result = d_value1 / d_value2;
else
d_result = d_value1;
break;
case 5:
// Checkit!
break;
}
// double -> char*
len = sprintf( s_result, "%g", d_result );
// można to spr.
// if ( !len ) ...
set_value1(s_result);
set_is_result(true);
#ifdef DEBUG
printf ("calculateby to %g , %g wynik to: %g \n",d_value1,d_value2,d_result);
#endif
}
char* Kalkulator::get_value1()
{
if (is_value1)
return value1->str;
else
return NULL;
}
void Kalkulator::set_value1(const gchar *val)
{
if (is_value1)
{
g_string_free(value1,TRUE);
value1 = g_string_new(val);
}
else
{
value1 = g_string_new(val);
is_value1 = TRUE;
}
}
bool Kalkulator::del_value1()
{
if (is_value1)
{
g_string_free(value1,TRUE);
is_value1 = FALSE;
return TRUE;
}
else
return FALSE;
}
char* Kalkulator::get_value2()
{
if (is_value2)
return value2->str;
else
return NULL;
}
void Kalkulator::set_value2(const gchar *val)
{
if (is_value2)
{
g_string_free(value2,TRUE);
value2 = g_string_new(val);
}
else
{
value2 = g_string_new(val);
is_value2 = TRUE;
}
}
bool Kalkulator::del_value2()
{
if (is_value2)
{
g_string_free(value2,TRUE);
is_value2 = FALSE;
return TRUE;
}
else
return FALSE;
}
gui.hpp zawiera definicje klasy odpowiadającej za zadania realizowane przez graficzny interfejs użytkownika kalkulatora. Jednocześnie dziedziczy po klasie opisującej ogólnie kalkulator, co w sumie daje połączenie zadań realizowanych przez kalkulator oraz interfejsu graficznego do obsługi kalkulatora. Publiczne metody init(int, char**), build(), run() stanowią programistyczny interfejs do uruchomienia całego programu. Pierwsza z nich inicjuje GTK+, druga tworzy potrzebne kontrolki, lecz ich nie wyświetla. Ostatnia metoda run() wyświetla stworzone okna oraz wywołuje główną pętle programu w GTK+.
#include "kalkulator.cpp"
class GUIKalkulator: public Kalkulator
{
private:
GtkWidget *mainwindow;
GtkWidget *table;
GtkWidget *entry;
GtkWidget *button1;
GtkWidget *button2;
GtkWidget *button3;
GtkWidget *button4;
GtkWidget *button5;
GtkWidget *button6;
GtkWidget *button7;
GtkWidget *button8;
GtkWidget *button9;
GtkWidget *button0;
GtkWidget *buttoncomma;
GtkWidget *buttonback;
GtkWidget *buttonclear;
GtkWidget *buttonadd;
GtkWidget *buttonsub;
GtkWidget *buttonmulti;
GtkWidget *buttondiv;
GtkWidget *buttonresult;
// funkcje zwrotne
static gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data);
static void destroy(GtkWidget *widget, gpointer data);
static void btn_1_clicked(GtkWidget *widget, gpointer data);
static void btn_2_clicked(GtkWidget *widget, gpointer data);
static void btn_3_clicked(GtkWidget *widget, gpointer data);
static void btn_4_clicked(GtkWidget *widget, gpointer data);
static void btn_5_clicked(GtkWidget *widget, gpointer data);
static void btn_6_clicked(GtkWidget *widget, gpointer data);
static void btn_7_clicked(GtkWidget *widget, gpointer data);
static void btn_8_clicked(GtkWidget *widget, gpointer data);
static void btn_9_clicked(GtkWidget *widget, gpointer data);
static void btn_0_clicked(GtkWidget *widget, gpointer data);
static void btn_comma_clicked(GtkWidget *widget, gpointer data);
static void btn_back_clicked(GtkWidget *widget, gpointer data);
static void btn_clear_clicked(GtkWidget *widget, gpointer data);
static void btn_add_clicked(GtkWidget *widget, gpointer data);
static void btn_sub_clicked(GtkWidget *widget, gpointer data);
static void btn_multi_clicked(GtkWidget *widget, gpointer data);
static void btn_div_clicked(GtkWidget *widget, gpointer data);
static void btn_result_clicked(GtkWidget *widget, gpointer data);
// obsłuwa wszystkich przycisków numerycznych: 1,2,3,4,5,6,7,8,9,0
void _numeric_btn_clicked_event(btn_id button);
// obsługa wszytskich przycisków działń: +,-,*,/
void _calculate_btn_clicked_event(operation_id operation);
public:
GUIKalkulator();
~GUIKalkulator();
void init(int, char**);
void build();
void run();
};
gui.cpp wprowadzono tu nową zastępczą funkcje gtk_editable_insert_text() dla gtk_entry_append_text(), ponieważ jest ona wyprowadzana z API GTK+. Funkcja ta różni się od poprzedniej tym, że wstawia tekst w określonej przez ostatni parametr pozycji a nie na koniec ciągu znaków.
#include "gui.hpp"
#include <string.h>
#define DEBUG
#define INFO
GUIKalkulator::GUIKalkulator()
{
#ifdef INFO
__debug("GUIKalkulator konstruktor",false);
#endif
}
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_container_set_border_width(GTK_CONTAINER(mainwindow), 5);
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 | _ | _ | _ | _ | _ | _ |
*/
table = gtk_table_new (4, 6, TRUE);
gtk_container_add ( GTK_CONTAINER (mainwindow),
table);
// entry
entry = gtk_entry_new ( );
gtk_entry_set_alignment ( GTK_ENTRY( entry ), 1);
gtk_editable_set_editable ( GTK_EDITABLE( entry ), FALSE);
// 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 );
// 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 C
buttonclear = gtk_button_new_with_label ("C");
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);
}
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);
#endif
gui_kalkulator->set_prev_button(Button_1);
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)
{
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);
if (get_is_result() && get_prev_button() == Button_result)
{
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),"");
}
else if (get_is_result())
{
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);
set_prev_button(button);
}
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;
}
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_comma)
{
// ustawic value2 i obcalculateyć wynik
test = 2;
}
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)));
// gdy po wielokrotnych operacji następuje zmiana
// wynik obcalculateamy 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)
*/
gtk_entry_set_text(GTK_ENTRY(entry), get_value1());
break;
}
set_prev_button(_operation_id_to_btn_id(operation));
// 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)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_1);
}
void GUIKalkulator::btn_2_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_2);
}
void GUIKalkulator::btn_3_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_3);
}
void GUIKalkulator::btn_4_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_4);
}
void GUIKalkulator::btn_5_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_5);
}
void GUIKalkulator::btn_6_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_6);
}
void GUIKalkulator::btn_7_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_7);
}
void GUIKalkulator::btn_8_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_8);
}
void GUIKalkulator::btn_9_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_9);
}
void GUIKalkulator::btn_0_clicked(GtkWidget *widget, gpointer data)
{
static_cast<GUIKalkulator*>(data)->_numeric_btn_clicked_event(Button_0);
}
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
len = strlen(GTK_ENTRY(gui_kalkulator->entry)->text);
gtk_editable_insert_text(GTK_EDITABLE(gui_kalkulator->entry),",",1,&len);
//gtk_entry_append_text(GTK_ENTRY(entry),",");
gui_kalkulator->set_prev_button(Button_comma);
}
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));
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);
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_prev_button(Button_result);
#ifdef DEBUG
gui_kalkulator->__debug("GUIKalkulator clicked: =",true);
#endif
}
main.cpp główny program, korzysta z implementacji naszego kalkulatora.
/*
* Autor: Grzegorz Kuczyński
* Data: 29 kwietnia 2009
*/
#include <iostream>
#include "gui.cpp"
int main(int argc, char *argv[])
{
GUIKalkulator *gui_kalkulator = new GUIKalkulator;
gui_kalkulator->init(argc,argv);
gui_kalkulator->build();
gui_kalkulator->run();
delete gui_kalkulator;
return 0;
}
Makefile plik definiujący zasady kompilacji.
CC = g++ CFLAGS = -Wall \ -DG_DISABLE_DEPRECATED \ -DGDK_DISABLE_DEPRECATED \ -DGDK_PIXBUF_DISABLE_DEPRECATED \ -DGTK_DISABLE_DEPRECATED kalkulatorCPP: main.cpp $(CC) main.cpp -o kalkulatorCPP $(CFLAGS) `pkg-config gtk+-2.0 --cflags --libs` clean: rm -f *.o kalkulatorCPP