Membuat Aplikasi Desktop Native dengan SQLite dan GTK: Panduan Lengkap

Aplikasi desktop native menawarkan pengalaman pengguna yang unggul dalam hal performa, akses ke sumber daya sistem, dan integrasi dengan sistem operasi. Dengan SQLite dan GTK, Anda dapat membuat aplikasi desktop yang kuat, ringan, dan cross-platform. Artikel ini akan memandu Anda melalui proses pembuatan aplikasi desktop native menggunakan SQLite untuk penyimpanan data dan GTK untuk antarmuka pengguna.

Mengapa SQLite dan GTK?

• SQLite: Database embedded yang ringan dan self-contained. Tidak memerlukan server database terpisah, membuatnya ideal untuk aplikasi desktop. SQLite sangat stabil, reliabel, dan mendukung standar SQL.
• GTK (GIMP Toolkit): Toolkit GUI cross-platform yang populer untuk membuat antarmuka pengguna grafis. GTK menawarkan berbagai macam widget dan kontrol yang dapat disesuaikan, serta mendukung berbagai bahasa pemrograman seperti C, C++, Python, dan lainnya.

Target Audiens

Artikel ini ditujukan untuk pengembang perangkat lunak yang:

• Ingin mempelajari cara membuat aplikasi desktop native.
• Familiar dengan konsep pemrograman dasar.
• Memiliki pengalaman dengan setidaknya satu bahasa pemrograman (seperti C, C++, atau Python).
• Tertarik menggunakan SQLite dan GTK untuk pengembangan aplikasi desktop.

Prasyarat

Sebelum memulai, pastikan Anda memiliki prasyarat berikut:

1. Lingkungan Pengembangan: Siapkan lingkungan pengembangan dengan compiler C/C++ (seperti GCC atau MinGW) atau interpreter Python.
2. SQLite: Instal library SQLite. Anda dapat mengunduh precompiled binaries atau menginstal melalui package manager sistem operasi Anda.
3. GTK: Instal GTK. Ini biasanya melibatkan penginstalan GTK development packages menggunakan package manager sistem operasi Anda. Pastikan Anda menginstal versi GTK yang sesuai dengan bahasa pemrograman yang Anda gunakan.
4. Text Editor/IDE: Gunakan text editor atau IDE yang Anda sukai untuk menulis kode.

Kerangka Aplikasi Desktop

Berikut adalah kerangka dasar untuk aplikasi desktop yang akan kita buat:

1. Persiapan Lingkungan Pengembangan: Konfigurasi lingkungan pengembangan dengan SQLite dan GTK.
2. Perancangan Database SQLite: Merancang skema database untuk menyimpan data aplikasi.
3. Pembuatan Antarmuka Pengguna GTK: Membuat antarmuka pengguna grafis dengan GTK.
4. Integrasi SQLite dan GTK: Menghubungkan antarmuka pengguna ke database untuk membaca dan menulis data.
5. Penanganan Event: Menangani event pengguna (seperti klik tombol) untuk berinteraksi dengan database dan antarmuka pengguna.
6. Fitur Tambahan (Opsional): Menambahkan fitur tambahan seperti pencarian, penyortiran, dan validasi data.
7. Building dan Deployment: Membangun aplikasi dan menyebarkannya ke pengguna.

1. Persiapan Lingkungan Pengembangan

Langkah ini melibatkan konfigurasi lingkungan pengembangan Anda dengan SQLite dan GTK. Proses ini bervariasi tergantung pada sistem operasi dan bahasa pemrograman yang Anda gunakan.

Contoh untuk Linux (Ubuntu) dengan C

1. Instal SQLite: sudo apt-get update && sudo apt-get install libsqlite3-dev
2. Instal GTK: sudo apt-get install libgtk-3-dev
3. Instal Compiler (GCC): sudo apt-get install build-essential

Contoh untuk Windows dengan C (Menggunakan MinGW)

1. Instal MinGW: Unduh dan instal MinGW dari situs web resmi. Pastikan untuk memilih paket gcc, g++, dan make selama instalasi.
2. Instal SQLite: Unduh precompiled binaries SQLite dari situs web resmi. Tambahkan direktori yang berisi file DLL SQLite ke PATH sistem Anda.
3. Instal GTK: Unduh GTK runtime environment dan development files dari situs web resmi. Konfigurasikan variabel lingkungan dan compiler Anda untuk menemukan header dan library GTK.

Contoh untuk Python

1. Instal Python: Unduh dan instal Python dari situs web resmi Python (https://www.python.org/downloads/).
2. Instal Modul PyGObject: PyGObject menyediakan binding untuk GTK dalam Python. Gunakan pip: `pip install PyGObject`
3. Instal Modul SQLite: Modul SQLite sudah termasuk dalam instalasi Python standar, jadi Anda tidak perlu menginstalnya secara terpisah.

2. Perancangan Database SQLite

Langkah ini melibatkan perancangan skema database SQLite untuk menyimpan data aplikasi Anda. Anda perlu menentukan tabel, kolom, dan tipe data yang sesuai dengan kebutuhan aplikasi Anda.

Contoh Skema Database untuk Aplikasi Buku Alamat

Misalkan kita membuat aplikasi buku alamat. Kita dapat membuat tabel contacts dengan kolom-kolom berikut:

1. id: Integer, primary key, auto-increment (identitas unik untuk setiap kontak)
2. name: Text (nama kontak)
3. phone: Text (nomor telepon kontak)
4. email: Text (alamat email kontak)
5. address: Text (alamat fisik kontak)

Contoh SQL untuk Membuat Tabel

Berikut adalah contoh SQL untuk membuat tabel contacts:

CREATE TABLE contacts (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    phone TEXT,
    email TEXT,
    address TEXT
);
  

Contoh Interaksi dengan Database SQLite di C

#include <stdio.h>
#include <sqlite3.h>

int main() {
  sqlite3 *db;
  int rc = sqlite3_open("addressbook.db", &db);

  if (rc) {
    fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
    return 1;
  } else {
    fprintf(stdout, "Opened database successfully\n");
  }

  char *errMsg = 0;
  const char *sql = "CREATE TABLE contacts ("
                    "id INTEGER PRIMARY KEY AUTOINCREMENT,"
                    "name TEXT NOT NULL,"
                    "phone TEXT,"
                    "email TEXT,"
                    "address TEXT"
                    ");";

  rc = sqlite3_exec(db, sql, 0, 0, &errMsg);

  if (rc != SQLITE_OK) {
    fprintf(stderr, "SQL error: %s\n", errMsg);
    sqlite3_free(errMsg);
  } else {
    fprintf(stdout, "Table created successfully\n");
  }

  sqlite3_close(db);
  return 0;
}
  

Contoh Interaksi dengan Database SQLite di Python

import sqlite3

# Membuat koneksi ke database (atau membuatnya jika belum ada)
conn = sqlite3.connect('addressbook.db')

# Membuat objek cursor untuk mengeksekusi perintah SQL
cursor = conn.cursor()

# Membuat tabel kontak
cursor.execute('''
    CREATE TABLE IF NOT EXISTS contacts (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        phone TEXT,
        email TEXT,
        address TEXT
    )
''')

# Melakukan perubahan dan menyimpan ke database
conn.commit()

# Menutup koneksi
conn.close()
  

3. Pembuatan Antarmuka Pengguna GTK

Langkah ini melibatkan pembuatan antarmuka pengguna grafis (GUI) untuk aplikasi Anda menggunakan GTK. Anda perlu mendefinisikan jendela utama, widget (seperti tombol, label, dan text entry), dan tata letak.

Contoh Antarmuka Pengguna GTK untuk Aplikasi Buku Alamat

Antarmuka pengguna aplikasi buku alamat dapat mencakup widget-widget berikut:

1. Label: Untuk menampilkan teks statis (misalnya, “Nama:”, “Telepon:”, “Email:”, “Alamat:”).
2. Text Entry: Untuk memasukkan data (misalnya, nama, telepon, email, alamat).
3. Button: Untuk melakukan tindakan (misalnya, “Tambah”, “Ubah”, “Hapus”, “Cari”).
4. List View/Tree View: Untuk menampilkan daftar kontak.

Contoh Kode GTK (C)

#include <gtk/gtk.h>

int main(int argc, char *argv[]) {
  GtkWidget *window;
  GtkWidget *label;

  gtk_init(&argc, &argv);

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window), "Buku Alamat");
  gtk_window_set_default_size(GTK_WINDOW(window), 400, 300);
  g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);

  label = gtk_label_new("Selamat Datang di Buku Alamat!");
  gtk_container_add(GTK_CONTAINER(window), label);

  gtk_widget_show_all(window);

  gtk_main();

  return 0;
}
  

Untuk mengompilasi kode di atas, Anda bisa menggunakan perintah berikut:

gcc `pkg-config --cflags gtk+-3.0` -o addressbook addressbook.c `pkg-config --libs gtk+-3.0`
  

Pastikan pkg-config terinstal dan dikonfigurasi dengan benar agar dapat menemukan header dan library GTK.

Contoh Kode GTK (Python)

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

class AddressBookWindow(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="Buku Alamat")
        self.set_default_size(400, 300)

        label = Gtk.Label("Selamat Datang di Buku Alamat!")
        self.add(label)

win = AddressBookWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
  

4. Integrasi SQLite dan GTK

Langkah ini melibatkan menghubungkan antarmuka pengguna GTK ke database SQLite. Anda perlu membuat fungsi untuk membaca, menulis, memperbarui, dan menghapus data dari database dan menampilkannya di antarmuka pengguna.

Contoh Kode (C) – Membaca Data dari Database dan Menampilkannya di GTK List View

#include <gtk/gtk.h>
#include <sqlite3.h>
#include <stdio.h>

// Struktur untuk menyimpan data kontak
typedef struct {
    int id;
    char *name;
    char *phone;
    char *email;
    char *address;
} Contact;

// Fungsi untuk membaca data dari database
GList* read_contacts_from_db(sqlite3 *db) {
    GList *contacts = NULL;
    sqlite3_stmt *stmt;
    const char *sql = "SELECT id, name, phone, email, address FROM contacts;";

    if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) == SQLITE_OK) {
        while (sqlite3_step(stmt) == SQLITE_ROW) {
            Contact *contact = g_new0(Contact, 1);
            contact->id = sqlite3_column_int(stmt, 0);
            contact->name = g_strdup((const char*)sqlite3_column_text(stmt, 1));
            contact->phone = g_strdup((const char*)sqlite3_column_text(stmt, 2));
            contact->email = g_strdup((const char*)sqlite3_column_text(stmt, 3));
            contact->address = g_strdup((const char*)sqlite3_column_text(stmt, 4));
            contacts = g_list_append(contacts, contact);
        }
        sqlite3_finalize(stmt);
    } else {
        fprintf(stderr, "Error preparing statement: %s\n", sqlite3_errmsg(db));
    }
    return contacts;
}

// Fungsi untuk menampilkan data kontak di GTK List View
void populate_list_view(GtkWidget *list_view, sqlite3 *db) {
    GtkListStore *store = gtk_list_store_new(5, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
    GList *contacts = read_contacts_from_db(db);
    GList *current = contacts;

    while (current != NULL) {
        Contact *contact = (Contact*)current->data;
        GtkTreeIter iter;
        gtk_list_store_append(store, &iter);
        gtk_list_store_set(store, &iter,
                           0, contact->id,
                           1, contact->name,
                           2, contact->phone,
                           3, contact->email,
                           4, contact->address,
                           -1);
        current = current->next;
    }

    gtk_tree_view_set_model(GTK_TREE_VIEW(list_view), GTK_TREE_MODEL(store));

    // Free memory allocated for contacts
    current = contacts;
    while (current != NULL) {
        Contact *contact = (Contact*)current->data;
        g_free(contact->name);
        g_free(contact->phone);
        g_free(contact->email);
        g_free(contact->address);
        g_free(contact);
        current = g_list_remove(current, current->data);
    }
}

int main(int argc, char *argv[]) {
    GtkWidget *window;
    GtkWidget *list_view;
    GtkWidget *scrolled_window;

    sqlite3 *db;
    int rc = sqlite3_open("addressbook.db", &db);

    if (rc) {
        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
        return 1;
    }

    gtk_init(&argc, &argv);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), "Buku Alamat");
    gtk_window_set_default_size(GTK_WINDOW(window), 600, 400);
    g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);

    // Create a list view
    list_view = gtk_tree_view_new();

    // Create columns for the list view
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("ID", renderer, "text", 0, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Name", renderer, "text", 1, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Phone", renderer, "text", 2, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Email", renderer, "text", 3, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Address", renderer, "text", 4, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);

    // Create a scrolled window to contain the list view
    scrolled_window = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
                                   GTK_POLICY_AUTOMATIC,
                                   GTK_POLICY_AUTOMATIC);
    gtk_container_add(GTK_CONTAINER(scrolled_window), list_view);
    gtk_container_add(GTK_CONTAINER(window), scrolled_window);

    // Populate the list view with data from the database
    populate_list_view(list_view, db);

    gtk_widget_show_all(window);

    gtk_main();

    sqlite3_close(db);
    return 0;
}
  

Contoh Kode (Python) – Membaca Data dari Database dan Menampilkannya di GTK List View

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
import sqlite3

class AddressBookWindow(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="Buku Alamat")
        self.set_default_size(600, 400)

        # Membuat koneksi ke database
        self.conn = sqlite3.connect('addressbook.db')
        self.cursor = self.conn.cursor()

        # Membuat ListStore untuk menyimpan data
        self.liststore = Gtk.ListStore(int, str, str, str, str)

        # Membuat TreeView untuk menampilkan data
        self.treeview = Gtk.TreeView(model=self.liststore)

        # Membuat kolom-kolom di TreeView
        for i, column_title in enumerate(["ID", "Name", "Phone", "Email", "Address"]):
            renderer = Gtk.CellRendererText()
            column = Gtk.TreeViewColumn(column_title, renderer, text=i)
            self.treeview.append_column(column)

        # Memuat data dari database dan menampilkannya
        self.load_data()

        # Membuat ScrolledWindow untuk TreeView
        scrolled_window = Gtk.ScrolledWindow()
        scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        scrolled_window.add(self.treeview)

        self.add(scrolled_window)
        self.connect("destroy", self.on_destroy)
        self.show_all()


    def load_data(self):
        # Membersihkan data yang ada di ListStore
        self.liststore.clear()

        # Mengeksekusi query untuk membaca data dari database
        self.cursor.execute("SELECT id, name, phone, email, address FROM contacts")
        rows = self.cursor.fetchall()

        # Menambahkan data ke ListStore
        for row in rows:
            self.liststore.append(list(row))

    def on_destroy(self, widget):
        self.conn.close()
        Gtk.main_quit()


win = AddressBookWindow()
Gtk.main()
  

5. Penanganan Event

Langkah ini melibatkan penanganan event pengguna (seperti klik tombol) untuk berinteraksi dengan database dan antarmuka pengguna. Anda perlu mendefinisikan callback functions yang akan dieksekusi ketika event tertentu terjadi.

Contoh Kode (C) – Menangani Klik Tombol “Tambah”

#include <gtk/gtk.h>
#include <sqlite3.h>
#include <stdio.h>
#include <string.h>

// Callback function untuk tombol "Tambah"
void on_add_button_clicked(GtkWidget *button, gpointer data) {
    // Dapatkan data dari entry fields
    GtkWidget *name_entry = (GtkWidget *)g_object_get_data(G_OBJECT(data), "name_entry");
    GtkWidget *phone_entry = (GtkWidget *)g_object_get_data(G_OBJECT(data), "phone_entry");
    GtkWidget *email_entry = (GtkWidget *)g_object_get_data(G_OBJECT(data), "email_entry");
    GtkWidget *address_entry = (GtkWidget *)g_object_get_data(G_OBJECT(data), "address_entry");

    const char *name = gtk_entry_get_text(GTK_ENTRY(name_entry));
    const char *phone = gtk_entry_get_text(GTK_ENTRY(phone_entry));
    const char *email = gtk_entry_get_text(GTK_ENTRY(email_entry));
    const char *address = gtk_entry_get_text(GTK_ENTRY(address_entry));

    // Buka koneksi database
    sqlite3 *db;
    int rc = sqlite3_open("addressbook.db", &db);
    if (rc) {
        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
        return;
    }

    // Siapkan pernyataan SQL untuk menyisipkan data
    char *errMsg = 0;
    char sql[500];
    snprintf(sql, sizeof(sql), "INSERT INTO contacts (name, phone, email, address) VALUES ('%s', '%s', '%s', '%s');", name, phone, email, address);

    // Eksekusi pernyataan SQL
    rc = sqlite3_exec(db, sql, 0, 0, &errMsg);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "SQL error: %s\n", errMsg);
        sqlite3_free(errMsg);
    } else {
        printf("Record created successfully\n");

        // Setelah menambahkan data, bersihkan entry fields
        gtk_entry_set_text(GTK_ENTRY(name_entry), "");
        gtk_entry_set_text(GTK_ENTRY(phone_entry), "");
        gtk_entry_set_text(GTK_ENTRY(email_entry), "");
        gtk_entry_set_text(GTK_ENTRY(address_entry), "");

        // Update list view (harus diimplementasikan)
        // populate_list_view(list_view, db);
    }

    // Tutup koneksi database
    sqlite3_close(db);
}

int main(int argc, char *argv[]) {
  // ... (Inisialisasi GTK, buat jendela, label, tombol, dll.)

  // Contoh pembuatan tombol "Tambah"
  GtkWidget *add_button = gtk_button_new_with_label("Tambah");

  // Membuat entry fields untuk data kontak (misalnya, name_entry, phone_entry, email_entry, address_entry)
  GtkWidget *name_entry = gtk_entry_new();
  GtkWidget *phone_entry = gtk_entry_new();
  GtkWidget *email_entry = gtk_entry_new();
  GtkWidget *address_entry = gtk_entry_new();

  // Mengemas semua widget (harus diimplementasikan)

  // Siapkan data untuk diteruskan ke callback function
  gpointer data = (gpointer)g_object_new(G_TYPE_OBJECT, NULL);
  g_object_set_data(G_OBJECT(data), "name_entry", name_entry);
  g_object_set_data(G_OBJECT(data), "phone_entry", phone_entry);
  g_object_set_data(G_OBJECT(data), "email_entry", email_entry);
  g_object_set_data(G_OBJECT(data), "address_entry", address_entry);

  // Hubungkan sinyal "clicked" ke callback function
  g_signal_connect(add_button, "clicked", G_CALLBACK(on_add_button_clicked), data);

  // ... (Tampilkan semua widget dan jalankan main loop)
}
  

Contoh Kode (Python) – Menangani Klik Tombol “Tambah”

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
import sqlite3

class AddressBookWindow(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="Buku Alamat")
        self.set_default_size(600, 400)

        # Membuat koneksi ke database
        self.conn = sqlite3.connect('addressbook.db')
        self.cursor = self.conn.cursor()

        # Membuat ListStore untuk menyimpan data
        self.liststore = Gtk.ListStore(int, str, str, str, str)

        # Membuat TreeView untuk menampilkan data
        self.treeview = Gtk.TreeView(model=self.liststore)

        # Membuat kolom-kolom di TreeView
        for i, column_title in enumerate(["ID", "Name", "Phone", "Email", "Address"]):
            renderer = Gtk.CellRendererText()
            column = Gtk.TreeViewColumn(column_title, renderer, text=i)
            self.treeview.append_column(column)

        # Membuat Entry Fields dan Labels
        self.name_entry = Gtk.Entry()
        self.phone_entry = Gtk.Entry()
        self.email_entry = Gtk.Entry()
        self.address_entry = Gtk.Entry()

        name_label = Gtk.Label("Name:")
        phone_label = Gtk.Label("Phone:")
        email_label = Gtk.Label("Email:")
        address_label = Gtk.Label("Address:")

        # Membuat tombol Tambah
        self.add_button = Gtk.Button(label="Tambah")
        self.add_button.connect("clicked", self.on_add_clicked)

        # Mengatur Layout (contoh sederhana menggunakan Grid)
        grid = Gtk.Grid()
        grid.set_column_spacing(5)
        grid.set_row_spacing(5)

        grid.attach(name_label, 0, 0, 1, 1)
        grid.attach(self.name_entry, 1, 0, 1, 1)
        grid.attach(phone_label, 0, 1, 1, 1)
        grid.attach(self.phone_entry, 1, 1, 1, 1)
        grid.attach(email_label, 0, 2, 1, 1)
        grid.attach(self.email_entry, 1, 2, 1, 1)
        grid.attach(address_label, 0, 3, 1, 1)
        grid.attach(self.address_entry, 1, 3, 1, 1)
        grid.attach(self.add_button, 1, 4, 1, 1)
        grid.attach(Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), 0, 5, 2, 1)
        grid.attach(scrolled_window, 0, 6, 2, 1) #scrolled_window dari contoh sebelumnya

        # Memuat data dari database dan menampilkannya
        self.load_data()

        # Membuat ScrolledWindow untuk TreeView
        scrolled_window = Gtk.ScrolledWindow()
        scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        scrolled_window.add(self.treeview)

        self.add(grid)
        self.connect("destroy", self.on_destroy)
        self.show_all()


    def load_data(self):
        # Membersihkan data yang ada di ListStore
        self.liststore.clear()

        # Mengeksekusi query untuk membaca data dari database
        self.cursor.execute("SELECT id, name, phone, email, address FROM contacts")
        rows = self.cursor.fetchall()

        # Menambahkan data ke ListStore
        for row in rows:
            self.liststore.append(list(row))


    def on_add_clicked(self, button):
        name = self.name_entry.get_text()
        phone = self.phone_entry.get_text()
        email = self.email_entry.get_text()
        address = self.address_entry.get_text()

        # Mengeksekusi query untuk menambahkan data ke database
        self.cursor.execute("INSERT INTO contacts (name, phone, email, address) VALUES (?, ?, ?, ?)",
                           (name, phone, email, address))
        self.conn.commit()

        # Membersihkan entry fields
        self.name_entry.set_text("")
        self.phone_entry.set_text("")
        self.email_entry.set_text("")
        self.address_entry.set_text("")

        # Memuat ulang data untuk memperbarui tampilan
        self.load_data()


    def on_destroy(self, widget):
        self.conn.close()
        Gtk.main_quit()


win = AddressBookWindow()
Gtk.main()
  

6. Fitur Tambahan (Opsional)

Setelah Anda memiliki aplikasi dasar yang berfungsi, Anda dapat menambahkan fitur tambahan untuk meningkatkan fungsionalitas dan pengalaman pengguna. Beberapa fitur tambahan yang umum meliputi:

• Pencarian: Memungkinkan pengguna mencari kontak berdasarkan nama, telepon, atau email.
• Penyortiran: Memungkinkan pengguna menyortir daftar kontak berdasarkan nama, telepon, atau email.
• Validasi Data: Memastikan bahwa data yang dimasukkan valid sebelum disimpan ke database.
• Error Handling: Menangani kesalahan dengan baik dan memberikan pesan yang informatif kepada pengguna.
• Import/Export: Memungkinkan pengguna mengimpor dan mengekspor data kontak ke dan dari file.

7. Building dan Deployment

Langkah terakhir adalah membangun aplikasi Anda dan menyebarkannya ke pengguna. Proses ini bervariasi tergantung pada bahasa pemrograman dan sistem operasi yang Anda gunakan.

Contoh untuk C

1. Kompilasi: Gunakan compiler C (seperti GCC) untuk mengkompilasi kode sumber Anda menjadi executable file.
2. Linking: Link executable file dengan library SQLite dan GTK.
3. Packaging: Buat paket instalasi yang berisi executable file, library yang diperlukan, dan file konfigurasi.

Contoh untuk Python

1. Packaging: Gunakan tools seperti PyInstaller atau cx_Freeze untuk membungkus aplikasi Python Anda menjadi executable file.
2. Distribusi: Distribusikan executable file dan library yang diperlukan ke pengguna.

Kesimpulan

Dengan SQLite dan GTK, Anda dapat membuat aplikasi desktop native yang kuat, ringan, dan cross-platform. Artikel ini telah memberikan panduan lengkap tentang cara membuat aplikasi desktop dasar menggunakan SQLite untuk penyimpanan data dan GTK untuk antarmuka pengguna. Anda dapat memperluas aplikasi ini dengan menambahkan fitur tambahan dan menyesuaikannya sesuai dengan kebutuhan Anda.

Ingatlah bahwa pengembangan aplikasi desktop melibatkan banyak detail dan pertimbangan. Penting untuk merencanakan aplikasi Anda dengan cermat, menguji kode Anda secara menyeluruh, dan memberikan dokumentasi yang jelas kepada pengguna.