Seri Tutorial Bahasa C – Bagian 10: Membuat Keluaran-keluaran Tertentu

1. Mulailah membuat sebuah program baru dengan sebuah instruksi prapemroses untuk mengikutsertakan fungsi-fungsi dalam pustaka masukan/keluaran standar.

   #include <stdio.h>

2. Tambahkan sebuah fungsi main() yang mendeklarasikan sebuah penunjuk berkas.

   int main()
   {
       FILE *p__berkas ;
   }

3. Selanjutnya dalam blok fungsi main(), cobalah untuk membuat sebuah berkas untuk ditulisi.

   p__berkas = fopen( "data.txt" , "w" ) ;

4. Sekarang, tampilkan sebuah pesan untuk memberi konfirmasi bahwa upaya tersebut berhasil, kemudian tutup berkas dan berikan keluaran sebuah bilangan bulat nol seperti yang disyaratkan dalam deklarasi fungsi.

   if( p__berkas != NULL )
   {
       printf( "Berkas telah dibuat.\n" ) ;
       fclose( p__berkas ) ;
   
       return 0 ;
   }

5. Terakhir, sebagai pesan alternatif apabila upaya tersebut gagal.

   else
   {
       printf( "Tidak bisa membuat berkas.\n" ) ;
   
       return 1 ;
   }

6. Simpanlah berkas program kemudian kompilasi dan jalankan program untuk mencoba membuat sebuah berkas teks.

1. Mulailah membuat sebuah program baru dengan sebuah instruksi prapemroses untuk mengikutsertakan fungsi-fungsi dalam pustaka masukan/keluaran standar.

   #include <stdio.h>

2. Tambahkan sebuah fungsi main() yang mendeklarasikan sebuah pointer berkas, sebuah variabel pencacah perulangan, dan sebuah larik karakter yang terinisialisasi.

   int main()
   {
       FILE *p__berkas ; int i ;
       char v__larik_karakter[30] = "Teks, satu karakter per waktu." ;
   }

3. Selanjutnya, dalam blok fungsi main(), cobalah untuk membuat sebuah berkas untuk ditulisi.

   p__berkas = fopen( "karakter.txt" , "w" ) ;

4. Sekarang tampilkan sebuah pesan untuk mengonfirmasi bahwa upaya tersebut berhasil, menulis setiap karakter dari larik, kemudian tutup berkas dan berikan keluaran sebuah bilangan bulat nol seperti yang disyaratkan.

   if( p__berkas != NULL )
   {
       printf( "Berkas karakter.txt telah dibuat.\n" ) ;
       for( i = 0; v__larik_karakter[i]; i++ ) {
           fputc( v__larik_karakter[i] , p__berkas ) ;
       }
       fclose( p__berkas ) ;
   
       return 0 ;
   }

5. Terakhir, tampilkan sebuah pesan alternatif jika upaya tersebut gagal.

   else { printf("Tidak bisa membuat berkas.\n") ; return 1 ; }

6. Simpanlah berkas program kemudian kompilasi dan jalankan program untuk mencoba menulis sebuah berkas teks.

1. Mulailah membuat sebuah program baru dengan sebuah instruksi prapemroses untuk mengikutsertakan fungsi-fungsi dalam pustaka masukan/keluaran dan fungsi kalimat standar.

   #include <stdio.h>
   #include <string.h>

2. Tambahkan sebuah fungsi main() yang mendeklarasikan sebuah berkas pointer dan sebuah larik karakter yang tak terinisialisasi.

   int main()
   {
       FILE *p__berkas ;
       char v__larik_karakter[30] ;
   }

3. Selanjutnya di dalam blok fungsi main(), cobalah untuk membuka sebuah berkas teks lokal untuk dibaca dan ditambahkan sesuatu.

   p__berkas = fopen( "bulan.txt" , "r+a" ) ;

4. Sekarang tampilkan sebuah pesan untuk mengonfirmasi apabila upaya tersebut berhasil.

   if( p__berkas != NULL )
   {
       printf( "Berkas bulan.txt telah dibuka.\n" ) ;
   }

5. Selanjutnya, dalam blok if, lakukan pembacaan dan tampilkan semua baris dari berkas.

   while ( fgets( v__larik_karakter , 30 , p__berkas) ) { printf( "%s" , v__larik_karakter ) ; }

6. Sekarang dalam blok if, salinlah sebuah kalimat baru ke larik kemudian rangkaikan kalimat tersebut ke berkas teks.

   strcpy( v__larik_karakter , ".. oleh Neil Armstrong" ) ;
   fputs( v__larik_karakter , p__berkas ) ;

7. Terakhir dalam blok if, tutuplah berkas dan berikan keluaran sebuah bilangan bulat nol seperti yang disyaratkan dalam deklarasi fungsi.

   fclose( p__berkas ) ;
   return 0 ;

8. Tambahkan sebuah pesan alternatif jika upaya tersebut gagal.

   else { printf( "Tidak bisa membuka berkas.\n" ) ; return 1 ; }

9. Simpan berkas program kemudian kompilasi dan jalankan program untuk membuka berkas dan menambahkan kalimat teks.

1. Mulailah membuat sebuah program baru dengan sebuah instruksi prapemroses untuk mengikutsertakan fungsi-fungsi dalam pustaka masukan/keluaran standar.

   #include <stdio.h>

2. Tambahkan sebuah fungsi main() yang mendeklarasikan dua pointer berkas, sebuah variabel larik karakter, dan sebuah variabel bilangan bulat.

   int main()
   {
       FILE *p__berkas_asli ;
       FILE *p__berkas_salinan ;
       char v__larik_sangga[1000] ;
       int v__banyak_objek ;
   }

3. Selanjutnya dalam blok fungsi main(), cobalah untuk membuka sebuah berkas lokal yang ada untuk dibaca dan berkas lain untuk ditulis.

   p__berkas_asli = fopen( "berkas_asli.txt" , "r" ) ;
   p__berkas_salinan = fopen( "berkas_salinan.txt" , "w" ) ;

4. Sekarang ujilah kedua berkas apabila telah berhasil dibuka.

   if( ( p__berkas_asli != NULL ) && ( p__berkas_salinan != NULL ) )
   {
   
   }

5. Dalam blok if, lakukan pembacaan isi berkas asli ke dalam larik karakter, mencacah setiap objek yang dibaca, kemudian menulis isi larik ke dalam berkas kedua.

   v__banyak_objek = fread( v__larik_sangga , 1 , 1000 , p__berkas_asli ) ;
   fwrite( v__larik_sangga , 1 , v__banyak_objek , p__berkas_salinan ) ;

6. Ingatlah untuk menutup kedua berkas teks saat proses selesai.

   fclose( p__berkas_asli ) ;
   fclose( p__berkas_salinan ) ;

7. Terakhir dalam blok if tampilkan sebuah konfirmasi, termasuk cacah objek, berikan keluaran sebuah bilangan bulat nol seperti yang disyaratkan pada deklarasi fungsi.

   printf( "Selesai: berkas_asli.txt sudah disalin ke berkas_salinan.txt" ) ;
   printf( "\n%d objek disalin.\n" , v__banyak_objek ) ;
   return 0 ;

8. Tambahkan sebuah pesan alternatif untuk apabila upaya tersebut gagal.

   else
   {
       if( p__berkas_asli == NULL ) printf( "Tidak bisa membuka berkas berkas_asli.txt.\n" ) ;
       if( p__berkas_salinan == NULL ) printf( "Tidak bisa membuka berkas berkas_salinan.txt\n" ) ;
       return 1 ;
   }

9. Simpanlah berkas program kemudian kompilasi dan jalankan program untuk membuka sebuah berkas dan menyalin isinya ke sebuah berkas baru.

1. Mulailah membuat sebuah program baru dengan sebuah instruksi prapemroses untuk mengikutsertakan fungsi-fungsi dalam pustaka masukan/keluaran standar.

   #include <stdio.h>

2. Tambahkan sebuah fungsi main() yang mendeklarasikan dua pointer berkas, sebuah variabel larik bilangan bulat, dan dua variabel bilangan bulat biasa.

   int main()
   {
       FILE *p__berkas_bilangan , *p__berkas_tulis ;
       int v__larik_bilangan[20] , i , j ;
   }

3. Selanjutnya dalam blok fungsi main(), cobalah untuk membuka sebuah berkas lokal yang ada untuk dibaca dan berkas lainnya untuk ditulis.

   p__berkas_bilangan = fopen( "berkas_bilangan.txt" , "r" ) ;
   p__berkas_tulis = fopen( "berkas_tulis.txt" , "w" ) ;

4. Sekarang ujilah kedua berkas, apakah dibuka dengan berhasil.

   if( ( p__berkas_bilangan != NULL ) && ( p__berkas_tulis != NULL ) )
   {
   
   }

5. Dalam blok if, lakukan pemindaian bilangan bulat dari berkas ke anggota larik bilangan bulat.

   for( i = 0; !feof( p__berkas_bilangan ); i++ )
   {
       fscanf( p__berkas_bilangan , "%d" , &v__larik_bilangan[i] ) ; 
   }

6. Selanjutnya, dalam blok if keluarkan nilai-nilai anggota larik.

   fprintf( stdout , "\nBanyak seluruh bilangan yang ditemukan: %d\n" , i ) ;
   for( j = 0; j < i; j++ ){ fprintf( stdout , "%d" , v__larik_bilangan[j] ) ; } ;

7. Sekarang tulis nilai-nilai anggota larik ke dalam sebuah berkas.

   fprintf( p__berkas_tulis , "fscanf dan fprintf begitu fleksibel\n" ) ;
   for( j = 0; j < i; j++ ){ fprintf( p__berkas_tulis , "%d" , v__larik_bilangan[j] ) ; }

8. Terakhir, pada blok if, tutuplah kedua berkas ketika operasinya sudah selesai.

   fclose( p__berkas_bilangan ) ;
   fclose( p__berkas_tulis ) ;

9. Tambahkan sebuah pesan alternatif untuk apabila upaya tersebut gagal.

   else
   {
       fprintf( stdout , "Tidak dapat membuka berkas.\n" ) ; return 1 ;
   }

10. Simpanlah berkas program kemudian kompilasi dan jalankan untuk membuka sebuah berkas, mengeluarkan dan menulis isinya.

1. Mulailah sebuah program baru dengan instruksi prapemroses untuk mengikutsertakan fungsi-fungsi masukan/keluaran standar, penanganan pesan kesalahan, dan fungsi-fungsi kalimat.

   #include <stdio.h>
   #include <errno.h>
   #include <string.h>

2. Tambahkan sebuah fungsi main() yang mendeklarasikan sebuah pointer berkas dan sebuah variabel bilangan bulat.

   int main()
   {
       FILE *p__berkas ;
       int i ;
   }

3. Selanjutnya dalam blok fungsi main(), cobalah untuk membuka sebuah berkas yang belum ada atau belum dibuat.

   p__berkas = fopen( "berkas_tidak_ada.txt" , r ) ;

4. Keluarkan sebuah pesan konfirmasi atau kesalahan saat upaya tersebut gagal.

   if( p__berkas != NULL ) { printf( "Berkas telah dibuka\n" ) ; }
   else{ perror( "Ada kesalahan" ) ; } 

5. Sekarang tambahkan sebuah perulangan untuk mengeluarkan pesan-pesan kesalahan yang bersesuaian dengan kode nomor kesalahan.

   for( i = 0; i < 44; i++ )
   {
       printf( "Kesalahan %d : %s\n" , i , strerror( i ) ) ;
   }

6. Pada akhir blok fungsi main() keluarkan sebuah bilangan nol seperti yang disyaratkan dalam deklarasi fungsi.

   return 0 ;

7. Simpanlah berkas program, kemudian kompilasi dan jalankan untuk melihat pesan-pesan kesalahan.

1. Mulailah sebuah program baru dengan sebuah instruksi prapemroses untuk mengikutsertakan fungsi-fungsi dalam pustaka masukan/keluaran standar juga fungsi-fungsi tanggal dan waktu.

   #include <stdio.h>
   #include <time.h>

2. Tambahkan sebuah fungsi main() yang mendeklarasikan sebuah variabel larik karakter, sebuah variabel bertipe data time_t, dan sebuah struktur tm.

   int main()
   {
       char v__larik_sangga[100] ; // buffer
       time_t v__lewatan_waktu ;
       struct tm *p__sekarang ;
   }

3. Selanjutnya dalam blok fungsi main(), ambil hitungan lewatan detik terkini sejak Epoch.

   v__lewatan_waktu = time(NULL) ;

4. Kemudian lakukan konversi hitungan tersebut ke komponen waktu lokal.

   p__sekarang = localtime( &v__lewatan_waktu ) ;

5. Keluarkan tanggal dan waktu dalam format standar.

   printf( "%s\n" , asctime( p__sekarang ) ) ;

6. Lalu keluarkan komponen-komponen tanggal dan waktu secara tersendiri.

   strftime( v__larik_sangga , 100 , "Hari sekarang %A, %B %d.\n" , p__sekarang ) ;
   printf( "%s" , v__larik_sangga ) ;
   strftime( v__larik_sangga , 100 , "Waktu sekarang %I:%M %p.\n" , p__sekarang ) ;
   printf( "%s" , v__larik_sangga ) ;

7. Terakhir, keluarkan sebuah bilangan bulat nol yang disyaratkan kemudian simpan berkas program, kompilasi dan jalankan program untuk melihat informasi tanggal dan waktu saat ini.

1. Mulailah sebuah program baru dengan instruksi prapemroses untuk mengikutsertakan fungsi-fungsi dalam pustaka masukan/keluaran standar juga fungsi-fungsi tanggal dan waktu.

   #include <stdio.h>
   #include <time.h>

2. Berikutnya, deklarasikan sebuah prototipe fungsi untuk melakukan operasi pause pada program.

   void f__tunggu( int vf__banyak_detik ) ;

3. Tambahkan sebuah fungsi main() yang mendeklarasikan dua variabel bertipe data tim_t dan sebuah variabel bilangan bulat.

   int main()
   {
       time_t v__mulai , v__berhenti ;
       int i ;
   }

4. Selanjutnya dalam blok fungsi main(), dapatkan waktu saat ini dan keluarkan sebuah pesan.

   v__mulai = time(NULL) ;
   printf( "Mulai menghitung mundur...\n\n" ) ;

5. Tambahkan sebuah perulangan untuk mengeluarkan nilai cacah hitung dan panggil fungsi lain pada setiap iterasi.

   for( i = 10; i > -1 ; i--)
   {
       printf( "- %d" , i ) ;
       f__tunggu( 1 ) ;
   }

6. Berikutnya pada blok fungsi main(), dapatkan waktu terkini sekali lagi kemudian gunakan waktu yang diambil untuk menjalankan perulangan.

   v__berhenti = time(NULL) ;
   printf( "\nDurasi: %.0f detik\n" , difftime( v__berhenti , v__mulai ) ) ;

7. Terakhir, pada blok fungsi main(), keluarkan sebuah bilangan bulat nol seperti yang disyaratkan dalam deklarasi fungsi.

   return 0 ;

8. Setelah blok fungsi main(), mulailah definisi fungsi dengan menginisialisasi sebuah variabel bertipe data clock_t pada sebuah titik waktu depan melampaui waktu lewatan saat ini yang sedang berjalan.

   void f__tunggu( int vf__banyak_detik )
   {
       clock_t v__akhir_tunggu = ( clock() + ( vf__banyak_detik * CLOCKS_PER_SEC ) ) ;
   }

9. Dalam blok fungsi f__tunggu(), tambahkan sebuah perulangan kosong yang dihentikan saat waktu kini mencapai sebuah titik waktu depan, yang kemudian mengembalikan kendali ke perulangan dalam fungsi main().

   while( clock() < v__akhir_tunggu ) {}

10. Simpanlah berkas program kemudian kompilasi dan jalankan program untuk melihat pencacah waktu hitungan mundur dan jalannya waktu.

1. Mulailah sebuah program baru dengan instruksi prapemroses untuk mengikutsertakan fungsi-fungsi dalam pustaka masukan/keluaran standar, bilangan acak, waktu, dan untaian karakter.

   #include <stdio.h>
   #include <stdlib.h>
   #include <time.h>
   #include <string.h>

2. Tambahkan sebuah fungsi main() yang mendeklarasikan variabel-variabel int dan char.

   int main()
   {
       int i , v__nomor_acak , v__bilangan_sementara , v__larik_bilangan[100] ;
       char v__larik_sangga[10] , v__larik_karakter[100] = { "10 angka keberuntungan Anda adalah: " } ;
   }

3. Dalam blok fungsi main(), pertama berikan benih pada pembangkit bilangan acak dengan nilai detik terkini.

   srand( time(NULL) ) ;

4. Selanjutnya, isilah larik dengan bilangan dari 0-99 secara berurutan.

   for( i = 0; i < 100; i++ ){ v__larik_bilangan[i] = i ; }

5. Kemudian kocok deret tersebut sehingga urutannya menjadi acak.

   for( i = 1; i < 100; i++ ){
       v__nomor_acak = ( rand() % 99 ) + 1 ;
   
       v__bilangan_sementara = v__larik_bilangan[i] ;
       v__larik_bilangan[i] = v__larik_bilangan[v__nomor_acak] ;
       v__larik_bilangan[v__nomor_acak] = v__bilangan_sementara ; 
   }

6. Tambahkan 10 bilangan anggota larik ke sebuah untaian karakter.

   for( i = 1; i < 11; i++ )
   {
       sprintf( v__larik_sangga , "%d" , v__larik_bilangan[i] ) ;
       strcat( v__larik_sangga ,  " ") ;
       strcat( v__larik_karakter , v__larik_sangga ) ;
   }

7. Kemudian cetak keluaran untaian karakter.

   printf( "\n%s\n\n" , v__larik_karakter ) ;

8. Pada akhir blok fungsi main() keluarkan sebuah bilangan bulat bernilai nol seperti yang disyaratkan pada deklarasi fungsi.

   return 0 ;

9. Simpanlah berkas program kemudian kompilasi dan jalankan program secara berulang untuk melihat sebuah pemilihan 10 bilangan acak yang berbeda dalam rentang 1-100 dalam setiap eksekusi.

gcc -o program_gtk program_gtk.c `pkg-config --libs --cflags gtk+-2.0`

1. Mulailah sebuah program baru dengan sebuah instruksi prapemroses untuk mengikutsertakan pustaka antarmuka grafis GTK+.

   #include <gtk-2.0/gtk/gtk.h>

2. Tambahkan sebuah fungsi main() yang mendeklarasikan variabel pointer bertipe GtkWidget.

   int main( int argc, char *argv[] )
   {
       GtkWidget* p__w_jendela_utama ;    
   }

3. Selanjutnya lakukan inisialisasi GTK+ sehingga fungsi-fungsi GTK+ lainnya nanti bisa dipanggil.

   gtk_init( &argc , &argv ) ;

4. Di bawah baris inisialisasi GTK+, buatlah sebuah jendela utama yang merupakan jendela tingkat teratas untuk menampung komponen lainnya.

   p__w_jendela_utama = gtk_window_new( GTK_WINDOW_TOPLEVEL ) ;

5. Selanjutnya, untuk menampilkan jendela utama dilayar bisa dilakukan dengan memanggil fungsi gtk_widget_show().

   gtk_widget_show( p__w_jendela_utama ) ;

6. Untuk menutup jendela utama, kita tambahkan sebuah sinyal penyambung berupa sinyal “destroy” yang dihubungkan dengan fungsi gtk_main_quit().

   g_signal_connect( p__w_jendela_utama , "destroy" , G_CALLBACK( gtk_main_quit ) , NULL) ;

7. Untuk membuat program tetap tinggal dan menunggu adanya kejadian (events) maka tambahkan kode berikut untuk memasuki perulangan utama GTK+.

   gtk_main() ;

8. Pada akhir blok fungsi main(), keluarkan sebuah bilangan bulat nol seperti yang disyaratkan dalam pendeklarasian fungsi.

   return 0 ;

9. Simpanlah berkas program, kemudian lakukan proses kompilasi dan jalankan program untuk melihat tampilan jendela sederhana.

Catatan: Untuk melihat baris kode secara utuh, letakkan kursor mouse di dalam area kode, tekan dan tahan tombol Shift kemudian gunakan scroll wheel tengah mouse untuk melakukan scroll horizontal.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <gtk-2.0/gtk/gtk.h>

/* deklarasi tipe data tersuai */
typedef struct {
    GtkWidget* vg__w_label ; // vg: variabel anggota
    GtkWidget* vg__w_tombol ;
    char* vg__pesan ;
} st__data_klik ; // st: struct typedef

static gboolean f__tampilkan_pesan( gpointer pf__data_klik ) ;
void c__clicked_tombol( GtkWidget* pf__w_tombol , gpointer pf__data_klik ) ;

int main( int argc, char *argv[] ) {

    GtkWidget* p__w_jendela_utama ;    
    GtkWidget* p__w_fixed_layout ;
    GtkWidget* p__w_tombol ;
    GtkWidget* p__w_label ;

    gtk_init( &argc , &argv );

    // jendela utama
    p__w_jendela_utama = gtk_window_new( GTK_WINDOW_TOPLEVEL );
    gtk_window_set_position( GTK_WINDOW( p__w_jendela_utama ) , GTK_WIN_POS_CENTER ); // posisi jendela pada layar
    gtk_widget_set_size_request( p__w_jendela_utama , 300 , 200 );
    gtk_window_set_resizable( GTK_WINDOW( p__w_jendela_utama ) , FALSE );
    gtk_window_set_title( GTK_WINDOW( p__w_jendela_utama ) , "ANGKA KEBERUNTUNGAN ANDA" ) ; // judul jendela

    // fixed layout jendela utama
    p__w_fixed_layout = gtk_fixed_new();
    gtk_container_add( GTK_CONTAINER( p__w_jendela_utama ) , p__w_fixed_layout );

    // label
    p__w_label = gtk_label_new( "Silahkan Anda menekan tombol \"Tampilkan\"!" ) ;
    gtk_fixed_put( GTK_FIXED( p__w_fixed_layout ), p__w_label , 10 , 10 );
    gtk_widget_set_size_request( p__w_label, 250 , 100 );
    gtk_label_set_justify( GTK_LABEL( p__w_label ) , GTK_JUSTIFY_CENTER ) ;

    // tombol
    p__w_tombol = gtk_button_new_with_label( "Tampilkan" ) ;
    gtk_fixed_put( GTK_FIXED( p__w_fixed_layout ) , p__w_tombol , 185 , 135 );
    gtk_widget_set_size_request( p__w_tombol , 80 , 30 );

    // tebal garis tepi jendela utama
    gtk_container_set_border_width( GTK_CONTAINER( p__w_jendela_utama ) , 15 );

    // aksi klik tombol
    st__data_klik vt__data_klik_awal ;
    vt__data_klik_awal.vg__w_label = p__w_label ;
    vt__data_klik_awal.vg__w_tombol = p__w_tombol ;

    g_signal_connect( G_OBJECT( p__w_tombol ), "clicked", G_CALLBACK( c__clicked_tombol ) , &vt__data_klik_awal );

    // tutup jendela utama
    g_signal_connect( p__w_jendela_utama , "destroy" , G_CALLBACK( gtk_main_quit ) , G_OBJECT( p__w_jendela_utama ) );

    // tampilkan jendela utama
    gtk_widget_show_all( p__w_jendela_utama );

    gtk_main();

    return 0;
}

// fungsi pemanggil balik ketika tombol ditekan
void c__clicked_tombol( GtkWidget* pf__w_tombol ,  gpointer pf__data_klik ) {

    int  i , v__nomor_acak , v__bilangan_sementara , v__larik_bilangan[100] ;
    char v__larik_sangga[10] , v__larik_karakter[100] = { "Ini adalah 10 angka keberuntungan Anda:\n\n" } ;

    srand( time(NULL) ) ;

    for( i = 0; i < 100; i++ ) { v__larik_bilangan[i] = i ; }

    // pengacakan nomor
    for( i = 1; i < 100; i++ )
    {
        v__nomor_acak = ( rand() % 99 ) + 1 ;

        v__bilangan_sementara = v__larik_bilangan[i] ;
        v__larik_bilangan[i] = v__larik_bilangan[v__nomor_acak] ;
        v__larik_bilangan[v__nomor_acak] = v__bilangan_sementara ;
    }

    // pilih 10 bilangan
    for( i = 1; i < 11; i++ )
    {
        sprintf( v__larik_sangga , "%d" , v__larik_bilangan[i] ) ;
        strcat( v__larik_sangga , ( i < 10 ) ? ", " : "" ) ;
        strcat( v__larik_karakter , v__larik_sangga ) ;
    }

    // dari masukan
    st__data_klik* vt__data_klik_masuk = ( st__data_klik* ) pf__data_klik ;

    // untuk keluaran
    st__data_klik vt__data_klik_keluar ;

    vt__data_klik_keluar.vg__w_label = vt__data_klik_masuk->vg__w_label ;
    vt__data_klik_keluar.vg__w_tombol = vt__data_klik_masuk->vg__w_tombol ;
    vt__data_klik_keluar.vg__pesan = v__larik_karakter ;

    gtk_widget_set_sensitive( vt__data_klik_masuk->vg__w_tombol , FALSE );

    g_main_context_invoke( NULL , f__tampilkan_pesan , &vt__data_klik_keluar );

}

// fungsi untuk menampilkan pesan
static gboolean f__tampilkan_pesan( gpointer pf__data_klik ) {

    st__data_klik* vt__data_klik = ( st__data_klik* ) pf__data_klik ;

    gtk_label_set_text( GTK_LABEL( vt__data_klik->vg__w_label ) , vt__data_klik->vg__pesan ) ;

    gtk_widget_set_sensitive( vt__data_klik->vg__w_tombol , TRUE );

    return G_SOURCE_REMOVE ;
}

1. Kernighan, Brian W. & Ritchie, Dennis M. (1988). The C Programming Language. New Jersey: Prentice Hall.
2. Griffiths, David & Griffiths, Dawn (2012). Head First C. California: O’Reilly.
3. McGarth, Mike (2012). C Programming: Grasp the Nuts and Bolts of Programming. Warwickshire: In Easy Steps Ltd.
4. Stevanovic, Milan (2014). Advanced C and C++ Compiling: An Engineering Guide to Compiling, Linking, and Libraries using C and C++. California: Apress.