Variabel, Fungsi, Prosedur, klass dll... Dalam MFC

Variabel, Fungsi, Prosedur, klass dll... Dalam MFC

Prememori
Hal yang baru yang sering saya dapati dalam MFC
Saya awali dari
            virtual BOOL OnInitDialog( ); 

Menentukan apakah aplikasi telah menetapkan fokus input ke salah satu kontrol di kotak dialog. Jika  OnInitDialog()  return 0,maka Windows akan menetapkan fokus input ke kontrol di kotak dialog pertama . apakah Aplikasi ini dapat return 0 jika  hanya memiliki sebuah eksplisit untuk mengatur sebuah fokus input ke salah satu kontrol di kotak dialog

 ###############################################################################

Prosedur

Pengertian Prosedur
Prosedur adalah sebuah blok program tersendiri yang merupakan bagian dari program lain yang lebih besar. prosedur dapat dipanggil oleh program utamanya ataupun oleh prosedur lain yang juga merupakan bagian dari program utamanya (yang masih dalam satu kode program). sebuah program yang mememiliki prosedur biasanya terdiri dari satu atau lebih prosedur dan satu program utama.

Keuntungan dari pembuatan prosedur
1.    Memecah program menjadi lebih sederhana. misalnya diperlukan proses pencarian berkali kali jika hanya terdiri dari satu program utama tanpa prosedur maka kode program pencarian akan beberapa kali ditulis ulang dan hasilnya dapat memperbesar ukuran file
2.    Blok program yang digunakan jelas jika akan digunakan pada program lain cukup dengan mengkopi yang membutuhkan dan program lain tersebut tinggal memanggil prosedur tersebut
catatan :
Perbedaan antara prosedur dengan fungsi yang paling utama adalah prosedur  tidak menghasilkan nilai, namun hanya merupakan proses di dalamnya. sedangkan fungsi menghasilkan nilai keluaran (Output). jika kita membutuhkan hasil keluaran dan hanya membutuhkan proses akan dapat digunakan prosedur, tapi jika membutuhkan hasil keluaran (output maka gunakan fungsi.
cara mendeklarasikan prosedur
jika didalam java prosedur hampir mirip dengan yang dinamakan Metod. 
void nama_prosedur(tipe_data variabel_input1, tipe_data variabel_inputn)
{
....................
}

atau
void cariNama(char nama[])
 {
...................
}

adapun cara memanggilnya adalah

nama_prosedur (variabel_masukan);
cariNama(nama);

Parameter dalam prosedur
parameter dalam prosedur adalah sebuah variabel masukan (input) dari sebuah prosedur misalnya pada prosedur berikut :
prosedur hitungJumlah(input : integer hasil, integer operan1,  integer operan2)
{
hasil = operan1+operan2;
}
penjelasan
hasil, operan1, operan2 adalah parameter dalam prosedur hitungJumlah dalam hal ini jumlah parameter tidak terbatas namun prosedur yang baik biasanya memilki parameter masukan paling banyak 7 buah parameter. masukan dari sebuah prosedur  tidak harus berupa variabel, dapat lansung berupa nilai karena jika yang dijadikan masukan adalah variabel, tetap saja yang diproses dalam prosedur adalah nilai dari variabel itu, oleh karena itu dalam pemanggilan sebuah prosedur dapat dilakukan dengan cara sebagai berikut ;
 hitungJumlah (1, 2, 3,4,.....n);
jika menggunakan varibel maka menggunakansebagai berikut
hitungJumlah(a, b, c, d,.....n);
terdapat dua buah metode pemrosesan parameter dalam penggunaan sebuah prosedur yaitu pemroresan parameter berdasarakan nilainya (parameter pass by value ) dan pemroresan parameter berdasarakan acuan (parameter pass by reference).
pemroresan parameter berdasarkan nilainya
adalah pemroresan parameter didalam prosedur, bahwa parameter hanya dipakai nilainya saja pada proses yang ada didalam prosedur dijalankan misalnya contoh :

prosedur hitung (input : integer a, integer b)
integer hasil;
hasil = a+b ;
write ("Hasil penjumlahan : ", hasil);i
parameter masukan a dan b hanya bisa dipakai nilainya saja, nilai parameter ini tidak berubah seteleh perosedur hitung dijalankan. pada gambar 14 terdapat variabel operan1 dan operan2 sebagai parameter masukan prosedur hitung, di dalam prosedur hitung nilai a diisi dngan nilai operan1 dan nilai b diisi dengan nilai operan2 sehingga nilai operan1 dan nilai operan2 tidak berubah setelah prosedur hitung dijalankan.
default atau standar pada bahasa pemrograman C++ dan Java adalah (pass by value), bahkan dalam java tidak mendukung pass by reference.

permroresan parameter berdasarkan acuan (Parameter pass by reference)
adalah pemrosesan diddalam sebuah prosedur bahwa yang dimasukan didalam prosedur adalah tempat dari variabel yang menjadi parameter sehingga dapat terjadi perubahan nilai variabel yang menjadi parameter, misalnya pada contoh prosedur dengan bahasa algoritma sebagai baerikut :
prosedur hitung(input : integer a, integer b, output : integer c)
{
c = a +b ;
}
parameter masukan a dan b hanya dipakai nilainya saja, nilai parameter ini tidak berubah setelah prosedur hitung dijalankan sedangkan parameter  akan berubah nilainya setelah prosedur hitung dijalankan.

#include <stdio.h>
void hitung (int a, int b, int *c){
*c = a +b;
printf ("dalam prosedur : hasil penjumlahan %d\n", *c);
}
int main (){
int operan1 = 2;
int operan2=3;
int hasil =0;
hitung(operan1, opearn2, &hasil);
printf ("setelah prosederu nilai hasil adalah : %d\n", hasil);
return 0;
}


dalam bahasa c++ mengijinkan mengakses alamat variabel secara langsung dengan menambahkan tanda * (bintang).  parameter * bintang pada bahasa pemrograman c++ bisa berarti parameter pass by reference atau menyatakan pointer. pointer berarti yang dipesan pada memeri  bukan sebuah tempat, tapi hanya sebuah penunjuk yang mengacu ke tempat variabel yang  akan diubah nilainya.

prosedur standar

prosedur standar adalah prosedur yang dapat langsung dipaikai tanpa mendeklarasikanya karena telah ada pada pustaka (library) yang perlu dilakukan adalah menyertakan pustaka yang berisi prosedur standar yang dibutuhkan pada kode program dengan kata kunci include untuk bahasa pemrograman c++ dan kata kunci import pada bahasa pemrogramana java. untuk mengetahui prosedur apa saja yang dapat  dipaikai perlu dilakukan ekisplorasi terhadap putaka yang disediakianl selain prosedur, juga terdapat fungsi standar yang juga dapat langsung dipakai tanpa membuatnya sendiri.

Fungsi :
Fungsi adalah sebuah blok program yang tersendiri yang merupakan bagian dari program lain yang lebih besar sama halnya dengan prosedur hanya saja fungsi memiliki hasil keluaran sedangkan prosedur hanya berisi proses. Fungsi dapat dipanggil oleh program utamanya ataupun oleh prosedur atau fungsi lain yang juga merupakan bagian dari program utamanya (Masih dalam satu kode prgoram). Sebuah program bisa terdiri dari satu atau lebih proseedur, satu atau lebih fungsi dan satu program utama. Fungsi juga memiliki keuntungan-keuntungan seperti halnya prosedur, hal paling mendasar yang membedakan prosedur dan fungsi adalah keluaran/output  sedangkan prosedur tidak.
Deklarasi  fungsi
Prosedur dan fungsi sama halnya dengan Metode jika dalam bahasa pemrograman java bedanya hanya metode yang memiliki hasil keluaran dan metode yang tidak memiliki hasil keluaran.
Conotoh deklarasi dari fungis/methode
Int  nilaiTerbesar(int a, int b, int c)
{
// proses
Int hasil;
Return hasil;
} 

Cara memanggil fungsi/ metode adalah
Nama_variabel = nama_fungsi (variabael_masukan);
Maximum = nilaiTerbesar (a, b, c);

Contoh
#include <stdio.h>
Int hasilKali (int a, int b, int c)
{
Int hasil;
Hasil = a* b*C;
Return hasil;
}
Int main(){
int a=1;
int b =2;
int c=3;
hasil = hasilKali(a, b, c);
printf(“hasil perkalian adalah : “, hasil);
return 0;
}

Fungsi dapat didefinisikan secara langsung ataupun didalam program maupun yang disimpan dalam file header (misal header.h) satu fungsi yang pasti terdapat dalam program yang ditulis menggunakan bahasa c++ adalah main fungsi man(). Fungsi tersebut merupakan fungsi utama dan merupakan fungsi yang akan pertama kali akan di eksekusi.
Fungsi juga dapat didefinisikan sebagi berikut, fungsi adalah suatu blok program yang digunakan untuk melakukan proses-proses tertentu. Sebuah fungsi dibutuhkan untuk menjadikan program yang akan dibuat menjadi lebih modular dan mudah dipahami alurnya. Dengan adanya fungsi maka dapat mengurangi penulisan kode yang ganda.
Dalam c++ memilik 2 jenis fungsi yaitu fungsi yang mengembalikan nilai (return value) dan fungsi yang tidak mengemebalikan nilai. Fungs i yang mengembalikan nilai tersebut dinamakan dengan void function.
Nilai kembalian pada fungsi main ();
Nilai yang dikembalikan pada fungsi  main adalah  nilai 0 dan nilai 1;  apabila fungsi main() mengembalikan nilai 0 kesistem operasi, maka sistem operasi akan mengetahui bahwa program yang kita buat tersebut telah dieksekusi dengan benar tanpa adanya kesalahan.  Sedangkan apabila nilai yang dikembalikan kesistem operasi adalah 1 maka sistem operasi akan mengetahi bahwa program telah dihentikan secara tidak normal ( terdapat kesalahan) dengan demikian seharusnya fungsi main() tidaklah mengembalikan tipe void melainkan tipe data int.
Fungsi tanpa nilai balik
Pada umumnya fungsi tanpa nilai balik (retrun value ) ini digunakan untuk melaukukan proses-proses yang tidak menghasilkan nilai. Seperti melakukan pengulangan, proses pengesetan nilai taupun yang lainya. Dalam bahsa c++  fungsi semacam ini tipe kembaliaya akan diisi dengan nilai void.
Contoh :
Void nilaiTerendah(void){
Int j;
For (j=0; j<10; j++){
Printf (“pelajaran c++”);
}
Fungsi ini tidaklah menghasilkan nilai, melainkna hanya melakukan proses yaitu penulisan teks “Pelajaran c++” sebanyak 10 kali, inilah yan gdisebut dengan fungsi tanpa nilai balik (void function).

Fungsi dengan nilai balik
Adapun cara mendefinisikan fungsi yang memiliki nilai balik adalah dengan menuliskan  tipe data dari nilai yang akan dikembalikan didepan nama fungsi, berikut ini bentuk umum dari pendifinisian fungsi dengan nilai balik dalam bahasa c++;
Tipe_data  nama_fungsi(parameter1, parameter2,.....){
Statemen yang akan dieksekusi;
.................
Return nilai_balik;
}




Int hitungLuas(int sisi){
Int L;
L= sisi * sisi;
Return L;
}

Fungsi dengan parameter;
Parameter adalah suatu variabel yang bersfungsi untuk menampung nilai  yang akan dikirim kedalam fungsi. Dengan adanya parameter, sebuah fungsi dapat bersifat dinamis. Parameter itu sendiri terbagi menjadi dua macam, yaitu parameter formal dan parameter aktual. Parameter formal adalah parameter yang terdapat pada pendefinisian fungsi, sedangkan parameter aktual adalah parameter ayng terdapat pada ssaat pemanggilan fungsi. Contoh :
    Int tambahSatu(int X){
         Retrun ++x;
    }
Variabel x dinamakan sebagai parameter formal
Int main()
   {
      Int a= 10;
      Int hasil;
       Hasil = tambahSatu(a);
       Return 0;
  }
Pada saat pemanggilan fungsi tambaSatu() diatas variabel a dinamakan dengan parameter akual.

Jenis parameter
3 jenis parameter adalah parameter masukan, keluaran dan masukan/keluaran.
Parameter Masukan
Parameter masukan adalah parameter yang digunakan untuk menampung nilai data yang akan dijadikan sebagai masukan(inputs) kedalam fungsi. Artinya sebuah fungsi dapat menghasilkan nilai yang berbeda tergantung dari nilai parameter yang dimasukan pada saat pemanggilan fungsi tersebut.
 
#include <stdio.h>
#define PI 3.14

Doubel  hitungKeliling(int radius){
 Doubel K;
 K= 2*PI*radius;
Return K;
}

Int main (void) {
Int R;
Printf (“Masukan jari jari”);
Scanf(“%d”, &R);
Double Keliling = hitungKeliling(R);
Printf (“keliling adalah “, R, Keliling);

Return 0;
}
   

Pada sintak tersebut variabel R merupakan parameter aktual  yang berfungsi sebagai parameter masukan karena variabel tersebut digunakan untuk menampung nilai yang akan menjadi masukan untuk proses perhitungan dalan fungsi hitungKeliling();.
Apabila kina masukan nilai parameter diatas dengan nilai 5 maka akan memberikan hasil yang berbeda.
Hal ini membuktikan bahwa fungsi hitungKeliling(); akan menghasilkan nilai yang berbeda sesuai dengan nilai parameter yang dimasukan.
Parameter keluaran
Kebalikan dari parameter masukan parameter keluaran adalah parameter yang digunakan untuk menampung nilai kembalian/ nilai keluaran (output) dari suatu proses. Umumnya parameter jenis ini digunakan didalam fungsi yang tidak mempunyai nilai balik.

#include <stdio.h>
#define PI 3.14

Doubel  hitungKeliling (int radius, doubel  *K){
 Doubel K;
 K= 2*PI*radius;
Return K;
}

Int main (void) {
Int R;
Double Keliling;
Printf (“Masukan jari jari”);
Scanf(“%d”, &R);
hitungKeliling(R, Keliling);
Printf (“keliling adalah “, R, Keliling);

Return 0;
}
     

Variabel Keliling diatas berfungsi sebagai parameter keluaran karena variabel tersebut digunakna untuk menampung nilai hasil dari proses yang terdapat dalam fungsi. Sedangkan variabel R adalah variabel yang berfungsi sebagai parameter masukan diomana nilainya digunkana untk menampung nilai yang akan dilewatkan ke dalam fungsi.

Parameter masukan/keluaran.
Kegunaan parameter masukan/keluaran adalah sebagai berikut ;
-    Parameter ini akan bertindak sebagai parameter yang menampung nilai masukan.
-    Parameter ini akan bertindak sebagai parameter yang menampung nilai keluaran.
Perlu dicatat bahwa istilah "parameter" digunakan dalam dua konsep berbeda tetapi berkaitan. Yang pertama adalah "parameter" digunakan untuk mendefinisikan suatu subrutin. Parameter yang digunakan pada definisi suatu subrutin disebut parameter formal. "Parameter" yang digunakan untuk memanggil suatu subrutin disebut parameter aktual. Ketika suatu subrutin dipanggil, parameter aktual akan dievaluasi, dan hasilnya akan dimasukkan ke dalam parameter formal.

Enkapsulasi
Enkapsulasi inilah yang diimplementasikan dalam sebuah kelas bahwa di dalam sebuah kelas terdiri dari atribut dan metode yagn dibungkus dalam satu kelas. Enkapsulasi dalam sebuah kelas berfungsi untuk melindungi atribut dan metode-metode yang ada didalam kelas agar tidak sembarangan diakses oleh kelas lain.

Atribu dari sebuah keals adalah variabel global yang dimiiki sebuah kalas,
Contoh :
Class Elemen
NilaiMatKul elmt;
Elemen next;
Elemen(){
}

Maka  elmt dan next adalah atribut dari kelas elemen. Atribut pada sebuah kelas memiliki ijin akses jiki kelas digunakan oleh kelas lain, izin akses itu seperti  Private, Public, dan Protected.
Atribute Private :
Izin akses ini pada sebuah atribut biasanya digunakan oleh sebuah kelas untuk melindungi atribut-atributnya agara tidak dapat diakses oleh kelas lain.
Atribute Public :
Izin akses ini pada sebuah atribut biasanya digunakan oleh sebuah kelas, jika sebuah atribut diperbolehkan diakses secara langsung oleh kelas lain.
Atribute Protected :
Izin akses ini pada sebuah atribut biasanya digunakan oleh sebuah kelas, jika sebuah aribut diperbolehkan diakses secara langung oleh kelasi lain yang merupakan kelas turunannya.

Method
Method pada suatu kelas hampir sama dengan fungsi atau prosedur pada pemrograman prosedural. Pada sebuah method di dalam sebuah kelas juga memilki izin akses seperti halnya aribut pda kelas izin akses yaitu private, public dan protected.




################################################################################


Mungkin ini yang sering saya alami, karena saya termasuk pemula dalam MFC






========================================================================
Perlu digaris bawahi, ingat atau perlu di pahami ini semua tulisan yang terdapat dalam Blog ini adalah merupakan sebuah catatan pribadi yang berguna untuk saya sendiri, atau orang lain jika memang berguna, tulisan ini saya ambil dari berbagai sumber baik dari potongan tulisan dari buku, blog-blog teman, bahkan dari hasil translet ada yang dari situs, blog ataupun buku....? jadi apa bila ada pihak yang merasa dirugikan silahkna untuk mengirimkan kritik, pesan, saran atau pun email.... TRIMA KASIH

C++ MFC

MFC C++ 

Pembuatan aplikasi menggunakan c++ berbasis GUI dengan MFC lumayan rumit, karena masih sangat sedikitnya tutorial tentang pembahasan MFC, siapa tahu ini bisa bermanfaat bagi yang membutuhkannya

1. Pengetahuan MFC

Microsoft Visual C + + yang merupakan salah satu tool pemrograman yang digunakan untuk membuat aplikasi komputer untuk keluarga sistem operasi  Microsoft Windows.
Untuk membantu itu, maka diciptakan Microsoft Foundation Class (MFC) untuk sebagai sebuah adaptasi dari library Win32 yang digunakan dalam Microsoft Visual Studio.
MFC (Microsoft Foundation Class) adalah tool khusus berbentuk library yang digunakan untuk pembuatan aplikasi windows dari visual C++ merupakan tool yang mirip dengan ObjectWindow dari Borland. MFC mengandung lebih dari 200 kelas yang dapat langsung digunakan secara langsung yang berfungsi terutama sebagai kelas dasar dari  kelas dalam pembuatan window.
MFC juga merupakan sebuah framework yang lebih dari sekedar koleksi kelas, MFC membantu menentukan untuk struktur dalam sebuah aplikasi dan menangani banyak tugas-tugas untuk sebuah aplikasi.

2. Program Windows dengan MFC
3. MFC pada Visual Studio
4. Pembuatan Aplikasi




Bab pertama Hello MFC

Pemodelan Windows Programing dengan MFC pemrograman windows c++ berbasis MFC beroperasi secara berbeda, disini akan dijelaskan secara singkat menurut pemahaman penulis, mungkin berbeda dengan pemahaman anda. disini mereka (pemrograman windows) menggunakan model pemrograman event-driven yang diilustrasikan seperti gambar dibawah ini. di mana aplikasi akan merespon kejadian/proses dengan pengolahan pesan yang dikirim oleh sistem operasi, setiap aksi/atau event bisa menjadi sebuat keystroke, sebuah aksi klik dari sebuah mouse, atau perintah untuk membuat sebuah tampilan windows, sejauh ini mungkin sulit dipahami maksud dari kalimat diatas, anda bisa melihat gambar dibawah ini untuk lebih memperjelas keterangan diatas. 

Entry point untuk program Windows pada MFC adalah menggunakan fungsi yang bernama WinMain, tetapi sebagian besar aksi/event terjadi dalam suatu fungsi yang dikenal sebagai prosedur windows. dari prosedur windows ini pesan akan dikirim ke Windows. Fungsi WinMain ini akan menciptakan sebuah windows kemudian masuk kedalam sebuah pesan yang berulang(Message Loop) dan bergantian mengambil pesan kesebuah prosedur windows, lalu pesan akan menunggu dalam antrian pesan sampai mereka diambil.

Sebuah aplikasi Windows sebagian besar akan melakukan pengolahan dalam respon terhadap pesan-pesan yang diterima, dan di antara pesan tersebut, tetapi itu tidak sedikit kecuali akan menunggu untuk pesan berikutnya. lalu pesan (Message Loop) akan berakhir ketikan pesan WM_QUIT akan dipanggil dari antrian pesan yang dimaksud diatas, menandakan bahwa waktunya untuk aplikasi berakhir atau ditutup. 

Pesan ini biasanya muncul karena user atau pengguna memilih File menu Keluar,dengan klik tombol close (tombol kecil dengan tanda X yang ada di sudut kanan atas windows), atau dipilih Close dari menu sistem window. Ketika pesan(message loop) berakhir, WinMain kembali pada alur awal dan aplikasi berakhir/tertutup.

Gambar


gambar tersebut adalah menggambarkan proses berjalannya windows programing


Windows N MFC
Prosedur Windows biasanya memanggil fungsi lainya untuk membantu proses pesan-pesan yang diterimanya.Hal ini dapat memanggil fungsi-fungsi lokal ke aplikasi tersebut,atau dapat memanggil fungsi-fungsi API yang disediakan oleh Windows, Fungsi API yang terkandung dalam modul khusus yang dikenal sebagai dinamic-link library , atau DLL. 

API Win32 sangat banyak bahkan ratusan fungsi yang dapat memanggil aplikasi untuk melakukan berbagai tugas seperti membuat Windows( masksud windows disini adalah tampian gui windows), menggambar garis, dan masukan file input dan output.

Kode yang diberikan untuk memproses pesan tertentu dikenal sebagai handler pesan.   Pesan yang tidak diproses oleh aplikasi akan disampaikan ke fungsi API yang bernama DefWindowProc, yang memberikan tanggapan default ke pesan yang belum diolah.

Introduction to Messages

Sistem operasi Microsoft Windows tidak dapat memprediksi jenis permintaan apa  dari suatu objek yang akan memerlukan pelayanan yabng harus diambil dan jenis tugas apa dari suatu objek lain yang akan membutuhkanya. Untuk mengelola semua tugas dan request, lalu objek mengirimkan pesan, dari satu pesan pada suatu waktu, maka untuk sistem operasi memilik alasan ini ,sebab itulah Microsoft Windows dikatakan sebagai sistem operasi Message-driven.
Pesan akan terbagi dalam berbagai kategori, tetapi  seperti apa yang telah disebutkan , masing-masing objek  memiliki tanggung jawab untuk memutuskan bagaimana pesan mengirim dan kapan akan mengirim. Oleh karena itu, sebagian besar  pesan yang  kita akan review di sini  adalah bagian dari  window  umum.
Begitu objek telah menyusun pesan, maka ia harus mengirimkannya  ke tepat sasaran, yang bisa menjadikan sistem beroperasi. Menulis dan mengirim pesan inilah yang disebut sebagai sebuah event.dan Objek juga dikatakan suatu event  . Untuk membuat perbedaan antara pesan dan event, maka nama pesan biasanya dimulai dengan WM_ yang merupakan singkatan dari Window Message . sedangkan Nama dari suatu event biasanya dimulai dengan On yang menunjukkan aksi. Ingatlah, pesan adalah apa yang  perlu  dikirim. sedangkan Even adalah aksi mengirimkan pesan.



A Map of Messages
Makro DECLARE_MESSAGE_MAP  harus  disediakan  di akhir dari definisi kelas. Pesan yang sebenarnya   harus tercantum tepat di atas garis DECLARE_MESSAGE_MAP.
Untuk melaksanakan pesan, Anda harus membuat daftar pesan yang digunakan program Anda . Tabel ini menggunakan dua macro pembatas. Ini dimulai dengan BEGIN_MESSAGE_MAP  dan berakhir dengan macro END_MESSAGE_MAP. Makro BEGIN_MESSAGE_MAP  mengambil  dua argumen, nama kelas dan kelas MFC yang diperoleh  dari kelas tersebut

BEGIN_MESSAGE_MAP(CSimpleFrame, CFrameWnd)

Seperti makro DECLARE_MESSAGE_MAP, END_MESSAGE_MAP  mengambil bukan argumen. Tugasnya adalah hanya untuk menentukan akhir dari daftar pesan. Tabel pesan dapat dibuat sebagai berikut:
#include <afxwin.h>
#include <afxdlgs.h>
#include "resource.h"

class CExerciseApp : public CWinApp
{
public:
    BOOL InitInstance();

    DECLARE_MESSAGE_MAP()
};

class CExerciseDlg : public CDialog
{
public:
    enum { IDD = IDD_EXERCISE_DLG };

    CExerciseDlg();
    ~CExerciseDlg();

    DECLARE_MESSAGE_MAP()
};

CExerciseDlg::CExerciseDlg()
    : CDialog(CExerciseDlg::IDD)
{
}

BEGIN_MESSAGE_MAP(CExerciseDlg, CDialog)

END_MESSAGE_MAP()

CExerciseDlg::~CExerciseDlg()
{
}

BEGIN_MESSAGE_MAP(CExerciseApp, CWinApp)

END_MESSAGE_MAP()

BOOL CExerciseApp::InitInstance()
{
    CExerciseDlg Dlg;

    m_pMainWnd = &Dlg;
    Dlg.DoModal();

    return TRUE;
}

CExerciseApp theApp;



Messages, Messages, and More Messages

dari mana pesan(Message) itu berasal, dan jenis informasi apa yang akan mereka sampaikan?  Windows akan mendefinisikan banyak pesan bahkan ratusan jenis pesan yang berbeda. Kebanyakan pesan memiliki nama yang dimulai dengan huruf "WM" dan (underscore) garis bawah, seperti di WM_CREATE dan WM_PAINT.
Tabel berikut menunjukkan 10 dari pesan yang paling umum digunakan dalam pembuatan aplikasi.

10 perintah Windows Messages
=================================================================
WM_CHAR                sebuah karakter adalah input dari keyboard.
WM_COMMAND     Pengguna memilih menu, atau kontrol guna mengirimkan pemberitahuan ke item menu.
WM_CREATE           Membuat sebuah windows / jendela.
WM_DESTROY         membuat sebuah windows destroyed.
WM_LBUTTONDOWN     Tekan tombol kiri pada mouse.
WM_LBUTTONUP            Tombol kiri mouse apa bila di lepas.
WM_MOUSEMOVE          Pointer mouse dipindahkan.
WM_PAINT                        Sebuah window digunakan untuk menggambar.
WM_QUIT                           Ini digunakan untuk mengakhir/menutup windows.
WM_SIZE                            Sebuah window  resize.

=================================================================
 ok itu adalah sekilas mengenai message pada windows yang menggunakan fungsi WinMain, pada pembahasan selanjutnya akan membahas MFC lebih lanjut.

Pengenalan MFC

apa itu MFC, MFC merupakan  GUI dari C++ dalam membuat sebuah aplikasi User Interface yang merupakan class library c++ yang di sediakan oleh microsoft. Beberapa kelas MFC yang sangat sederhana, seperti kelas CPoint yang mewakili sebuah titik (lokasi yang ditetapkan koordinanya dengan x dan y ). Misalah yang lain yang lebih kompleks, seperti kelas cwnd yang melapisi fungsionalitas Windows( jendela).

The Structure of an MFC Application

sebuah Aplikasi mfc akan melakukan dua hal dasar yaitu :
Menciptakan sebuah jendela utama aplikasi itu sendiri dan melakukan proses awal, seperti mengalokasikan memori dan memproses pesan ke jendela atau aplikasi.
Saat menulis sebuah program, langkah pertama adalah  mendefinisikan dan membuat jendela utama aplikasi, yang merupakan "Bangunan Awal aplikasi" atau bagian dari layar yang akan mengendalikan aplikasi yang dibuat.
Penulisan program hanya ditulis di dalam jendela itu sendiri dan tidak di jendela program lainnya.
  Jika sebuah program mencoba ditulis di luar wilayahnya, tidak akan muncul di layar. Ini sebagaimana sistem operasi menyimpan program sehingga tidak  mengganggu atau merusak kode yang satu dengan yang lainya di layar. jika anda pernah sekali membuat aplikasi MFC pasti anda tau apa maksud yang saya jelaskan diatas.
Sebuah jendela utama program aplikasi pada MFC disebut  juga  sebagai  Mainframe. Jendela utama menampilkan menu bar. Jendela utama, atau mainframe, dapat menjadi indux untuk jendela jendela yang dibuat lainnya.

Pada pembahasan selanjutnya nanti akan membuat sebuah aplikasi MFC sederhana.
Contoh pertama menunjukkan  bagaimana Anda  membuat  jendela utama dengan  fitur yang  standar.
Contoh kedua menunjukkan Anda bagaimana untuk membuat jendela utama dengan unsur-unsur non-klien opsional visual
Pada contoh ketiga Anda menunjukkan bagaimana untuk menyesuaikan fitur lain dari jendela, yaitu: warna backgroun, ikon, dan kursor. Fitur-fitur ini disesuaikan dengan program yang akan dibuat.
============
Dalam aplikasi MFC, Anda memperoleh jendela utama atau kelas mainframe dari kelas MFC CFrameWnd, yang berasal dari cwnd.
Semua kelas MFC akan dimulai dengan "C" contoh  CFrameWnd adalah kelas MFC   yang memanggil kelas mainframe Anda,  itu berisi fungsi yang akan dibutuhkan untuk jendela utama. sedangkan Cwnd adalah kelas dasar CFrameWnd. sedangkan untuk Kotak dialog (dialog Box) dan kontrol disini juga merupakan jendela, sehingga cwnd juga merupakan kelas dasar kotak dialog dan kontrol.
Programer perlu membuat objek turunan dari kelas mainframe  yang akan menjadi objek jendela utama. Jadi  objek mainframe dari jendela utama Anda akan mewarisi  perilaku standar dari CFrameWnd dan dapat memiliki perilaku/behafior tambahan yang sesuai untuk setiap fungsi anggota yang tetapkan di kelas mainframe.
Selain itu, perilaku yang terkandung dalam Member Function (fungsi anggota)  warisan dari CFrameWnd dapat dimodifikasi dengan menimpa anggota fungsi-fungsi ini lalu diwarisikan dengan fungsi anggota yang diubah di kelas mainframe.
Setiap aplikasi MFC akan memiliki kelas mainframe. Dalam tulisan ini, saya telah memilih untuk memberikan kelas mainframe dalam file terpisah. Kode yang disusun nantinya ini akan cocok dengan compiler digunakan membuat aplikasi pertama, karena alat membangun sebuah file terpisah dari kelas mainframe.
=========================
Pada pembahsan berikut ini akan membahas dasar-dasar pembuatan aplikasi.

Semua kelas dalam MFC akan didefinisikan kedalam file header <afxwin.h>.Tanda kurung di sekitar  file header berfungsi memberitahu compiler untuk melihat isi dalam subdirektori compiler untuk setiap file yang ada didalamnya, bukan hanya di direktori kerja saja.
Awalan "AFX" adalah sebuah singkatan dari "application framework x." File header <afxwin.h> berisi definisi dari kelas MFC, yang mengetahui bagaimana sebuah compiler untuk memasukkan kelas CWinApp dan CFrameWnd. File header ini juga berisi sejumlah direktif  (# include) , yang membawa kedalam file header yang lainya.
<afxwin.h> juga termasuk file header afx.h, yang pada intinya meliputi lima file header lainya yaitu : string.h, stdio.h, stdlib.h, time.h, dan afx.ini.File header <afxwin.h> di compiler yang akan membaca beberapa file header yang ada sebelum dimulainya kompilasi.

Ini adalah daftar file header yang termasuk dalam file <afxwin.h>.
File             Contents
afxwin.h     MFC header file
                 afx.h         MFC header file for utility functions
                 string.h     C run-time library for string functions
                 stdio.h      C run-time library for input/output
                 stdlib.h      Standard C run-time library
                 time.h       C run-time library for time functions
                 afx.ini        Inline function declarations
        windows.h       Windows OS header file
        afxmsg_.h       Message map table for MFC
        afxdd_.h          Standard DDX_and DDV_routines
        afxwin1.in1     Inline function declarations
        afxwin2.in1     Inline function declarations

Pengantar Win32

Win32 adalah library yang terbuat dari tipe data, variabel, konstanta, fungsi, dan kelas (kebanyakan struktur) yang dapat digunakan untuk membuat sebuah aplikasi  untuk  keluarga sistem operasi  Microsoft Windows
Sama seperti C + + program selalu memiliki fungsi  main (), sebuah program Win32 menggunakan fungsi pusat yang disebut  winmain.

Sintaks fungsi yaitu:

     INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,  
                                           LPSTR lpCmdLine, int nCmdShow );

Untuk mendukung karakter internasional, Microsoft Windows menyediakan  versi lain  dari fungsi ini yang bernama _tWinMain. Versi ini menggunakan sintaks yang sama (argumen yang sama) sebagai yang pertama.
Tidak seperti C + + 's fungsi main (), argumen dari fungsi winmain ()  tidak opsional. Program akan membutuhkannya  untuk  berkomunikasi  dengan sistem operasi. Berikut adalah contoh memulai program dengan winmain () fungsi:

            #include <windows.h>

           INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                                                    LPSTR lpCmdLine, int nCmdShow )
              {
                 return 0;
             }

Diingat Kembali tentang MFC

Microsoft Foundation Class (MFC) library menyediakan satu set fungsi, konstanta, tipe data, dan kelas untuk mempermudah membuat aplikasi untuk keluarga Microsoft Windows sistem operasi.

CObject, the Ancestor of All/Most MFC Classes
Untuk melaksanakan fungsi nya, MFC yang diatur sebagai pohon kelas hirarki , nenek moyang  dari  CObject itu sendiri. Meskipun Anda dapat membuat kelas C + +  untuk aplikasi Anda, sebagian besar sebuah kelas akan menggunakan  seluruh  turunan dari CObject  langsung ataupun tidak langsung .

Kelas CObject meletakkan dasar yang berharga bahwa kelas lain dapat dibangun di atasnya. Menggunakan aturan warisan, fungsi CObject dapat transparan untuk dapat  diterapkan pada kelas-kelas lain  seperti  yang kita  akan pelajari sedikit demi sedikit.
  • Nilai yang akan melakukan streaming untuk menyimpan atau membuka isi file
  • Pengontrolan dimik yang akan membuat dan penghancuran kelas yang mewarisinya
  • Memeriksa validitas variabel kelas, dll
kita tidak dapat langsung menggunakan CObject langsung kedalam sebuah program. Sebaliknya, kita dapat membuat  kelas  kita sendiri  yang didasarkan pada CObject.  Berikut  adalah  contohnya:
class CCar : public CObject
     {
            public:
            CCar();
            char *Make;
            char *Model;
            int Year;
            long Mileage;
            int Doors;
           double Price;
    };

Ketika mewarisi sebuah kelas dari CObject, kelas akan dapat memanfaatkan fitur dari CObject induknya. Ini berarti bahwa  akan tersedia sebuah  fungsi  yang diletakkan oleh metodnya
.
Berikut ini adalah beberapa metod dari kelas CObject adalah:

* CObject ();
Konstruktor ini memungkinkan Anda untuk menggunakan sebuah instance dari CObject. Jika telah membuat sebuah kelas berdasarkan CObject, ketika mendeklarasikan sebuah instance dari kelas tersebut maka, konstruktor default CObject tersedia dan memberikan akses ke metode CObject.

* CObject (const CObject & Src);
metod ini digunakan jika akan menyalin sebuah variabel CObject dari  kelas yang  digunakan dalam sebuah program, misalnya untuk menetapkan ke variabel lain, dapat menggunakan copy constructor yang diwariskanya. Karena objek berasal dari CObject, compiler akan membuat salinan variabel secara member-by-member.

* Serialize ();
Metode ini memungkinkan untuk meletakan sebuah nilai-nilai dari sebuah objek.

* AssertValid ();
Metode ini digunakan untuk memeriksa sebuah kelas . Karena kelas warisan biasanya dimaksudkan untuk menyediakan fungsionalitas baru berdasarkan kelas induk, ketika akan membuat kelas berdasarkan CObject,  maka harus menyediakan proses pengecekan untuk sebuah variabel . Dalam hal ini harus menyediakan sebuah implementasi sendiri dari method AssertValid () . Agar dapat menggunakannya misalnya untuk memeriksa bahwa variabel unsigned int selalu positif.

Objek dari sebuah aplikasi akan mengirim pesan ke sistem operasi untuk menentukan apa yang mereka inginkan. Library MFC menyediakan kelas khusus untuk mengelola banyak pesan. Kelas disebut CCmdTarget. Objek akan kembali ke sana ketika berhadapan dengan pesan.

==========================================================================

Sebuah Aplikasi Dasar

Untuk membuat sebuah program atau aplikasi, maka akan memperoleh sebuah kelas dari kelas CWinApp di MFC. Kelas CWinApp berasal dari kelas CWinThread. Dan CWinThread berasal dari kelas bernama CCmdTarget,ini yang berasal dari CObject. CWinApp singkatan Kelas Untuk Sebuah Aplikasi Windows:


Perlu di ingat bahwa
Karena kelas CWinApp didefinisikan  pada file header AFXWIN.H, pastikan Anda menyertakan  file yang mana CWinApp sedang digunakan.

The Framework

Daripada membuat aplikasi yang menggunakan  kelas  Win32   dan fungsi  "yang masih baku",Library  MFC telah  menyederhanakan proses ini dengan menyediakan mekanisme yang disebut framework. Framework adalah seperangkat kelas, fungsi, dan teknik yang digunakan untuk membuat aplikasi selengkap mungkin dengan sebagai beberapa baris kode yang tersusun sebaik mungkin.

Untuk menyediakan semua fungsionalitas ini, framework bekerja di balik layar dengan kelas CWinApp untuk mengumpulkan kelas  dan fungsi  MFC  yang diperlukan, untuk mengenali dan mendamaikan kelas-kelas Win32 bahwa aplikasi tersebut membutuhkanya.
Rekonsiliasi ini juga dimungkinkan oleh satu set fungsi global. Fungsi-fungsi ini memiliki nama yang dimulai dengan AFX ... Beberapa fungsi-fungsi ini:
    *  AfxFormatString1
    * AfxFormatString2
    * AfxMessageBox
    * AfxFreeLibrary
    * AfxGetApp
    * AfxGetAppName
    * AfxGetInstanceHandle
    * AfxGetMainWnd
    * AfxGetResourceHandle
    * AfxInitRichEdit
    * AfxLoadLibrary
    * AfxMessageBox
    * AfxRegisterWndClass
    * AfxSocketInit
    * AfxSetResourceHandle
    * AfxRegisterClass
    * AfxBeginThread
    * AfxEndThread
    * AfxGetThread
    * AfxWinInit
 ===============================

Sebuah Objek Global dari Sebuah Aplikasi

Untuk membuat kelas aplikasi yang tersedia dan dapat diakses oleh objek aplikasi itu sendiri, maka harus mendeklarasikan variabel global terlebih dahulu, maka dari itu harus ada walau hanya satu variabel dari sebuah aplikasi. Variabel ini adalah jenis kelas turunan dari CWinApp. Berikut adalah contohnya:
       class CSimpleApp : public CWinApp
          {
          };
      CSimpleApp MyApplication;

Seperti yang terlihat,ini adalah nama variabel global yang inginkan. Dalam Microsoft Visual C + +, variabel ini biasa diberi nama theApp. Berikut adalah contohnya:
        CSimpleApp theApp;
Untuk mendapatkan pointer ke variabel ini dari mana saja dalam sebuah aplikasi , maka dapat memanggil fungsi framework berikut  AfxGetApp () . Sintaks-nya adalah:
      CWinApp* AfxGetApp();

Untuk melaksanakan  peran  winmain  di fungsi Win32 () , framework diimplementasikan  sendiri  menggunakan  fungsi  ini dan MFC menyediakan fungsi ini  AfxWinInit (). Hal ini dideklarasikan sebagai berikut:
      BOOL AFXAPI AfxWinInit(HINSTANCE hInstance,
                                                  HINSTANCE hPrevInstance,
                                                  LPTSTR lpCmdLine,
                                                 int nCmdShow);
Seperti yang Anda lihat, di Win32 fungsi   WinMain(); dan AfxWinInit  ();  di MFC menggunakan  argumen yang  sama.

Sebuah Window's Instance

Ketika Anda menjalankan aplikasi seperti Notepad, anda dikatakan telah menciptakan sebuah instance dari aplikasi. Dengan cara yang sama, ketika anda mendeklarasikan sebuah variabel kelas, maka sebuah instance dari kelas tersebuh dibuat dan tersedia untuk projeck.
fungsi  Winmain ();  juga memungkinkan Anda untuk membuat sebuah instance dari sebuah aplikasi, disebut sebagai argumen hInstance dari fungsi winmain (); (Argumen yang sering penulis sebut dari awal pembahasan disini adalah parameter). contoh ini dibuat sebagai suatu HINSTANCE. Kelas CWinApp menyediakan variabel m_hInstance sesuai  contoh yang disebut. Variabel ini dapat membuat Anda mendapatkan pegangan ke instance dari aplikasi Anda.
Atau, untuk mendapatkan pegangan ke instance dari aplikasi Anda, maka Anda dapat menghubungi AfxGetInstanceHandle () fungsi global. Sintaks-nya adalah:

      HINSTANCE AfxGetInstanceHandle ();

Bahkan lebih dari itu, untuk mendapatkan pegangan untuk aplikasi Anda, Anda dapat memanggil API Win32 fungsi GetWindowLong (); . Misalkan anda telah membuka Notepad untuk melihat kode sumber dari sebuah dokumen HTML. Ini dikatakan bahwa Anda memiliki instance dari Notepad. Bayangkan bahwa Anda ingin membuka dokumen teks menggunakan Notepad tanpa menutup contoh pertama Notepad. Untuk melakukan ini, Anda harus membuka salinan lain dari Notepad. Ini salinan kedua Notepad adalah contoh lainnya. Dalam hal ini, contoh pertama disebut sebagai contoh sebelumnya. Untuk aplikasi Win32, contoh sebelumnya akan menjadi argumen hPrevInstance dari fungsi Winmain () . Untuk aplikasi Win32, argumen hPrevInstance selalu memiliki nilai NULL. Jika Anda ingin mengetahui apakah contoh aplikasi sebelumnya sudah ada, Anda dapat menghubungi method cwnd:: FindWindow () . Sintaks-nya adalah:

  static CWnd* PASCAL FindWindow(LPCTSTR lpszClassName, LPCTSTR lpszWindowName);

Jika Anda membuat jendela atau apabila jendela dapat dipastikan, bahwa dalam hal ini bisa menjadi sebuah objek WNDCLASS atau WNDCLASSEX, tentukan sebagai argumen/parameter  untuk variabel  lpszClassName. Jika Anda tidak tahu nama dari window dengan pasti, maka set argumen/parameter ini sebagai NULL. Argumen dari variabel lpszWindowName  adalah  keterangan  yang mungkin  dari window yang dimaksud. Bayangkan posisi tombol pada kotak dialog dan oleh pengguna ingin  memulai Notepad dengan tombol itu lalu bayangkan jika Notepad itu  sudah dibuka, tidak akan ada alasan untuk membuat contoh lain  dari itu.
Kelas CWinApp menyediakan semua fungsionalitas dasar yang aplikasi butuhkan.dalam  Hal ini dilengkapi dengan metode yang disebut InitInstance (). Sintaks-nya adalah:

      virtual BOOL InitInstance();
Ketika membuat  sebuah aplikasi, anda harus mengganti metode di kelas Anda sendiri. Metode ini digunakan untuk menciptakan  aplikasi. Jika berhasil, ia mengembalikan TRUE atau nilai bukan nol. Jika aplikasi tidak dapat dibuat, kembali metode FALSE atau 0. Berikut adalah contoh mengimplementasikannya:
            
             class CSimpleApp : public CWinApp
                 {
                          BOOL InitInstance() { return TRUE; }
                 };

perlu diingat bahwa metode juga bisa saja diterapkan sebagai berikut:

struct CSimpleApp : public CWinApp
{
    BOOL InitInstance()
    {
    return TRUE;
    }
};

atau sebagai berikut :

struct CSimpleApp : public CWinApp
{
    BOOL InitInstance();
};

BOOL CSimpleApp::InitInstance()
{
    return TRUE;
}


 Command Line

Untuk menjalankan program, Anda harus berkomunikasi denga path dan yang mungkin ada beberapa parameter tambahan untuk compiler. Informasi ini disebut informasi command line dan diberikan sebagai nilai string. Anda harus selalu ingat itu meskipun semua program pelajaran yang kita akan disusun menggunakan Visual C + +. Informasi common line dipasok ke compiler sebagai argumen lpCmdLine dari Fungso WinMain( );. Secara internal, Visual C + + menciptakan jalan dan berkomunikasi ke compiler ketika  menjalankan program. Jika ingin mengetahui apa  yang digunakan command Line  untuk mengeksekusi program , kita dapat menghubungi fungsi GetCommandLine (); di Win32  . Sintaks-nya adalah:.

       LPTSTR GetCommandLine(VOID);

Fungsi ini tidak membutuhkan sebuah argumen tapi  akan mengembalikan  commman line dari aplikasi yang diakhiri sebagai string-null

onverting a Resource Identifier

Identifier adalah konstanta integer yang namanya biasanya dimulai dengan ID. Meskipun dalam pemrograman Win32 biasanya dapat menggunakan nama resource sebagai string, dalam aplikasi MFC, resource biasanya dinamai  dengan identifier mereka sendiri. Untuk membuat nama identifier (yang dianggap sbagai string) yang dikenal ke fungsi MFC (atau Win32) , maka menggunakan MAKEINTRESOURCE yang disebut makro. Sintaks-nya adalah sebagai berikut:

      LPTSTR MAKEINTRESOURCE (WORD Identifier);

Makro ini mengambil identifier dari resource dan mengembalikan kesebuah nilai string yang diberikan kepada fungsi yang memanggilnya. Dalam arti yang tepat, setelah membuat file resource, maka harus dikompilasi untuk membuat file baru yang memiliki ekstensi.res. Untungnya, didalam Microsoft Visual C + + secara otomatis akan menyusun file dan akan ngelink ke aplikasi.

Dialog BOX

Pada pembahsan ini mengenai Dialog Box


Dialog Box
Sebuah kotak dialog dibuat dari kelas yang bernama CDialog. Kelas CDialog mengimplementasikan sebuah kelas yang bernama cwnd. lalu kelas cwnd berasal dari CCmdTarget:



Seperti kontrol lainnya, untuk kotak dialog harus diidentifikasi. Pengenal dari kotak dialog  biasanya  dimulai  dengan  IDD_ . Contoh identifier  kota dialog  ini IDD_SCHOOL_SURVEY. Oleh karena itu, bagian dari kotak dialog di file bisa mulai dengan:

       IDD_SCHOOL_SURVEY

Library Win32 menyediakan serangkaian  nama siap pakai kelas untuk menciptakan  kontrol. Dengan cara yang sama, sebuah kotak dialog memiliki dua jenis kelas yang digunakan  untuk  membuat  kotak  dialog. Statemen DIALOG pada dasarnya/umunya yang biasa digunakan untuk  membuat ID  kotak dialog. Ini telah diperbarui  dan diganti dengan nama DIALOGEX. Oleh karena itu, untuk menunjukkan dalam file yang bagian Anda membuat adalah untuk kotak dialog, ketik DIALOGEX. Berikut adalah contohnya:

IDD_SCHOOL_SURVEY DIALOGEX

Membuat Klass untuk Dialog Box
Setelah membuat resource  untuk  kotak  dialog, Anda harus membuat sebuah class yang akan digunakan  untuk  menangani  tugas-tugasnya. Untuk melakukan ini, maka harus menurunkan kelas dari CDialog.   Anda dapat  membuat  sebuah  file header dan file sumber untuk kotak dialog.

Dalam file header kelas dialog itu, menetapkan penghitungan yang  disebut sebagai SLI dan menginisialisasi dengan identifier dari kotak dialog. Karena identifier yang terdaftar dalam file header , maka harus menyertakan file header diresource  di mana Anda menggunakan dialog identifier.

Metod Dialog Box

Sebuah kotak dialog yang dibuat berdasarkan pada kelas CDialog. Seperti yang terlihat di atas, ketika membuat kotak dialog, Anda dapat memperoleh kelas dari CDialog. Kelas CDialog itu sendiri menyediakan tiga konstruktor default  sebagai berikut:

CDialog ();
CDialog (uint nIDTemplate, cwnd * pParentWnd = NULL);
CDialog (LPCTSTR lpszTemplateName, cwnd * pParentWnd = NULL);

Constructor default, CDialog ();, dapat digunakan untuk mendeklarasikan variabel yang perilakunya belum diketahui atau, untuk satu alasan lainnya tergantung kebutuhan dalam pembuatan program, yang belum dapat didefinisikan. Ketika membuat kelas , Anda juga harus mendeklarasikan setidaknya  constructor default.

Pengenal dari kotak dialog, seperti IDD_DIALOG1, dapat digunakan sebagai argumen pertama, nIDTemplate, dari konstruktor  CDialog () untuk membuat kotak dialog dari resource yang ada.

Jika Anda menggunakan template Win32 untuk membuat kotak dialog Anda, kirimkan nama template ini sebagai nilai string ke konstruktor CDialog () , lpszTemplateName.

Ketika menerapkan konstruktor default, dalam menginisialisasi  CDialog  konstruktor  induk  dengan  enumerator  IDD maka dideklarasikan  kedalam  kelas  Anda. Jika kotak dialog Anda memiliki pemilik dari dialog induk,mak tentukan sebagai argumen pParentWnd. Jika Anda menetapkan  ke NULL, aplikasi akan digunakan  sebagai  induk  dialog  itu.
Jika Anda membuat objek secara dinamis untuk aplikasi maka menggunakan kelas dialog Anda, itu adalah ide yang baik untuk mendeklarasikan  dan mendefinisikan  sebuah  destructor. Ini akan digunakan untuk menghancurkan objek dinamis tersebut.


Mendeklarasikan  constructor
========
Mendeklarasikan  constructor default  dan destructor untuk kelas sebuah dialog dan mengimplementasikan  mereka  sebagai  berikut  (dalam file yang sama):

class CPreparationDlg : public CDialog
{
public:
    enum { IDD = IDD_PREPARATION_DLG };

    CPreparationDlg();
    ~CPreparationDlg();
};

CPreparationDlg::CPreparationDlg()
   : CDialog(CPreparationDlg::IDD)
{
}

CPreparationDlg::~CPreparationDlg()
{
}



# sebelum menggunakan class baru, maka deklarasikan variable berlebih dahulu seperti  berikut


BOOL CPreparationApp::InitInstance()
{
    CPreparationDlg Dlg;

    m_pMainWnd = &Dlg;

    return TRUE;
}


Modal dalam  Dialog Box


Ada dua jenis kotak dialog:
modal dan modeless. Sebuah modal dari  kotak dialog yang merupakan  salah satu  yang pengguna harus terlebih dahulu menutup  agar   mengakses  ke jendela atau kotak dialog dari aplikasi yang sama.

Salah satu skenario di mana dalam menggunakan kotak dialog yaitu untuk  menciptakan  sebuah  aplikasi  yang berpusat di sekitar kotak dialog. Dalam hal ini, jika salah satu tidak ada jendela lain dari sebuah aplikasi atau jika semua jendela lain itu tergantung  pada kotak dialog pusat/induk,maka  harus diciptakan sebagai modal. Permohonan semacam ini disebut  sebagai  dialog _base
Ada dua teknik utama yang dapat Anda gunakan untuk membuat aplikasi berbasis dialog: dari awal atau menggunakan salah satu Visual C + + Wizards. Setelah membuat dialog dan resource yang berasal  dari kelas CDialog, anda dapat mendeklarasikan variabel kelas dialog Anda. Untuk menampilkan kotak dialog sebagai moda, Anda dapat memanggil  CDialog  ini:: DoModal () metode dalam Anda CWinApp:: InitInstance () method. Sintaks-nya adalah:
virtual int DoModal ();

Metode ini dengan sendirinya akan   menampilkan kotak dialog ada lagi sebagai modal. Kita akan mempelajari  dalam  menggunakan metod ini, untuk mengetahui bagaimana pengguna telah menutup kotak dialog tersebut.

Untuk menampilkan kotak dialog sebagai modal, maka dalam  InitInstance (); event dari kelas  turunan CWinApp   ,dengan memanggil method  DoModal () menggunakan variabel dialog Anda:

#include <afxwin.h>
#include <afxdlgs.h>
#include "resource.h"

class CPreparationApp : public CWinApp
{
public:
    BOOL InitInstance();
};

class CPreparationDlg : public CDialog
{
public:
    enum { IDD = IDD_PREPARATION_DLG };

    CPreparationDlg();
    ~CPreparationDlg();
};

CPreparationDlg::CPreparationDlg()
    : CDialog(CPreparationDlg::IDD)
{
}

CPreparationDlg::~CPreparationDlg()
{
}

BOOL CPreparationApp::InitInstance()
{
    CPreparationDlg Dlg;

    m_pMainWnd = &Dlg;
    Dlg.DoModal();

    return TRUE;
}

CPreparationApp theApp;


Ok untuk materi menenai MFC dapat dilihat halaman lain...





Katalog

Katalog

Katalog

Katalog

Download Katalog

Download Katalog