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_id zastępuje umowne wartości dla zmiennej prev_button, obecnie zmienna ta jest typu btn_id. Ponieważ wartościom zmiennej prev_button typu btn_id dla 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ść typu btn_id na char* podobnie zdefiniowano nowy typ dla zmiennej operation. Dodano dwie nowe funkcje konwertujące: const char* _operation_id_to_char(operation_id val); - zamienia wartość typu operation_id na char* (wykorzystywana w celach debugujących) btn_id _operation_id_to_btn_id(operation_id val); - zamienia wartość typu operation_id na btn_id (używa się jej w funkcjach obsługi działań przycisków +, -, *, /, na podstawie wywołanego działania ustawiana jest zmienna prev_button) funkcja void __debug(const gchar* event,bool data); zastępuje poprzednią void info (Kalkulator * pkalkulator, gchar* event). poprzednią funkcję licz() nazwano void calculate(bool);
#include
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_priv funkcji calculate() informuje ją o tym czy powinna wykonać obecne działanie czy poprzednie, umożliwia to wielokrotne wykonywanie działań na przemian.
#include #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 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
#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 | _ | _ | _ | _ | _ | _ | */