diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..f803c07 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,9 @@ +{ + "files.associations": { + "stdbool.h": "c", + "cstdbool": "c", + "c++config.h": "c", + "functional": "c", + "ctype.h": "c" + } +} \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 2f052f1..5f8b3eb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,5 +3,7 @@ GIT Testprojekt ## Change log -Version Branch Änderung -0.0.2 main Gtk Grundgerüst +Version Branch Änderung +0.0.2 main Gtk Grundgerüst +0.0.4 feature-gtk4 Umstellung auf gtk4 +'apt install libgtk-4-1 libgtk-4-dev libgtk-4-bin libgtk-4-common' diff --git a/GITHELP.md b/GITHELP.md index ce74b66..e111a90 100644 --- a/GITHELP.md +++ b/GITHELP.md @@ -1,5 +1,13 @@ # GIT Help +Marker : feature-keybord branch + +https://docs.github.com/de + +## Strategie + + + ## First steps git init diff --git a/MEMO.md b/MEMO.md new file mode 100644 index 0000000..789f0c2 --- /dev/null +++ b/MEMO.md @@ -0,0 +1,19 @@ +# Memos + +## C Help + +https://cplusplus.com/reference/cstdlib/ + +https://www.programiz.com/c-programming/library-function/ctype.h/isalnum + +## GUI Design + +Glade + +https://gitlab.gnome.org/GNOME/glade + +## Git Help + +https://git-scm.com/book/de/v2/Git-Branching-Branch-Management + +https://www.atlassian.com/de/git/tutorials/using-branches/merge-conflicts \ No newline at end of file diff --git a/calc.c b/calc.c new file mode 100644 index 0000000..5369f98 --- /dev/null +++ b/calc.c @@ -0,0 +1,295 @@ +// Funktionen zum berechnen des Ergebnis + +#include +#include +#include +#include +#include +#include "calc.h" + +const char *termstart; +int64_t result; +//uint16_t FehlerPos; //: integer; +uint16_t FehlerNum = OK; +char FehlerText[MAX_ERROR_LEN] = {0}; //: string; +//void *pVari = 0; //: PVarArray; + +// Zeichen bzw. Symbole für Rechenoperation +// << Bits links schieben, >> Bits rechts schieben +// & AND, | OR, ~ XOR +const char *OpStr[OP_NUMBER] = {"+","-","*","/",">>","<<","&","|","~"}; //: array[0..8] of string = ('+','-','*','/','>>','<<','&','|','~'); + +bool find_operation(const char *pStart, const char *pEnd, const char *Opp, const char **pOpp); +uint16_t term_disassemble(const char *term, const char *term_end, int64_t *subresult); + +/** *************************************************************************** + * Name + * + * Discription + * + * @param term Term-String, der berechnet werden soll + * @return Fehlernummer + *************************************************************************** */ +uint16_t calc_term(const char *term) +{ + result = 0; + FehlerNum = OK; + if (!term) { + FehlerNum = ERR_TERM_EMPTY; + return FehlerNum; + } + + if (!strlen(term)) { + FehlerNum = ERR_TERM_EMPTY; + return FehlerNum; + } + + termstart = term; + + printf("Start Term [%s] %p %p \n", term, term, term + strlen(term)); + + return term_disassemble(term, term + strlen(term) - 1, &result); +} + +/** *************************************************************************** + * term_disassemble : + * + * Teilt den Term in seine Bestandteile auf + * + * @param term String des Term der entschlüsselt werden soll + * @param term_end Zeige auf letztes Zeichen des Terms + * @return Fehlernummer + *************************************************************************** */ +uint16_t term_disassemble(const char *term, const char *term_end, int64_t *subresult) +{ + const char *pPos = term; // Zeiger auf Position die verarbeitet wird + const char *pEnd = term_end; // Zeiger auf Ende des Terms + const char *pOpp = NULL; + int32_t i = 0; //: integer; + int64_t left_opp = 0; //left operant : integer; + int64_t right_opp = 0; //right operant : integer; + int64_t tempresult = 0; + + printf("Sub Term 1 [%ld] [%ld] \n", pPos-termstart, pEnd-termstart); + + if (FehlerNum != OK) { + return FehlerNum; + } + + // Trim left (find begin) + while (isspace(*pPos) && (pPos < pEnd)) { + pPos++; + } + + printf("Sub Term 2 [%ld] [%ld] \n", pPos-termstart, pEnd-termstart); + + // Trim right (find end) + while(pPos <= pEnd) { + if (!isspace(*pEnd)) { + break; + } + pEnd--; + } + + printf("Sub Term 3 [%ld] [%ld] \n", pPos-termstart, pEnd-termstart); + + if (pPos > pEnd) { + // Leerer Term + return WARN_EMPTY_TERM; + } + + printf("Sub Term 4 [%ld] [%ld] \n", pPos-termstart, pEnd-termstart); + + printf("Subterm start[%d] end[%d] schar[%c] echar[%c]\n" + , (uint16_t)(pPos-termstart), (uint16_t)(pEnd-termstart), (char)*pPos, (char)*pEnd); + + i = 0; + uint16_t err = 0; + while (i < OP_NUMBER) { + if (find_operation(pPos, pEnd, OpStr[i], &pOpp)) { + printf("Operation erkannt [%s] Pos[%d]\n", OpStr[i], (uint16_t)(pOpp-termstart)); + err = term_disassemble(pPos, pOpp-1, &left_opp); + if (err) { + if (err != WARN_EMPTY_TERM || *OpStr[i] != '-') { + return FehlerNum; + } + } + if (term_disassemble(pOpp+1, pEnd, &right_opp)) { + return FehlerNum; + } + + printf("Rechen Operanten %ld %s %ld\n", left_opp, OpStr[i], right_opp); + + switch (i) { + case 0: tempresult = left_opp + right_opp; break; + case 1: + if (err == WARN_EMPTY_TERM) { + // Vorzeichen + tempresult = right_opp * -1; + } else { + // Rechenoperation + tempresult = left_opp - right_opp; + } + break; + + case 2: tempresult = left_opp * right_opp; break; + case 3: tempresult = left_opp / right_opp; break; + case 4: tempresult = left_opp >> right_opp; break; + case 5: tempresult = left_opp << right_opp; break; + case 6: tempresult = left_opp & right_opp; break; + case 7: tempresult = left_opp | right_opp; break; + case 8: tempresult = left_opp ^ right_opp; break; + default: + ; + } + printf("Zwischenergebnis %ld\n", tempresult); + *subresult = tempresult; + return OK; + } + i++; + } + + // Ist Term in Klammern + if (*pPos == '(') { + if (*pEnd == ')') { + printf("Klammerauflösung\n"); + if (term_disassemble(pPos+1, pEnd-1, &tempresult)) { + return FehlerNum; + } + *subresult = tempresult; + return OK; + } else { + FehlerNum = ERR_BRACKET_CLOSE; + return FehlerNum; + } + } + + // Auf Variable oder Funktion prüfen + if (isalpha(*pPos) || *pPos == '_') { + printf("Variablenauflösung\n"); + uint16_t i = 0; + char *pVarEnd; + pVarEnd = (char*)pPos; +#warning Fehler zu langer Variablenname abfangen + while ((pVarEnd <= pEnd) && (isalnum(*pVarEnd) || *pVarEnd == '_')) { + pVarEnd++; + i++; + } + char varName[64] = {0}; + strncpy(varName, pPos, i-1); + *pVarEnd = '\0'; + printf("Variable %s erkannt\n", varName); + + snprintf(FehlerText, MAX_ERROR_LEN, "Syntax Fehler, Variable unbekannt."); + FehlerNum = ERR_UNKNOWN_VARIABLE; + return FehlerNum; + } + + // Wenn mit Komma beginnt = 0,xx + if (*pPos == ',') { + + } + + // Wenn Term eine Zahl ist + if (isdigit(*pPos)) { + while(isdigit(*pPos) && pPos <= pEnd) { + tempresult *= 10; + tempresult += *pPos & 0x0f; + pPos++; + } + printf("Zahl erkannt %ld\n", tempresult); + *subresult = tempresult; + } else { + FehlerNum = ERR_UNKNOWN; + return FehlerNum; + } + + return OK; +} +// ^^ TermZerlegung ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +/** *************************************************************************** + * find_operation + * + * Sucht die Rechenopertion, und gibt die Position zurück. In Klammern wird + * nicht gesucht. + * + * @param Term Term, der nach einer Operation/Verknüpfung durchsucht werden soll + * @param Opp Operation/Verknüpfung nach der in Term gesucht werden soll + * @param pPos Rückgabe der Position an der die Operation gefunden wurde + * @return true wenn Rechenoperation gefunden + *************************************************************************** */ +//bool find_operation(const char *subterm, const char *Opp, const char **pPos) +bool find_operation(const char *pPos, const char *pEnd, const char *Opp, const char **pOpp) +{ + uint16_t i = 0; // Zeichenzähler + uint16_t k = 0; // Klammerzähler, '(' plus 1 ; ')' minus 1 + + while (pPos <= pEnd) { + if (*pPos == '(') { + k++; + } + + if (*pPos == ')') { + if (k == 0) { + FehlerNum = ERR_BRACKET_OPEN; + snprintf(FehlerText, MAX_ERROR_LEN, "Klammer nicht geöffnet."); + return false; + } + k--; + } + + if ((k == 0) && !strncmp(pPos, Opp, strlen(Opp))) { + printf("Find Opp start[%d] end[%d] Opp[%s]\n", (uint16_t)(pPos-termstart), (uint16_t)(pEnd-termstart), Opp); + *pOpp = pPos; + return true; + } + i++; + pPos++; + } + + if (k > 0) { + FehlerNum = ERR_BRACKET_CLOSE; + snprintf(FehlerText, MAX_ERROR_LEN, "Geöffnete Klammer gefunden, die nicht geschlossen wird."); + return false; + } + + return false; +} +// ^^ find_operation ^^^^^^^^^^^^^^^^^^^^^^^^^^ + +/** *************************************************************************** + * Name + * + * Discription + * + * @param a Discription + * @return no + *************************************************************************** */ +int64_t get_calc_result() { + return result; +} + +/** *************************************************************************** + * Name + * + * Discription + * + * @param a Discription + * @return no + *************************************************************************** */ +int16_t GetFehler() { + return FehlerNum; +} + +/** *************************************************************************** + * Name + * + * Discription + * + * @param a Discription + * @return no + *************************************************************************** */ +const char *GetFehlerText() { + return NULL; +} diff --git a/calc.h b/calc.h new file mode 100644 index 0000000..bf83b36 --- /dev/null +++ b/calc.h @@ -0,0 +1,21 @@ +#ifndef CALC_H +#define CALC_H + +#define OP_NUMBER 9 +#define MAX_ERROR_LEN 512 + +enum ERROR { + OK = 0, + ERR_UNKNOWN, + ERR_BRACKET_OPEN, + ERR_BRACKET_CLOSE, + ERR_TERM_EMPTY, + ERR_SHORT_TERM, + ERR_UNKNOWN_VARIABLE, + WARN_EMPTY_TERM +}; + +uint16_t calc_term(const char *term); +int64_t get_calc_result(); + +#endif \ No newline at end of file diff --git a/calc.pas b/calc.pas new file mode 100644 index 0000000..51700ab --- /dev/null +++ b/calc.pas @@ -0,0 +1,249 @@ +unit IntegerTerm; + +interface + +uses SysUtils; + +type + VarRec = record + Name: string; + Wert: variant; + end; + VarArray = array of VarRec; + PVarArray = ^VarArray; + + TIntTerm = class + constructor Create(); + private + { Private-Deklarationen } + pVari: PVarArray; + FehlerPos: integer; + FehlerLaenge: integer; + FehlerText: string; + procedure FindeOperation(Term, Op: string; pPos: pinteger; p: integer); + function TermZerlegung(Term: string; p: integer): integer; + procedure SetFehlerMeldung(s: string; p: integer; l: integer); + public + { Public-Deklarationen } + function TermLoesen(Term: string; pVariablen: PVarArray): integer; + function GetFehler(FPos, FLaenge: pinteger): integer; + function GetFehlerText: string; + end; + +const + // Zeichen bzw. Symbole für Rechenoperation + // << Bits links schieben, >> Bits rechts schieben + // & AND, | OR, ~ XOR + OpStr: array[0..8] of string = ('+','-','*','/','>>','<<','&','|','~'); + +implementation + +constructor TIntTerm.Create; +begin + pVari := nil; + FehlerPos := 0; + FehlerLaenge := 0; + FehlerText := ''; +end; + +function TIntTerm.TermLoesen(Term: string; pVariablen: PVarArray): integer; +begin + FehlerPos := 0; + FehlerText := ''; + pVari := pVariablen; + result := TermZerlegung(Term, 1); +end; + +// ----------------------------------------------------------------------------- +// FindeOperation +// +// Sucht die Rechenopertion, und gibt die Position zurück. In Klammern wird +// nicht gesucht. +// +// Term : Term, der nach einer Operation/Verknüpfung durchsucht werden soll +// Op : Operation/Verknüpfung nach der in Term gesucht werden soll +// pPos : Rückgabe der Position an der die Operation gefunden wurde +// p : Zeichenposition im gesamt Term. Dient der Fehlerausgabe +// ----------------------------------------------------------------------------- +procedure TIntTerm.FindeOperation(Term: string; Op: string; pPos: pinteger; p: integer); +var + n: integer; // Zeichenzähler + k: integer; // Klammerzähler, '(' plus 1 ; ')' minus 1 + kPos: integer; // Merker für Position der ersten Klammer (Fehlerausgabe) +begin + kPos := 0; + k := 0; + for n := 1 to length(Term) do + begin + if term[n] = '(' then + begin + if k = 0 then + kPos := n; + inc(k); + end; + if term[n] = ')' then + begin + dec(k); + if k < 0 then + begin + SetFehlerMeldung('Klammer nicht geöffnet.', p+n-1, 1); + exit; + end; + end; + // if (k = 0) and (term[n] = Op) then + if (k = 0) and (copy(term, n, length(Op)) = Op) then + begin + pPos^ := n; + exit; + end; + end; + pPos^ := 0; + if k > 0 then + SetFehlerMeldung('Öffnende Klammer gefunden, die nicht geschlossen wird.', p+kPos-1, 1); +end; +// ^^ FindeOperation ^^^^^^^^^^^^^^^^^^^^^^^^^^ + +// ----------------------------------------------------------------------------- +// TermZerlegung +// +// Teilt den Term in seine Bestandteile auf +// +// Term : String des Term der entschlüsselt werden soll +// p : Zeichenposition im gesamt Term. Dient der Fehlerausgabe +// ----------------------------------------------------------------------------- +function TIntTerm.TermZerlegung(Term: string; p: integer): integer; +var + i: integer; + n: integer; + o1: integer; + o2: integer; + TempStr: string; +begin + result := 0; + + if FehlerPos > 0 then + begin + result := 1; + exit; + end; + + p := p + length(Term) - length(TrimLeft(Term)); + Term := trim(Term); + + i := 0; + while (i <= high(OpStr)) do + begin + FindeOperation(Term, OpStr[i], @n, p); + if n > 0 then + begin + o1 := TermZerlegung(copy(Term, 1, n-1), p); + o2 := TermZerlegung(copy(Term, n+length(OpStr[i]), length(Term)-n), p+n+length(OpStr[i])-1); + case i of + 0: result := o1 + o2; + 1: result := o1 - o2; + 2: result := o1 * o2; + 3: result := o1 div o2; + 4: result := o1 shr o2; + 5: result := o1 shl o2; + 6: result := o1 and o2; + 7: result := o1 or o2; + 8: result := o1 xor o2; + end; + exit; + end; + inc(i); + end; + + // Ist Term in Klammern + if Term[1] = '(' then + begin + if Term[length(Term)] = ')' then + begin + result := TermZerlegung(trim(copy(Term, 2, length(Term)-2)), p+1); + exit; + end; + end; + + // Auf Variable oder Funktion prüfen + if Term[1] in ['a'..'z','A'..'Z','_'] then + begin + i := 2; + while ((i <= length(Term)) and (Term[1] in ['a'..'z','A'..'Z','_','0'..'9'])) do + begin + inc(i); + end; + TempStr := copy(Term, 1, i-1); + + // Auf Variablen prüfen + if assigned(pVari) then + begin + for n := low(pVari^) to high(pVari^) do + begin + if lowercase(pVari^[n].Name) = lowercase(TempStr) then + begin + result := pVari^[n].Wert; + exit; + end; + end; + end; + SetFehlerMeldung('Syntax Fehler, Variable "'+TempStr+'" unbekannt.', p, length(TempStr)); + + // Auf Funktionen prüfen (z.B. Not, sin, cos) + end; + + // Wenn Term eine Zahl ist + if Term[1] in ['0'..'9'] then + begin + try + result := StrToInt(Term); + except + SetFehlerMeldung('Syntax Fehler, "'+Term+'" ist keine gültige Zahl.', p, length(Term)); + end; + exit; + end; +end; +// ^^ TermZerlegung ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +procedure TIntTerm.SetFehlerMeldung(s: string; p: integer; l: integer); +begin + FehlerPos := p; + FehlerLaenge := l; + FehlerText := s; + raise Exception.Create(s); +end; + +function TIntTerm.GetFehler(FPos: pinteger; FLaenge: pinteger): integer; +begin + result := 0; + FPos^ := FehlerPos; + FLaenge^ := FehlerLaenge; + if FehlerPos > 0 then + result := -1; +end; + +function TIntTerm.GetFehlerText(): string; +begin + result := FehlerText; +end; + + +{ +procedure TForm1.Button1Click(Sender: TObject); +var + test: VarArray; +begin + SetLength(test, 4); + test[0].Name := 'ertz'; + test[0].Wert := 25; + test[1].Name := 's34'; + test[1].Wert := 3; + test[2].Name := 'w3tz'; + test[2].Wert := 18; + test[3].Name := 'w'; + test[3].Wert := 9; + Memo1.Clear; + Memo1.Lines.Add(format('Ergebnis = %d',[TermLoesen(Edit1.Text, @test)])); +end; +} + +end. \ No newline at end of file diff --git a/main.c b/main.c index 5c57300..5c99823 100644 --- a/main.c +++ b/main.c @@ -1,85 +1,113 @@ #include +// https://docs.gtk.org/gtk4/ + +#include "calc.h" + +#define BUTTON_NUM 20 GtkWidget *window; GtkWidget *entry; GtkWidget *button; GtkWidget *grid; -GtkWidget *buttons[10]; +GtkWidget *buttons[BUTTON_NUM]; GtkWidget *box; +const char *buttonlabels[BUTTON_NUM] = {"C","/","*","-","7","8","9","+","4","5","6","(","1","2","3",")"," ","0",",","="}; + // Funktion zum Behandeln des Button-Klicks -void button_clicked(GtkWidget *button, gpointer data) { - const char *text = gtk_entry_get_text(GTK_ENTRY(data)); +void button_clicked(GtkWidget *button, gpointer data) +{ + const char *text = gtk_editable_get_text(GTK_EDITABLE(data)); printf("Der eingegebene Text ist: %s\n", text); } // Funktion zum Behandeln der Ziffern-Buttons -void number_button_clicked(GtkWidget *button, gpointer data) { - const char *number = gtk_button_get_label(GTK_BUTTON(button)); - gtk_entry_set_text(GTK_ENTRY(data), number); -// gtk_entry_append_text(GTK_ENTRY(data), number); +void number_button_clicked(GtkWidget *button, gpointer data) +{ + const char *label = gtk_button_get_label(GTK_BUTTON(button)); + char button_char = *label; + switch (button_char) { + case 'C': + gtk_editable_set_text(GTK_EDITABLE(data), ""); + break; + case '=': + // rechne Ergebnis aus; + const char *term = gtk_editable_get_text(GTK_EDITABLE(data)); + if (!calc_term(term)) { + printf("Kein Fehler. Ergebnis : %ld\n", get_calc_result()); + } else { + printf("Fehler aufgetreten\n"); + } + break; + default: + GtkEntryBuffer *buffer = gtk_entry_get_buffer (GTK_ENTRY(data)); + gtk_entry_buffer_insert_text (buffer, -1, label, -1); + } } -int main(int argc, char *argv[]) { - gtk_init(&argc, &argv); - +static void activate (GtkApplication *app, gpointer user_data) +{ // Erstellen Sie ein Fenster - window = gtk_window_new(GTK_WINDOW_TOPLEVEL); - gtk_window_set_title(GTK_WINDOW(window), "Hello World"); - gtk_window_set_default_size(GTK_WINDOW(window), 300, 100); + window = gtk_application_window_new (app); + gtk_window_set_title(GTK_WINDOW(window), "Hello World Gtk4"); + gtk_window_set_default_size(GTK_WINDOW(window), 320, 100); - // Erstellen Sie ein Eingabefeld + // Erstellt ein Eingabefeld entry = gtk_entry_new(); - // Erstellen Sie einen Button + // Erstellt einen Button button = gtk_button_new_with_label("Eingabe ausgeben"); - - // Verbinden Sie den Button-Klick mit der Funktion button_clicked + + // Verbindt den Button-Klick mit der Funktion button_clicked g_signal_connect(button, "clicked", G_CALLBACK(button_clicked), entry); - // Verbinden Sie den delete-event-Handler mit gtk_main_quit() - g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL); - -/**/ - - // Erstellen Sie ein GtkGrid-Widget für den Tastenblock + // Erstellt ein GtkGrid-Widget für den Tastenblock grid = gtk_grid_new(); gtk_grid_set_column_spacing(GTK_GRID(grid), 5); gtk_grid_set_row_spacing(GTK_GRID(grid), 5); - // Erstellen Sie 10 Buttons für die Ziffern 0-9 - for (int i = 0; i < 10; i++) { - buttons[i] = gtk_button_new_with_label(g_strdup_printf("%d", i)); + for (int i = 0; i < BUTTON_NUM; i++) { + // Erstellen der Buttons + buttons[i] = gtk_button_new_with_label(buttonlabels[i]); g_signal_connect(buttons[i], "clicked", G_CALLBACK(number_button_clicked), entry); - } - // Fügen Sie die Buttons in das Grid-Widget ein - int row = 0, column = 0; - for (int i = 0; i < 10; i++) { - gtk_grid_attach(GTK_GRID(grid), buttons[i], column, row, 1, 1); - if (column == 2) { - column = 0; - row++; - } else { - column++; - } + // Fügt die Buttons in das Grid-Widget ein + gtk_grid_attach(GTK_GRID(grid), buttons[i], i % 4, i / 4, 1, 1); } -/**/ // Erstellen Sie einen Box-Container und fügen Sie das Eingabefeld, den Button und den Tastenblock hinzu - box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); - gtk_box_pack_start(GTK_BOX(box), entry, TRUE, TRUE, 0); - gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0); - gtk_box_pack_start(GTK_BOX(box), grid, TRUE, TRUE, 0); + box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); + gtk_box_append(GTK_BOX(box), entry); + gtk_widget_set_margin_top(entry, 10); + gtk_widget_set_margin_start(entry, 10); + gtk_widget_set_margin_end(entry, 10); + + gtk_box_append(GTK_BOX(box), grid); + gtk_widget_set_halign(grid, GTK_ALIGN_CENTER); + gtk_widget_set_margin_top(grid, 10); + gtk_widget_set_margin_bottom(grid, 10); + + gtk_box_append(GTK_BOX(box), button); + gtk_widget_set_margin_start(button, 10); + gtk_widget_set_margin_end(button, 10); + gtk_widget_set_margin_bottom(button, 10); // Fügen Sie den Box-Container zum Fenster hinzu - gtk_container_add(GTK_CONTAINER(window), box); + gtk_window_set_child (GTK_WINDOW (window), box); + + gtk_window_present (GTK_WINDOW (window)); +} - // Zeigen Sie alle Widgets an - gtk_widget_show_all(window); - // Starten Sie die GTK+-Hauptschleife - gtk_main(); +int main (int argc, char **argv) +{ + GtkApplication *app; + int status; - return 0; -} + app = gtk_application_new("org.gtk.example", G_APPLICATION_FLAGS_NONE); + g_signal_connect(app, "activate", G_CALLBACK (activate), NULL); + status = g_application_run (G_APPLICATION (app), argc, argv); + g_object_unref (app); + + return status; +} \ No newline at end of file diff --git a/makefile b/makefile index d9d1c9d..5f9b9f0 100644 --- a/makefile +++ b/makefile @@ -4,35 +4,27 @@ PROJECT = taschenrechner # Quellcodedateien SRCS = \ main.c \ -# button_handler.c + calc.c # Headerdateien HDRS = \ -# button_handler.h + calc.h # Bibliotheken LIBS = \ - -lgtk3 + -lgtk4 # Objektdateien OBJS = $(SRCS:.c=.o) # Flagge für GTK+-Entwicklung -GTK3_CFLAGS = -Wall `pkg-config --cflags glib-2.0` \ - -I/usr/include/gtk-3.0 \ - -I/usr/include/glib-2.0 \ - -I/usr/include/pango-1.0 \ - -I/usr/include/harfbuzz \ - -I/usr/include/cairo \ - -I/usr/include/gdk-pixbuf-2.0 \ - -I/usr/include/atk-1.0 +GTK3_CFLAGS = -Wall `pkg-config --cflags gtk4` # Flagge für C-Compiler CFLAGS = $(GTK3_CFLAGS) # Flagge für Linker -LDFLAGS = `pkg-config --libs gtk+-3.0` -L/usr/local/lib -L/usr/lib -#LDFLAGS = `pkg-config --libs glib-2.0` -L/usr/local/lib -L/usr/lib +LDFLAGS = `pkg-config --libs gtk4` -L/usr/local/lib -L/usr/lib # Programmname PROGRAM = $(PROJECT) diff --git a/settings.json b/settings.json index c401ec2..6f4ac5a 100644 --- a/settings.json +++ b/settings.json @@ -1,5 +1,5 @@ { "c_cpp.includePath": [ - "/usr/include/gtk-3.0" // Ersetzen Sie diesen Pfad nach Bedarf + "/usr/include/gtk-4.0" // Ersetzen Sie diesen Pfad nach Bedarf ] } \ No newline at end of file