|
|
|
|
|
Hier stehen allgemeine Tipps und Informationen zum Umgang mit Dialogen.
- Der Unterschied zwischen modalen und nichtmodalen Dialogen
- Dialog nicht mehr mit 'Enter' oder 'Escape' beenden
- Dialogtitel während der Laufzeit ändern
- Doppelstart einer Anwendung verhindern
- Drucken in einem Dialog
- Eigenen Dialog anzeigen - DoModal()
- Ein Projekt umbenennen (nur VC++ 6)
- Einen zweiten Dialog beim Programmstart mitstarten
- Farbiger Dialog
- Kontextmenü in Dialog einfügen
- Lib-Datei einbinden
- Menü in Dialog einfügen
- Schließen-Kreuz zur Laufzeit deaktivieren
- Statusbar in eine dialogfeldbasierte Anwendung einfügen
- Toolbar in eine dialogfeldbasierte Anwendung einfügen (nur VC++ 6)
- Tooltips einfügen
- Vollbild Dialog - ShowWindow()/ModifyStyle()
Der Unterschied zwischen modalen und nichtmodalen Dialogen ist leicht erklärt:
Ist ein modaler Dialog geöffnet, muss dieser erst geschlossen werden, bevor man an dem restlichen Programm weiter arbeiten kann. Der Windows-Editor ist ein gutes Beispiel dafür. Hier kann immer nur eine Datei geöffnet sein. Klicke doch auch mal im Windows-Editor auf das ? oben in der Menüleiste und dann auf Info. Jetzt erscheint der Info-Dialog des Editors. Man kann erst mit dem Editor weiter arbeiten, wenn dieser Dialog geschlossen wird.
Nichtmodale Dialoge, wie z.B. bei Microsoft Excel, können offen sein und man kann trotzdem mit anderen Fensters des Programms arbeiten.
Ein Dialog beendet sich standardmäßig sobald man die Return- oder Escape Taste drückt. Das ist oft ärgerlich, weil es Anwender gewohnt sind, z.B nach Eingaben in ein Eingabefeld die Enter Taste zu drücken. Man kann dies aber mit ganz einfachen Mitteln unterbinden. Ich zeige jetzt zwei Möglichkeiten wie man das verhindern kann.
1. Möglichkeit:
Für die Enter Taste brauchen wir lediglich einen Button einzufügen, ihm in den Eigenschaften Standardschaltfläche zuweisen und ihn unsichtbar machen. Jedesmal wenn die Escape Taste gedrückt wird, wird die Standardfunktion für IDCANCEL aufgerufen, die eine Funktion zum Abbruch des Dialogs beinhaltet. Deshalb überschreiben wir die Standardfunktion für IDCANCEL einfach. Das Schliessen-Kreuz rechts oben in der Anwendung wird dann aber ebenfalls nicht mehr reagieren, da dies im Prinzip ein zweiter Abbrechen-Button ist.
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: DlgBeenden
- Füge einen Button ein und aktiviere in den Eigenschaften die Eigenschaft: Standardschaltfläche (Default Button) und deaktiviere die Eigenschaft: Sichtbar (Visible). Verkleinere den Button auf das Minimum und schon stört er nicht mehr, da er während dem Lauf der Anwendung nicht mehr sichtbar ist. Somit ist die Taste Enter ohne Funktion
- Um das gleiche nun für die Escape Taste zu erreichen, klicke doppelt auf den Abbrechen-Button, um eine Nachrichtenbehandlungsroutine (Funktion) für die BN_CLICKED-Nachricht einzufügen und übernehme den vorgeschlagenen Funktionsnamen. In der erstelleten Funktion steht eine Zeile Code, die für den Abbruch sorgt. Entferne diese Zeile: CDialog::OnCancel();
- Ändere jetzt die ID des Abbrechen-Button in: IDC_ABBRECHEN und klicke wieder doppelt drauf, um erneut eine Funktion einzufügen. Übernehme den vorgeschlagenen Funktionsnamen (OnAbbrechen) und füge die vorher entfernte Zeile in die eben erstelle Funktion ein:
void CDlgBeendenDlg::OnCancel()
{
// TODO: Zusätzlichen Bereinigungscode hier einfügen
}
void CDlgBeendenDlg::OnAbbrechen()
{
CDialog::OnCancel();
}
- Da das Schliessen-Kreuz funktionslos ist, entferne es über die Eigenschaften des Dialogs. Deaktiviere dazu die Eigenschaft: Systemmenü
2. Möglichkeit:
Eine andere Möglichkeit ist es die Tasten Enter und Escape abzufangen und darauf zu reagieren. So kann man den Tasten eine beliebige Funktionalität zuweisen oder keine, wie im folgenden Beispiel.
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: DlgBeenden2
- Überschreibe die Funktion PreTranslateMessage() für die Dialogklasse (CDlgBeendenDlg)
- Füge folgenden Code in die eben erstellte Funktion ein:
BOOL CDlgBeenden2Dlg::PreTranslateMessage(MSG* pMsg)
{
if(pMsg->message == WM_KEYDOWN)
{
// ESC-Taste abfangen
if(pMsg->wParam == VK_ESCAPE) || (pMsg->wParam == VK_RETURN)
{
return 0;
}
}
return CDialog::PreTranslateMessage(pMsg);
}
Downloads: DlgBeenden.exe - Gesamtes Projekt
DlgBeenden2.exe - Gesamtes Projekt
Der Titel eines Dialog lässt sich während der Laufzeit mit der Funktion SetWindowText() ändern.
Beispiel:
In der folgenden Anwendung fügen wir lediglich einen Button ein, in dem wir die Funktion zum ändern des Dialogtitels einfügen.
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: DlgTitel
- Füge ein Textfeld für die Überschrift ein und ändere den Titel in: Dialogtitel ändern
- Füge einen Button ein, behalte die vorgeschlagene ID (IDC_BUTTON1) und ändere den Titel in: Neuer Titel
- Klicke doppelt auf den eingefügten Button, um eine Nachrichtenbehandlungsroutine (Funktion) für die BN_CLICKED-Nachricht
einzufügen. Übernehme den vorgeschlagenen Funktionsnamen und trage folgenden Code in die eben erstellte Funktion ein:
void CDlgTitelDlg::OnButton1()
{
SetWindowText("Geänderter Titel");
}
Downloads: DlgTitel.exe - Gesamtes Projekt
Um zu verhindern das eine bereits gestartete Anwendung erneut aufgerufen wird, kann man mit der Funktion CreateMutex() eine systemweite Kennung anlegen.
Beispiel:
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: Doppelstart
- Füge ein Textfeld für die Überschrift ein und ändere den Titel in: Doppelstart einer Anwendung verhindern
- Füge folgenden Code in die Funktion OnInitDialog() ein:
BOOL CDoppelstartDlg::OnInitDialog()
{
...
// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
// Nötige Variablen erstellen und Kennung zuweisen´
char *p_appName = "KeinDoppelstart";
DWORD dwError;
// Kennung erstellen
CreateMutex(NULL, true, p_appName);
// Fehlermeldung prüfen
dwError = GetLastError();
if (ERROR_ALREADY_EXISTS == dwError)
{
MessageBox("Die Anwendung wurde bereits gestartet!", "Fehler!", MB_ICONERROR);
//Anwendung schliessen
OnOK();
}
return TRUE;
Beschreibung:
Als erstes legen wir einen Namen für unsere Anwendung fest (KeinDoppelstart). Dann erzeugen wir eine Variable, die einen Fehlercode aufnehmen wird. Danach verwenden wir die Funktion CreateMutex() , um eine einmalige Kennzeichnung für unsere Anwendung zu erstellen, indem wir ihr den vorher festgelegten Namen übergeben (KeinDoppelstart). Mit der Funktion GetLastError() holen wir uns die zuletzt bekannte Fehlermeldung des laufenden Programms (eigentlich des aktuell laufenden Threads). Wurde die Anwendung bereits gestartet, gibt die Funktion den Code ERROR_ALLREADY_EXISTS zurück.
Downloads: Doppelstart.exe - Gesamtes Projekt
Wie man aus einer dialogfeldbasierten Anwendung heraus drucken kann, steht im Bereich Drucken und zwar hier: Drucken im Dialog
Um einen eigenen Dialog anzeigen zu lassen, muss man diesen erst einmal unter Ressourcen/Neuen Dialog einfügen einfügen. Dann müssen wir eine Klasse für den neuen Dialog erstellen. Angenommen man nennt die neu erstellte Klasse CEingabe, dann kann man sich so seinen Dialog anzeigen lassen:
// Eine Instanz der Klasse CEingabe erzeugen
CEingabe dlg;
// Den neuen Dialog aufrufen
dlg.DoModal();
Um den Dialog aufrufen zu können, ist es nötig die neue Klasse der Haupt- bzw. Ansichtsklasse bekannt zu machen. Wenn z.B. das Programm DoModal und die neue Klasse CEingabe heisst, dann würde das so aussehen:
// DoModalDlg.cpp : Implementierungsdatei (Hauptklasse)
#include "stdafx.h"
#include "DoModal.h"
#include "DoModalDlg.h"
#include "Eingabe.h" // Hier wird unsere neue Klasse inkludiert
Beispiel:
Im folgenden Beispiel werden wir einen zweiten Dialog in eine Anwendung einfügen, eine neue Klasse für diesen Dialog erstellen und diesen neuen Dialog dann anzeigen:
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen DoModal und lösche alle vorhandenen Elemente
- Füge ein Textfeld für die Überschrift ein und ändere den Titel in: Eigenen Dialog anzeigen - DoModal()
- Füge einen Button ein, behalte die vorgeschlagene ID (IDC_BUTTON1) und ändere den Titel in: Dialog anzeigen
- Füge einen neuen Dialog in die Anwendung ein und behalte die vorgegebene ID
- Füge für den Dialog noch eine zugehörige Klasse ein und gib ihr den Namen: CEingabe. Als Basisklasse wähle CDialog aus und für die Dialogfeld-ID: IDD_DIALOG1.
- Klicke jetzt doppelt auf den vorher eingefügten Button im Hauptdialog, um eine Nachrichtenbehandlungsroutine (Funktion) für die BN_CLICKED-Nachricht einzufügen und übernehme den vorgeschlagenen Funktionsnamen
- Trage folgenden Code in die eben erstellte Funktion ein:
void CDoModalDlg::OnButton1()
{
// Eine Instanz der Klasse CEingabe erzeugen
CEingabe dlg;
// Den neuen Dialog aufrufen
dlg.DoModal();
}
- Wird die Anwendung jetzt kompiliert, wird dies nicht klappen. Das liegt daran, das wir versuchen eine Instanz von einer Klasse zu erzeugen, die unsere Hauptklasse DoModalDlg.cpp noch gar nicht kennt. Um jetzt die neue Klasse endgütig aufrufen zu können müssen wir der Hauptklasse unserer Anwendung (DoModalDlg.cpp) mitteilen, das wir eine neue Klasse erstellt haben
- Gehe an den Anfang der Hauptklasse (DoModalDlg.cpp) und inkludiere die neue Klasse folgendermaßen:
// DoModalDlg.cpp : Implementierungsdatei
#include "stdafx.h"
#include "DoModal.h"
#include "DoModalDlg.h"
#include "Eingabe.h" // Hier wird unsere neue Klasse inkludiert
Downloads: DoModal.exe - Gesamtes Projekt
Manchmal hat man sein Projektname unglücklich gewählt und möchte dies ändern. Deshalb zeige ich euch jetzt wie man sein Projekt restlos umbenennt.
GANZ WICHTIG: Solltest du die folgende Beschreibung zum Ändern deines Projektnamens an einem eigenen Projekt testen wollen, dann sichere es, bevor du Änderungen vornimmst. Die folgende Beschreibung funktioniert nur mit Projekten die mit Visual C++ 6.0 erstellt wurden. Bei mir hat es immer problemlos funktioniert, aber eine Garantie für ein erfolgreiches Gelingen gebe ich nicht!
Beispiel:
Wir werden jetzt ein Projekt mit dem Namen: Dialog erstellen und es dann in den Projektnamen: Umbenannt umbenennen:
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: Dialog, kompiliere das Projekt und beende Visual C++
- Öffne die Datei: Dialog.dsp mit dem Windows-Editor und drücke Strg + H, um den Ersetzen-Dialog zu öffnen. Bei Suchen nach: gib den Namen unserer Anwendung ein, also Dialog und bei Ersetzen mit: schreibe Umbenannt. Klicke jetzt auf Alle ersetzen und speichere die Datei
- Öffne jetzt die Datei Dialog.dsw mit dem Editor und ersetze die Zeile:
Project: "Dialog"=.\dialog.dsp - Package Owner=<4> mit
Project: "Umbenannt"=.\Umbenannt.dsp - Package Owner=<4>
- Navigiere nun in den Ordner des Projekts und ersetze in allen Dateien das vorkommende Dialog mit Umbenannt (denke auch an die Dateien im res-Ordner und den an den Ordner des Projekts selbst)
Die Datei DialogDlg.h wird zum Beispiel zu UmbenanntDlg.h
Die Datei Dialog.rc wird zu Umbenannt.rc
Die Datei DialogDlg.cpp wird zu UmbenanntDlg.cpp usw
 |
- Starte jetzt das Projekt wieder, kompiliere es und du siehst die erste Fehlermeldung in der Datei Umbenannt.rc. Klicke doppelt drauf und ändere die Zeile:
IDR_MAINFRAME ICON DISCARDABLE "res\\Dialog.ico"
in:
IDR_MAINFRAME ICON DISCARDABLE "res\\Umbenannt.ico"
- Kompiliere erneut und wieder erscheinen Fehler. Es hängt an der Datei Umbenannt.cpp. Klicke doppelt auf die Fehlermeldung und ändere die Zeilen:
#include "Dialog.h"
#include "DialogDlg.h"
in
#include "Umbenannt.h"
#include "UmbenanntDlg.h"
- Kompiliere nochmal und wie erwartet erscheint wieder eine Fehlermeldung. Diesmal hängt es an der Datei UmbenanntDlg.cpp. Klicke doppelt auf die Fehlermeldung und ändere die Zeilen:
#include "Dialog.h"
#include "DialogDlg.h"
in:
#include "Umbenannt.h"
#include "UmbenanntDlg.h"
Und somit hast du es geschafft! Der Projektname wurde erfolgreich geändert und wenn du alles richtig gemacht hast, lässt sich das Projekt jetzt problemlos kompilieren. Sollten noch andere, hier nicht aufgeführte Fehlermeldungen erschienen sein, dann musst du nur genauso wie in den vorigen Änderungen vorgehen, also das Wort Dialog mit Umbenannt austauschen
Um dies besser nachzuvollziehen wird der Vorgang anhand einer Beispielanwendung erklärt.
Beispiel:
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen Extra_Dialog
- Füge ein Textfeld für die Überschrift ein und ändere den Titel in: Einen zweiten Dialog beim Programmstart mitstarten
- Füge einen neuen Dialog in dein Projekt ein und behalte die vorgegebene ID (IDD_DIALOG1)
- Füge eine neue Klasse für den Dialog hinzu. Trage unter Name: CDialog_Neu ein, als Basisklasse wähle CDialog aus und für die Dialogfeld-ID: IDD_DIALOG1. Bestätige deine Eingabe mit OK
- Wir müssen jetzt noch eine Instanz der neuen Klasse (CDialog_Neu) in der Hauptklasse erstellen. Füge also eine Variable für die Dialogklasse (ExtraDialogDlg) ein.
Variablentyp: CDialog_Neu, Variablenname: m_dlgDialog_Neu, Zugriffstatus: Private
- Füge folgenden Code in die Funktion OnInitDialog() der Hauptklasse ein:
BOOL Extra_DialogDlg::OnInitDialog()
{
...
// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
// Das zweite Dialogfeld erzeugen
m_dlgDialog_Neu.Create(IDD_DIALOG1, this);
// Zweites Dialogfeld anzeigen
m_dlgDialog_Neu.ShowWindow(SW_SHOW);
return TRUE;
}
- Inkludiere zum Schluss noch die Header-Datei der neuen Klasse (Dialog_Neu.h) in die Hauptklasse (Extra_DialogDlg.cpp). Gehe dazu an den Anfang der Hauptklasse (Extra_DialogDlg.cpp) und inkludiere die neue Klasse folgendermaßen:
// Extra_DialogDlg.cpp : Implementierungsdatei
#include "stdafx.h"
#include "Extra_Dialog.h"
#include "Extra_DialogDlg.h"
#include "Dialog_Neu.h" // Hier wird unsere neue Klasse inkludiert
Beschreibung:
Der zusätzliche Dialog wurde als nichtmodaler Dialog erzeugt. Den Unterschied zwischen modalen und nichtmodalen Dialogen kannst du
HIER nachlesen. Um den zusätzlichen Dialog z.B direkt neben die Hauptanwendung
zu positionieren kannst du die Funktionen MoveWindow() oder SetWindowPos() verwenden.
Ein Beispiel wie man Dialoge mit der Funktion MoveWindow() verschiebt findest du hier: Steuerelemente allgemein/Dialog in Grösse und Position ändern
Downloads: ExtraDialog.exe - Gesamtes Projekt
Einen Dialog kann man ganz leicht einfärben. Man muss nur eine Nachrichtenbehandlungsroutine für die Nachricht WM_CTLCOLOR einfügen und etwas Code zum färben eintragen.
Beispiel:
HBRUSH CFarbDialogDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
// Hintergrund einfärben
HBRUSH hbr = CreateSolidBrush(RGB(128, 184, 223));
// Texthintergrund transparent machen
pDC->SetBkMode(TRANSPARENT);
return hbr;
}
Beschreibung:
Wir haben einen eigenen Brush erstellt und ihm eine Farbe zugewiesen. Danach setzen wir den Texthintergrund auf transparent. Würden wir das nicht machen, wäre der Texthintergrund weiss hinterlegt.
Downloads: FarbDialog.exe - Gesamtes Projekt
Es ist sehr leicht ein Kontextmenü in einen Dialog einzufügen. So geht's:
Beispiel:
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: KMenü
- Füge ein Menü ein. Eine genaue Anleitung steht hier: Menü einfügen. Die Überschrift für den ersten Menüpunkt ist unwichtig, trage z.B: Programm ein. Nachdem die Überschrift eingetragen wurde haben wir die Möglichkeit darunter auswählbare Menüeinträge einzugeben. Diese sind interessant, da sie im Kontextmenü angezeigt werden. Füge also direkt darunter einen Menüeintrag mit dem Titel: Meldung ausgeben ein. Wenn wir keine ID eingeben, wird diese automatisch erstellt. Die automatisch erstellte ID lautet: ID_TITEL_MELDUNGAUSGEBEN und diese ID behalten wir auch
- Füge nun eine Nachrichtenbehandlungsroutine in die Dialogklasse für die COMMAND- Nachricht des Menüeintrags: Meldung ausgeben ein. Füge in die eben erstellte Funktion folgenden Code ein:
void CKMenuDlg::OnTitelMeldungausgeben()
{
MessageBox("Kontextmenü funktioniert");
}
void CKMenuDlg::OnContextMenu(CWnd* pWnd, CPoint point)
{
CRect rect;
GetWindowRect(rect);
CMenu menu;
menu.LoadMenu(IDR_MENU1);
if(menu != 0)
menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this);
}
Downloads: KMenu.exe - Gesamtes Projekt
Manchmal muss man eine lib-Datei (library) in sein Projekt einbinden, um bestimmte Funktionen nutzen zu können. Eine lib-Datei wird unter die inkludierten Header-Dateien geschrieben. Somit kann der Linker die eingefügte library mitlinken. So gehts:
#pragma comment(lib,"wsock32.lib") // linkt die angegebene library mit
In einer Klasse eingefügt würde das dann so aussehen:
// Erst kommen die Header-Dateien
#include "stdafx.h"
#include "Extra_Dialog.h"
#include "Extra_DialogDlg.h"
// Darunter dann die einzufügende lib-Datei
#pragma comment(lib, "wsock32.lib") // linkt die angegebene library mit
Ein Menü ist leicht in eine dialogfeldbasierte Anwendung eingefügt und man kann damit dem Anwender viele Funktion eines Programms übersichtlich präsentieren.
Beispiel:
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen Menü
- Füge ein Menü ein. Eine genaue Anleitung steht hier: Menü einfügen. Füge als Überschrift für den ersten Menüpunkt: Programm ein. Nachdem die Überschrift eingetragen wurde haben wir die Möglichkeit darunter auswählbare Menüeinträge einzugeben. Füge direkt darunter einen Menüeintrag mit dem Titel: Beenden ein. Wenn wir keine ID eingeben, wird diese automatisch erstellt. Die automatisch erstellte ID lautet: ID_PROGRAMM_BEENDEN und diese ID behalten wir auch
- Füge nun eine Nachrichtenbehandlungsroutine in die Dialogklasse für die COMMAND- Nachricht des Menüeintrags: Beenden ein. Füge in die eben erstellte Funktion folgenden Code ein:
void CMenuDlg::OnProgrammBeenden()
{
MessageBox("Programm wird beendet", "Programmende");
OnOK();
}
Downloads: Menu.exe - Gesamtes Projekt
Man kann in den Eigenschaften eines Dialogs einstellen, ob das Schließen-Kreuz (Formate/Systemmenü) vorhanden oder nicht vorhanden ist. Hier geht es aber darum, wie man das Schließen-Kreuz während der Laufzeit deaktivieren und wieder aktivieren kann.
Beispiel:
Wir werden jetzt eine Anwendung mit einem Button erstellen. Über diesen Button werden wir das Schließen-Kreuz aktivieren bzw. deaktivieren:
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: Schliessen und entferne alle vorhandenen Elemente
- Füge ein Textfeld für die Überschrift ein und ändere den Titel in: Schließen-Kreuz während der Laufzeit deaktivieren
- Füge zwei Buttons ein, ändere die Ids in: IDC_DEAKTIVIEREN und IDC_AKTIVIEREN und die Titel in: Schließen deaktivieren und Schließen aktivieren.
- Klicke doppelt auf jeden Button, um für jeden eine Nachrichtenbehandlungsroutine (Funktion) für die BN_CLICKED-Nachricht
einzufügen. Übernehme die vorgeschlagenen Funktionsnamen und trage folgenden Code in die eben erstellten Funktionen ein:
void CSchliessenDlg::OnDeaktivieren()
{
CMenu* p_Menu = AfxGetMainWnd()->GetSystemMenu(FALSE);
p_Menu->EnableMenuItem(SC_CLOSE, MF_GRAYED);
}
void CSchliessenDlg::OnAktivieren()
{
CMenu* p_Menu = AfxGetMainWnd()->GetSystemMenu(FALSE);
p_Menu->EnableMenuItem(SC_CLOSE, MF_ENABLED);
}
Downloads: Schliessen.exe - Gesamtes Projekt
Man kann ganz einfach eine Statusbar in eine dialogfeldbasierte Anwendung einfügen, so wie man sie aus SDI/MDI Anwendungen kennt.
Beispiel:
Im folgenden Beispiel werden wir eine Statusbar einfügen und diese Schritt für Schritt erweitern bzw. modifizieren.
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: StatusBar und entferne vorhandenen Steuerelemente
- Füge ein Textfeld für die Überschrift ein und ändere den Titel in: StatusBar in einem Dialog
- Füge folgenden Code in die Funktion OnInitDialog() ein:
BOOL CStatusBarDlg::OnInitDialog()
{
...
// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
// StatusBar erzeugen
CStatusBarCtrl* m_StatusBar;
m_StatusBar = new CStatusBarCtrl;
m_StatusBar->Create(WS_CHILD|WS_VISIBLE, CRect(0, 0, 0, 0), this, 0);
// StatusBar einteilen
int nTeilung[3]= {240, 320, -1};
m_StatusBar->SetParts(3, nTeilung);
// Text in die einzelnen Spalten schreiben
m_StatusBar->SetText(("StatusBar im Dialog - Spalte 1"),0, 0);
m_StatusBar->SetText(("Spalte 2"), 1, 0);
m_StatusBar->SetText(("Spalte 3"), 2, 0);
return TRUE;
}
Beschreibung:
Nachdem die Statusbar erzeugt wurde, wird sie eingeteilt. Mit der Funktion SetParts() teilen wir die Statusbar in drei Teile ein (Spalte 1-3). Wir übergeben ein vorher definiertes Array vom Typ int, wobei die Werte bedeuten das Spalte 1 eine Breite von 240 Pixel von links hat, Spalte 2 eine Breite von 80 Pixel und Spalte 3 nimmt den Rest der Statusbar ein. Dafür sorgt der Wert -1.
Mit Hilfe der Funktion SetText() können wir Text in die Spalten der Statusbar schreiben. Als erstes Argument übergeben wir den anzuzeigenden Text, als zweites die Spalte wo der Text erscheinen soll und als drittes Argument übergeben wir 0. Wenn wir das Erscheinungsbild der Statusbar ändern wollten, würden wir hier nicht 0 übergeben. Das machen wir weiter unten in der Erweiterung des Beispiels.
Erweiterung des Beispiels - Ändern des Stils der Statusbar:
Die Funktion SetText() besitzt drei Parameter. Der erste Parameter steht für den anzuzeigenden Text, der zweite Parameter steht für die Spalte wo der Text erscheinen soll und der dritte Parameter für den Stil der im zweiten Parameter anzugebenden Spalte. Im ersten Beispiel hatten wir für den Stil 0 übergeben, da wir den Stil nicht ändern wollten. Um den Stil zu ändern werden wir jetzt SBT_POPOUT übergeben.
- Ändere die drei Zeilen mit der SetText() Funktion folgendermaßen um:
// Text in die einzelnen Spalten schreiben
m_StatusBar->SetText(("StatusBar im Dialog - Spalte 1"),0, SBT_POPOUT);
m_StatusBar->SetText(("Spalte 2"), 1, SBT_POPOUT);
m_StatusBar->SetText(("Spalte 3"), 2, SBT_POPOUT);
Beschreibung:
Durch die Äderung sieht die Statusbar jetzt etwas anders aus. Um die Statusbar ohne Rahmen darzustellen kann SBT_NOBORDERS übergeben werden. Die Statusbar sieht dann aus wie ein normales Textfeld.
Erweiterung des Beispiels - Ändern der Farbe der Statusbar:
Um der Statusbar eine andere Farbe zu verpassen, müssen wir lediglich die Funktion SetBkColor() aufrufen, nachdem wir die Statusbar erzeugt haben. Hier ist der modifizierte Code des ersten Beispiels:
BOOL CStatusBarDlg::OnInitDialog()
{
...
// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
// StatusBar erzeugen
CStatusBarCtrl* m_StatusBar;
m_StatusBar = new CStatusBarCtrl;
m_StatusBar->Create(WS_CHILD|WS_VISIBLE, CRect(0, 0, 0, 0), this, 0);
// StatusBar einfärben
m_StatusBar->SetBkColor(COLORREF(RGB(150, 150, 150)));
// StatusBar einteilen
int nTeilung[3]= {240, 320, -1};
m_StatusBar->SetParts(3, nTeilung);
// Text in die einzelnen Spalten schreiben
m_StatusBar->SetText(("StatusBar im Dialog - Spalte 1"),0, 0);
m_StatusBar->SetText(("Spalte 2"), 1, 0);
m_StatusBar->SetText(("Spalte 3"), 2, 0);
return TRUE;
}
Erweiterung des Beispiels - Ändern der Schriftart der Statusbar:
Wir können auch ohne Probleme eine andere Schriftart in der Statusbar anzeigen lassen. Wir erstellen einfach einen neuen Font mit der Funktion CreateFont() und weisen diesem der Statusbar mit Hilfe der Funktion SetFont() zu.
- Füge eine Variable in die Dialogklasse (CStatusBarDlg) ein - Variablentyp: CFont, Variablenname: m_Schrift, Zugriffstatus: Public
- Hier der komplette modifizierte Code für die Funktion OnInitDialog():
BOOL CStatusBarDlg::OnInitDialog()
{
...
// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
// StatusBar erzeugen
CStatusBarCtrl* m_StatusBar;
m_StatusBar = new CStatusBarCtrl;
m_StatusBar->Create(WS_CHILD|WS_VISIBLE, CRect(0, 0, 0, 0), this, 0);
// StatusBar einteilen
int nTeilung[3]= {240, 320, -1};
m_StatusBar->SetParts(3, nTeilung);
// Text in die einzelnen Spalten schreiben
m_StatusBar->SetText(("StatusBar im Dialog - Spalte 1"),0, 0);
m_StatusBar->SetText(("Spalte 2"), 1, 0);
m_StatusBar->SetText(("Spalte 3"), 2, 0);
// ----- Andere Schriftart in der Statusbar -----
CString str_Schriftart ="Arial";
// Schriftart erstellen - Arial 18p fettt
m_schrift.CreateFont(18, 0, 0, 0, FW_BOLD, 0, 0, 0, DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, str_Schriftart);
// Schrift setzen
m_StatusBar->SetFont(&m_schrift, TRUE);
return TRUE;
}
Beschreibung:
Am Ende der Funktion steht der Code, um die Schriftart- und Grösse zu verändern. Ich habe als Schriftart: Arial und Größe: 16pt gewählt. Selbstverständlich ist hier jede Schriftart- und Größe möglich. Die Statusbar hat sich mit der grösseren Schrift automatisch auch vergrössert.
Erweiterung des Beispiels - Anzeigen eines Icons in der Statusbar:
Um ein Icon neben der Beschriftung in einer beliebigen Spalte der Statusbar anzuzeigen, benötigen wir die Funktion SetIcon(). Als erstes müssen wir angeben in welcher Spalte das Icon angezeigt werden soll, als zweites rufen wir die Funktion LoadIcon() auf, um das Icon zu laden.
- Füge ein neues Icon in die Anwendung ein. Es bekommt automatisch die ID: IDI_ICON1. Male etwas in das Icon rein, damit etwas angezeigt werden kann
- Hier folgt der modifizierte Code des ersten Beispiels, um ein Icon in der ersten Spalte anzuzeigen:
BOOL CStatusBarDlg::OnInitDialog()
{
...
// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
// StatusBar erzeugen
CStatusBarCtrl* m_StatusBar;
m_StatusBar = new CStatusBarCtrl;
m_StatusBar->Create(WS_CHILD|WS_VISIBLE, CRect(0, 0, 0, 0), this, 0);
// StatusBar einteilen
int nTeilung[3]= {240, 320, -1};
m_StatusBar->SetParts(3, nTeilung);
// Text in die einzelnen Spalten schreiben
m_StatusBar->SetText(("StatusBar im Dialog - Spalte 1"),0, 0);
m_StatusBar->SetText(("Spalte 2"), 1, 0);
m_StatusBar->SetText(("Spalte 3"), 2, 0);
// Icon in erster Spalte anzeigen
m_StatusBar->SetIcon(0, AfxGetApp()->LoadIcon(IDI_ICON1));
return TRUE;
}
Beschreibung:
Am Ende der Funktion steht der Code, um das Icon in der ersten Spalte der Statusbar anzuzeigen. Da das Icon grösser ist wie der anzuzeigende Platz in der Spalte wird es nicht komplett angezeigt. Um wie in der Abbildung das komplette Icon anzuzeigen, male das Icon nicht komplett aus oder vergrössere die Spalte indem du die Schriftart bzw. Schriftgrösse veränderst.
Downloads: Statusbar.exe - Gesamtes Projekt
Auch in einer dialogfeldbasierten Anwendung kann man problemlos eine Toolbar einfügen. Für das folgende Beispiel werden wir eine Tooolbar benötigen. Diese kann direkt in Visual C++ erstellt und bearbeitet werden, man kann sie aber auch in einem Bildprogramm erstellen bzw. bearbeiten. Ihr könnt euch aber auch die im Beispiel verwendeten Toolbar HIER! runterladen. Sie muss in das res-Verzeichnis des Projekts eingefügt werden. Wichtig ist noch zu sagen das dieses Beispiel nur mit Visual C++ 6.0 klappt. Auch mit anderen Versionen ist dies möglich, aber ich habe es noch nicht hinbekommen.
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: Toolbar und entferne alle vorhandenen Elemente
- Füge eine Toolbar ein und behalte die vorgegebene ID (IDR_TOOLBAR1). Entwerfe jetzt deine Toolbar oder nimm die Toolbar aus dem Beispiel. Damit weitere Schaltflächen erscheinen, male einfach etwas in die bereits vorhandene Schaltfläche. Die Toolbar muss nicht unbedingt genauso aussehen wie im Beispiel, sollte aber fünf Schaltflächen haben. Die in diesem Beispiel verwendtete Toolbar habe ich mit VC++ erstellt. Wenn du die Toolbar erstellt hast, klicke doppelt auf jede Schaltfläche, um allen einzelnen Schaltflächen noch ID´s zu geben (IDC_TOOLBAR_EINS, IDC_TOOLBAR_ZWEI... usw.)
- Wir müssen jetzt eine Variable für die Dialogklasse (CToolbarDlg) einfügen, um die Toolbar anzeigen zu können - Variablentyp: CToolBar, Name: m_ToolBar, Zugriffstatus: Protected
- Öffne nun den Klassen-Assistenten und der Dialog Hinzufügen einer Klasse erscheint. Wähle Vorhandene Klasse auswählen und bestätige dies mit OK. Siehe dazu auch den folgenden Screenshot:
 |
- Jetzt erscheint der Dialog Klasse auswählen, da wir ja angegeben haben, das wir eine vorhandene Klasse auswählen möchten. Wähle hier die Klasse CToolBarDlg. Sie dazu auch den folgenden Screenshot:
- Füge jetzt über den Klassen-Assistenten für jede Schaltfläche der Toolbar eine Nachrichtenbehandlungsroutine (Funktion) für die Nachricht COMMAND ein. Übernehme die vorgeschlagenen Funktionsnamen (OnToolbarEins, OnToolbarZwei usw). Siehe dazu auch den folgenden Screenshot:
- Trage folgenden Code in die OnInitDialog() Funktion ein:
BOOL CToolbarDlg::OnInitDialog()
{
...
// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
// Toolbar erzeugen
m_ToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
// Unsere Toolbar zuweisen
m_ToolBar.LoadToolBar(IDR_TOOLBAR1);
// Toolbar anzeigen
m_ToolBar.ShowWindow(SW_SHOW);
m_ToolBar.SetBarStyle(CBRS_ALIGN_TOP | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST,0);
return TRUE;
}
- Füge nun folgenden Code in die erstellten Funktionen für die Schaltflächen der Toolbar ein:
void CToolbarDlg::OnToolbarEins()
{
MessageBox("Toolbar Button 'Eins' angeklickt!");
}
void CToolbarDlg::OnToolbarZwei()
{
MessageBox("Toolbar Button 'Zwei' angeklickt!");
}
void CToolbarDlg::OnToolbarDrei()
{
MessageBox("Toolbar Button 'Drei' angeklickt!");
}
void CToolbarDlg::OnToolbarVier()
{
MessageBox("Toolbar Button 'Vier' angeklickt!");
}
void CToolbarDlg::OnToolbarFuenf()
{
MessageBox("Toolbar Button 'Fünf' angeklickt!");
}
Beschreibung:
Die Toolbar ist jetzt schon komplett funktionsfähig. Sie wird korrekt im Dialog angezeigt und die einzelnen Schaltflächen reagieren auf einen Mausklick. Dieses Beispiel findest du unter dem Namen Toolbar.exe in den Downloads. Ich zeige dir jetzt welche Möglichkeiten du hast, um die Toolbar etwas zu verändern.
Die Schaltflächen in der Toolbar vergrössern:
Jetzt zeige ich euch wie man die einzelnen Schaltflächen in einer Toolbar vergrössert. Klicke einfach doppelt auf die erste Schaltfläche der Toolbar und ändere die Breite von 16 auf 35. Jede Schaltfläche in der Toolbar hat sich damit vergrössert. Fülle die entstandenen Lücken mit den passenden Farben aus. Genauso lässt sich auch leicht die Höhe der Schaltflächen in der Toolbar verändern.
Bessere Trennung zwischen den einzelnen Schaltflächen:
Um die einzelnen Schaltflächen der Toolbar etwas voneinander abzutrennen, klicke die erste Schaltfläche an, halte die linke Maustaste gedrückt und schiebe sie halb auf die zweite Schaltfläche. Die Schaltflä,chen rutschen etwas auseinander. Wiederhole dies für die anderen Schaltflächen. Wenn alles richtig ist, siehst du nach dem kompilieren einen kleinen Trennstrich zwischen den Schaltflächen.
Toolbar beliebig im Dialog platzieren
Hier zeige ich euch, wie leicht ihr das Toolbar Beispiel ändern könnt, um die Toolbar links,rechts, oben oder unten anzuzeigen. Wir gaben der Toolbar bei der Erstellung ein paar Eigenschaften mit, eben auch jene die angibt wo die Toolbar im Dialog erscheinen soll:
m_ToolBar.SetBarStyle(CBRS_ALIGN_TOP | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
Mit der Eigenschaft CBRS_ALIGN_... können wir die Position der Toolbar im Dialog vorgeben:
CBRS_ALIGN_TOP - Toolbar oben anzeigen
CBRS_ALIGN_BOTTOM - Toolbar unten anzeigen
CBRS_ALIGN_LEFT - Toolbar links anzeigen
CBRS_ALIGN_RIGHT - Toolbar rechts anzeigen
- Um dies mal auszutesten, füge in den Dialog 4 Buttons ein, ändere die Titel in: Oben, Unten, Links, Rechts und die IDs in: IDC_OBEN, IDC_UNTEN, IDC_LINKS, IDC_RECHTS
- Klicke doppelt auf jeden Button, um für jeden eine Nachrichtenbehandlungsroutine (Funktion) für die BN_CLICKED-Nachricht einzufügen. Übernehme die vorgeschlagenen Funktionsnamen
- Füge folgenden Code in die eben erstellten Funktionen ein:
void CToolbarDlg::OnLinks()
{
m_ToolBar.SetBarStyle(CBRS_ALIGN_LEFT | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST,0);
}
void CToolbarDlg::OnRechts()
{
m_ToolBar.SetBarStyle(CBRS_ALIGN_RIGHT | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST,0);
}
void CToolbarDlg::OnUnten()
{
m_ToolBar.SetBarStyle(CBRS_ALIGN_BOTTOM | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST,0);
}
void CToolbarDlg::OnOben()
{
m_ToolBar.SetBarStyle(CBRS_ALIGN_TOP | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST,0);
}
Beschreibung:
Anhand des Beispiels siehst du wie leicht man eine Toolbar links, rechts, oben oder unten im Dialog platzieren kann. Selbstverständlich kannst du deine Toolbar auch beliebig im Dialog platzieren. Nutze in diesem Fall die Funktionen MoveWindow() oder SetWindowPos().
Ein Beispiel wie man Dialoge mit der Funktion MoveWindow() verschiebt findest du hier: Steuerelemente allgemein
Downloads: Toolbar.exe - Gesamtes Projekt
Toolbar_Position.exe - Gesamtes Projekt
Toolbar_Ressource (Anleitung zum Einfügen liegt bei)
Ein Tooltip ist ein Infofeld für z.B Steuerelemente. Das ist nützlich, um dem Anwender Informationen zu liefern bevor er etwas anklickt.
Beispiel:
Wir erstellen uns jetzt eine Anwendung in der wir nichts machen, ausser Tooltips für die vorhandenen Steuerelemente einzufügen.
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: Tooltip und behalte alle vorhandenen Steuerelemente
- Füge eine Variable für die Dialogklasse (CTooltipDlg) ein - Variablentyp: CToolTipCtrl, Variablenname: m_ToolTip
- Ändere in den Eigenschaften die ID des vorhandenen Textfelds in IDC_STATIC1 und aktiviere Benachrichtigen (Notify)
- Überschreibe die Funktion PreTranslateMessage() für die Dialogklasse (CTooltipDlg)
- Füge folgenden Code in die überschriebene Funktion PreTranslateMessage() ein:
BOOL CTooltipDlg::PreTranslateMessage(MSG* pMsg)
{
// TODO: Speziellen Code hier einfügen und/oder Basisklasse aufrufen
if(IsWindow(m_ToolTip.m_hWnd))
{
m_ToolTip.RelayEvent(pMsg);
}
return CDialog::PreTranslateMessage(pMsg);
}
- Füge nun noch folgenden Code in die Funktion OnInitDialog() ein:
BOOL CToolbarDlg::OnInitDialog()
{
...
// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
// Tooltip erstellen
m_ToolTip.Create(this);
// Zuweisen von Tooltips für die Steuerelemente
m_ToolTip.AddTool(GetDlgItem(IDC_STATIC1),"ToolTip für Textfeld");
m_ToolTip.AddTool(GetDlgItem(IDOK),"Anwendung beenden");
m_ToolTip.AddTool(GetDlgItem(IDCANCEL),"Anwendung abbrechen");
return TRUE;
}
Beschreibung:
In der Funktion OnInitDialog() wird als erstes mit Hilfe der Funktion Create() ein Tooltip erzeugt. Dann wird mit Hilfe der Funktion AddTool() jedem Steuerelement ein Tooltip zugewiesen. In der überschriebenen Funktion PreTranslateMessage() wird mit Hilfe der Funktion IsWindow() abgefragt über welchem Steuerelement sich der Mauszeiger befindet und mit Hilfe der Funktion RelayEvent() der Tooltip angezeigt. Sowie man sich nun mit dem Mauszeiger über dem Textfeld oder den Buttons befindet, erscheint der vorher festgelegte Tooltip.
Downloads: ToolTip.exe - Gesamtes Projekt
Hier zeige ich wie man einen Dialog über das gesamte Bild anzeigen kann.
Beispiel:
Erst werden wir einen Dialog nur auf Vollbild vergrößern, danach werden wir zusätzlich die Titelleiste entfernen, um eine richtige Vollbild Anwendung zu erhalten.
- Erstelle eine Dialogfeldbasierte Anwendung mit dem Namen: Vollbild und entferne alle vorhandene Elemente
- Füge ein Textfeld für die Überschrift ein und ändere den Titel in: Vollbild - Dialog
- Füge einen Button ein, ändere den Titel in: Vollbild und die ID in: IDC_VOLL
- Füge noch einen Button ein, ändere den Titel in: Normal und die ID in: IDC_NORMAL
- Klicke doppelt auf beide Buttons, um für jeden eine Nachrichtenbehandlungsroutine (Funktion) für die BN_CLICKED-Nachricht
einzufügen und übernehme die vorgeschlagenen Funktionsnamen
- Füge folgenden Code in die eben erstellten Funktionen ein:
void CVollbildDlg::OnVoll()
{
// Dialog über den ganzen Bildschirm anzeigen
ShowWindow(SW_SHOWMAXIMIZED);
}
void CVollbildDlg::OnNormal()
{
// Dialog normal anzeigen
ShowWindow(SW_SHOWNORMAL);
}
Beschreibung:
Der Dialog lässt sich nun vergrößern und wieder auf Normalzustand zurücksetzen. Da die Titelleiste noch vorhanden ist, können wir den Dialog auch beliebig verschieben. Genauso könnten wir ihn minimieren und maximieren, wenn wir diese Funktionalität in den Eigenschaften des Dialogs eingestellt hätten.
Um aber einen richtigen Vollbild Dialog zu erhalten erweitern wir die beiden Funktionen, damit beim Vergrößern zusätzlich die Titelleiste entfernt wird. Wenn wir den Dialog zurücksetzen fügen wir die Titelleiste dann wieder hinzu. Wir verwenden dazu die Funktion ModifyStyle().
void CVollbildDlg::OnVoll()
{
// Titelleiste entfernen
ModifyStyle(WS_CAPTION, 0);
// Dialog über den ganzen Bildschirm anzeigen
ShowWindow(SW_SHOWMAXIMIZED);
}
void CVollbildDlg::OnNormal()
{
// Titelleiste hinzufügen
ModifyStyle(0, WS_CAPTION);
// Dialog normal anzeigen
ShowWindow(SW_SHOWNORMAL);
}
Beschreibung:
Der erste Parameter von ModifyStyle() gibt an was in dem Dialog entfernt werden soll, der zweite Parameter was dazugefügt werden soll.
Downloads: Vollbild.exe - Gesamtes Projekt |
Die Vervielfältigung der auf diesen Seiten enthaltenen Informationen und Grafiken ist untersagt, ausgenommen davon ist sämtlicher auf diesen Seiten angezeigter Quellcode. Es wird keinerlei Gewähr für die Richtigkeit und Vollständigkeit der bereitgestellten Informationen übernommen. Haftungsansprüche für Schäden, die durch Nutzung der bereitgestellten Informationen verursacht wurden, sind ausgeschlossen. Für den Inhalt von angegebenen Verweisen wird keine Gewährleistung übernommen.
Copyright © 2005 coding-help.de | |
