Kann eine Anwendung in VB.NET 2003 mehr als ein MDI-Formular besitzen?

Question

Kann eine Anwendung in VB.NET 2003 mehr als ein MDI-Formular besitzen?

Antwort

Verwandte Fragen

Wie greife ich in VB.NET 2003 von einem MDI-Formular auf ein Steuerelement zu?

Wie kann man in VB.NET 2003 von einem Child-Formular aus einen Wert aus der MDI-Form abfragen?

Wie kann ich in VB.NET 2003 einen Screenshot eines Child-Forms als BackgroundImage im MDI-Parent anzeigen?

Schließt in VB.NET 2003 bei Shortcut auch das MDI-Formular mit If Not Me.ActiveMdiChild Is Nothing Then Me.ActiveMdiChild.Close()?

Warum schließt in VB.NET 2003 das Strg+W-Shortcut nicht nur das MDI-Child, sondern auch die MDI-Form selbst?

Wie greift man in VB.NET 2003 aus einer Child-Form auf den MDI-Container zu?

Wie kann ich in VB.NET 2003 aus einer Ownerform Daten in einer geöffneten Ownedform ändern?

Ist in VB.NET 2003 bei der Umwandlung mit CInt(True) das Ergebnis -1 und bei CInt(False) das Ergebnis 0?

Wie ermittelt man in VB.NET 2003 die TransparentColor beim Extrahieren eines Icons mit SHGetFileInfo?

Wie wählt man in VB.NET 2003 per Code eine KnownColor aus?

Accepted Answer

In VB.NET 2003 kann eine Anwendung grundsätzlich mehrere MDI-Formulare (also mehrere Formulare, die jeweils als MDI-Container fungieren) besitzen. Allerdings kann **immer nur ein MDI-Container aktiv sein**, d.h. ein Kindformular kann immer nur zu einem MDI-Container gehören. Du kannst also mehrere MDI-Formulare (z.B. `MDIForm1`, `MDIForm2`) in deinem Projekt anlegen und jeweils als `IsMdiContainer = True` setzen. Beim Start deiner Anwendung entscheidest du, welches MDI-Formular angezeigt wird. Es ist aber **nicht möglich**, dass ein Kindformular gleichzeitig in mehreren MDI-Containern angezeigt wird. Zusammengefasst: - **Mehrere MDI-Formulare im Projekt:** Ja, das ist möglich. - **Mehrere MDI-Formulare gleichzeitig geöffnet:** Ja, das ist möglich. - **Ein Kindformular in mehreren MDI-Containern gleichzeitig:** Nein, das ist nicht möglich. Weitere Infos findest du z.B. in der offiziellen Microsoft-Dokumentation zu [MDI-Formularen](https://learn.microsoft.com/de-de/dotnet/desktop/winforms/advanced/multiple-document-interface-mdi-applications?view=netframeworkdesktop-4.8).

Accepted Answer

Um in Visual Basic .NET 2003 (VB.NET 2003) innerhalb einer MDI-Anwendung (Multiple Document Interface) von einem MDI-Parent-Formular (Hauptfenster) auf ein Steuerelement (z. B. einen Button, also &bdq... [mehr]

Accepted Answer

Um in Visual Basic .NET 2003 (VB.NET 2003) innerhalb einer MDI-Anwendung (Multiple Document Interface) von einem MDI-Parent-Formular (Hauptfenster) auf ein Steuerelement (z. B. einen Button, also „Schaltzug“) eines MDI-Child-Formulars (Unterfenster) zuzugreifen, gehst du wie folgt vor: **Beispiel: Zugriff vom MDI-Parent auf einen Button im aktiven MDI-Child** Angenommen, das MDI-Child-Formular heißt `ChildForm` und enthält einen Button namens `Button1`. 1. **Typprüfung und Zugriff:** ```vb ' Im MDI-Parent-Formular: Dim aktivesChild As Form = Me.ActiveMdiChild If aktivesChild IsNot Nothing AndAlso TypeOf aktivesChild Is ChildForm Then Dim child As ChildForm = CType(aktivesChild, ChildForm) child.Button1.Text = "Neuer Text" ' Oder andere Eigenschaften/Methoden End If ``` 2. **Zugriff auf ein bestimmtes MDI-Child:** ```vb For Each f As Form In Me.MdiChildren If TypeOf f Is ChildForm Then Dim child As ChildForm = CType(f, ChildForm) child.Button1.Enabled = False End If Next ``` **Wichtige Hinweise:** - Das Steuerelement (z. B. `Button1`) muss im `ChildForm` als `Public` oder mindestens `Friend` deklariert sein, damit du von außen darauf zugreifen kannst. - Beispiel für die Deklaration im Child-Formular: ```vb Public WithEvents Button1 As System.Windows.Forms.Button ``` **Zusammenfassung:** Du greifst über die `MdiChildren`-Eigenschaft oder `ActiveMdiChild` auf das gewünschte Child-Form zu, prüfst den Typ und kannst dann auf die Steuerelemente zugreifen, sofern sie entsprechend deklariert sind. Weitere Infos zu MDI in VB.NET findest du z. B. bei [Microsoft Learn](https://learn.microsoft.com/de-de/dotnet/desktop/winforms/advanced/multiple-document-interface-mdi-applications?view=netframeworkdesktop-4.8).

Accepted Answer

Um in VB.NET 2003 von einem MDI-Child-Formular auf einen Wert der MDI-Parent-Form zuzugreifen, gehst du wie folgt vor: 1. **Typisieren des Parent-Formulars:** Das MDI-Parent-Formular muss eine &... [mehr]

Accepted Answer

Um in VB.NET 2003 von einem MDI-Child-Formular auf einen Wert der MDI-Parent-Form zuzugreifen, gehst du wie folgt vor: 1. **Typisieren des Parent-Formulars:** Das MDI-Parent-Formular muss eine öffentliche Eigenschaft oder Methode bereitstellen, auf die das Child-Formular zugreifen kann. 2. **Zugriff vom Child-Formular:** Im Child-Formular kannst du über die `Me.MdiParent`-Eigenschaft auf das Parent-Formular zugreifen. Da `MdiParent` vom Typ `Form` ist, musst du es auf den tatsächlichen Typ deines MDI-Parent-Formulars casten. **Beispiel:** Angenommen, dein MDI-Parent-Formular heißt `MainForm` und hat eine öffentliche Eigenschaft: ```vb.net ' Im MDI-Parent (MainForm) Public Property MeinWert As String ``` Im Child-Formular kannst du dann so darauf zugreifen: ```vb.net ' Im MDI-Child Dim parent As MainForm = CType(Me.MdiParent, MainForm) Dim wert As String = parent.MeinWert ``` **Wichtige Hinweise:** - Stelle sicher, dass die Eigenschaft oder Methode im Parent-Formular `Public` ist. - Prüfe ggf. mit `If Not Me.MdiParent Is Nothing Then ...`, ob das Parent-Formular gesetzt ist, bevor du darauf zugreifst. **Zusammengefasst:** Im Child-Formular: ```vb.net Dim parent As MainForm = CType(Me.MdiParent, MainForm) Dim wert As String = parent.MeinWert ``` So kannst du Werte oder Methoden des MDI-Parent-Formulars aus dem Child-Formular heraus nutzen.

Accepted Answer

Um in VB.NET 2003 einen Screenshot eines MDI-Child-Forms zu erstellen und diesen als `BackgroundImage` im MDI-Parent zu verwenden, kannst du wie folgt vorgehen: 1. **Screenshot des Child-Forms erstel... [mehr]

Accepted Answer

Um in VB.NET 2003 einen Screenshot eines MDI-Child-Forms zu erstellen und diesen als `BackgroundImage` im MDI-Parent zu verwenden, kannst du wie folgt vorgehen: 1. **Screenshot des Child-Forms erstellen:** Du kannst das Child-Form in ein Bitmap zeichnen lassen, indem du die `DrawToBitmap`-Methode verwendest. In .NET 1.1 (VB.NET 2003) gibt es diese Methode allerdings noch nicht direkt, daher musst du das Child-Form mit `BitBlt` aus der WinAPI abgreifen. 2. **Bitmap als BackgroundImage setzen:** Das erzeugte Bitmap kannst du dann dem `BackgroundImage`-Eigenschaft des MDI-Parents zuweisen. Hier ein Beispiel, wie du das machen kannst: ```vbnet ' API-Deklarationen Private Declare Auto Function BitBlt Lib "gdi32.dll" ( _ ByVal hdcDest As IntPtr, ByVal nXDest As Integer, ByVal nYDest As Integer, _ ByVal nWidth As Integer, ByVal nHeight As Integer, _ ByVal hdcSrc As IntPtr, ByVal nXSrc As Integer, ByVal nYSrc As Integer, _ ByVal dwRop As Integer) As Boolean Private Const SRCCOPY As Integer = &HCC0020 ' Screenshot-Funktion Public Function GetFormScreenshot(frm As Form) As Bitmap Dim bmp As New Bitmap(frm.Width, frm.Height) Dim g As Graphics = Graphics.FromImage(bmp) Dim hdcDest As IntPtr = g.GetHdc() Dim hdcSrc As IntPtr = frm.CreateGraphics().GetHdc() BitBlt(hdcDest, 0, 0, frm.Width, frm.Height, hdcSrc, 0, 0, SRCCOPY) g.ReleaseHdc(hdcDest) frm.CreateGraphics().ReleaseHdc(hdcSrc) g.Dispose() Return bmp End Function ``` **Anwendung:** Angenommen, dein MDI-Child heißt `childForm` und dein MDI-Parent ist `Me`: ```vbnet ' Child unsichtbar machen childForm.Visible = False ' Screenshot erstellen Dim bmp As Bitmap = GetFormScreenshot(childForm) ' Als BackgroundImage setzen Me.BackgroundImage = bmp ``` **Hinweise:** - Das Child-Form muss sichtbar gewesen sein, damit der Screenshot korrekt ist. - Die Methode funktioniert nur mit klassischen Windows-Forms-Steuerelementen. - In .NET 1.1 gibt es keine direkte Möglichkeit, ein Steuerelement in ein Bitmap zu rendern, daher ist der Weg über die WinAPI notwendig. **Weitere Infos:** - [BitBlt-Funktion (Microsoft Doku)](https://learn.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-bitblt) - [MDI-Formulare in VB.NET (Microsoft Doku)](https://learn.microsoft.com/de-de/dotnet/desktop/winforms/advanced/multiple-document-interface-mdi-applications?view=netframeworkdesktop-4.8) Falls du weitere Details zu WinAPI oder zu MDI in .NET 1.1 brauchst, findest du in der Microsoft-Dokumentation hilfreiche Beispiele.

Accepted Answer

Ja, der von dir genannte Code in VB.NET 2003: ```vb If Not Me.ActiveMdiChild Is Nothing Then Me.ActiveMdiChild.Close() End If ``` schließt das aktuell aktive MDI-Kindformular (also das unt... [mehr]

Accepted Answer

Ja, der von dir genannte Code in VB.NET 2003: ```vb If Not Me.ActiveMdiChild Is Nothing Then Me.ActiveMdiChild.Close() End If ``` schließt das aktuell aktive MDI-Kindformular (also das untergeordnete Formular innerhalb des MDI-Parent-Formulars), **nicht** das MDI-Parent-Formular selbst. Das bedeutet: - Wenn ein Shortcut (z.B. Strg+W) diesen Code ausführt, wird nur das aktive Kindformular geschlossen, sofern eines geöffnet ist. - Das Hauptformular (MDI-Parent) bleibt weiterhin geöffnet. Das MDI-Parent-Formular selbst wird nur geschlossen, wenn du explizit `Me.Close()` im MDI-Parent-Formular aufrufst.

Accepted Answer

Das von dir beschriebene Verhalten tritt häufig auf, wenn das Shortcut (z. B. Strg+W) sowohl im Child-Formular als auch im MDI-Parent-Formular verarbeitet wird oder das Shortcut im MainMenu nicht... [mehr]

Accepted Answer

Das von dir beschriebene Verhalten tritt häufig auf, wenn das Shortcut (z. B. Strg+W) sowohl im Child-Formular als auch im MDI-Parent-Formular verarbeitet wird oder das Shortcut im MainMenu nicht korrekt auf das aktive Child-Formular beschränkt ist. **Mögliche Ursache:** In VB.NET 2003 (Windows Forms) wird das MainMenu-Shortcut standardmäßig auch dann ausgelöst, wenn das MDI-Parent-Formular den Fokus hat. Wenn du Strg+W als Shortcut für „Schließen“ im MainMenu des MDI-Parents definierst, wird dieses Ereignis auch dann ausgelöst, wenn kein Child-Formular aktiv ist – und dann schließt du möglicherweise das MDI-Parent-Formular selbst. **Lösungsvorschlag:** Im Event-Handler für das Schließen-Menü solltest du prüfen, ob ein MDI-Child aktiv ist, und nur dieses schließen. Das MDI-Parent-Formular sollte nicht geschlossen werden. **Beispiel:** ```vb.net Private Sub mnuClose_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles mnuClose.Click If Not Me.ActiveMdiChild Is Nothing Then Me.ActiveMdiChild.Close() End If End Sub ``` Hierbei ist `mnuClose` das Menüelement mit dem Shortcut Strg+W. **Zusätzlicher Hinweis:** Falls du im Child-Form einen eigenen Button zum Schließen hast, sollte dieser einfach `Me.Close()` aufrufen. Das ist korrekt. **Zusammenfassung:** - Das Shortcut im MainMenu sollte nur das aktive Child schließen, nicht das MDI-Parent. - Überprüfe im Event-Handler, ob ein aktives Child existiert. - So verhinderst du, dass das MDI-Parent-Formular durch Strg+W geschlossen wird. **Weitere Infos:** - [MDI-Formulare in Windows Forms](https://learn.microsoft.com/de-de/dotnet/desktop/winforms/advanced/multiple-document-interface-mdi-applications?view=netframeworkdesktop-4.8) - [MainMenu.Shortcut Eigenschaft](https://learn.microsoft.com/de-de/dotnet/api/system.windows.forms.menuitem.shortcut?view=netframework-4.8) Falls du noch ein konkretes Codebeispiel hast, kann die Ursache noch genauer eingegrenzt werden.

Accepted Answer

In VB.NET 2003 kannst du aus einer Child-Form (MDI-Child) auf den MDI-Container (das MDI-Parent-Formular) über die Eigenschaft `Me.MdiParent` zugreifen. Diese Eigenschaft liefert eine Referenz au... [mehr]

Accepted Answer

In VB.NET 2003 kannst du aus einer Child-Form (MDI-Child) auf den MDI-Container (das MDI-Parent-Formular) über die Eigenschaft `Me.MdiParent` zugreifen. Diese Eigenschaft liefert eine Referenz auf das übergeordnete MDI-Formular. Beispiel: ```vb.net ' Innerhalb der Child-Form: Dim parentForm As Form = Me.MdiParent ' Wenn du auf eine bestimmte Eigenschaft oder Methode des MDI-Containers zugreifen möchtest, ' kannst du das MDI-Parent-Formular ggf. in den richtigen Typ umwandeln: Dim mainForm As MainForm = CType(Me.MdiParent, MainForm) mainForm.SomePublicMethod() ``` **Hinweise:** - Ersetze `MainForm` durch den tatsächlichen Namen deines MDI-Parent-Formulars. - Die Methode oder Eigenschaft, auf die du zugreifen möchtest, muss im MDI-Parent als `Public` deklariert sein. **Weitere Infos:** - [Microsoft Docs: Form.MdiParent Property](https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms.form.mdiparent) So kannst du aus einer Child-Form heraus auf den MDI-Container zugreifen.

Accepted Answer

Um in VB.NET 2003 aus einer Owner-Form (Besitzer-Form) auf eine bereits geöffnete Owned-Form (besessene Form) zuzugreifen und deren Daten zu ändern, gehst du wie folgt vor: **1. OwnedForm r... [mehr]

Accepted Answer

Um in VB.NET 2003 aus einer Owner-Form (Besitzer-Form) auf eine bereits geöffnete Owned-Form (besessene Form) zuzugreifen und deren Daten zu ändern, gehst du wie folgt vor: **1. OwnedForm referenzieren:** Wenn du die OwnedForm beim Öffnen als Instanz speicherst, kannst du später direkt auf deren öffentliche Eigenschaften oder Methoden zugreifen. **Beispiel:** ```vb.net ' In der Owner-Form: Dim frmOwned As New OwnedForm() Me.AddOwnedForm(frmOwned) frmOwned.Show() ``` **2. Daten ändern:** Angenommen, die OwnedForm hat eine öffentliche Methode oder Eigenschaft, um Daten zu setzen: ```vb.net ' In OwnedForm: Public Sub SetzeText(ByVal text As String) Me.TextBox1.Text = text End Sub ``` Dann kannst du aus der Owner-Form heraus Folgendes tun: ```vb.net frmOwned.SetzeText("Neuer Text") ``` **3. Zugriff auf alle OwnedForms:** Falls du die Referenz nicht gespeichert hast, kannst du über die `OwnedForms`-Eigenschaft der Owner-Form auf alle zugehörigen Forms zugreifen: ```vb.net For Each f As Form In Me.OwnedForms If TypeOf f Is OwnedForm Then CType(f, OwnedForm).SetzeText("Neuer Text") End If Next ``` **Wichtige Hinweise:** - Die OwnedForm muss eine öffentliche Methode/Eigenschaft bereitstellen, um Daten zu ändern. - Die Owner-Form muss die OwnedForm als "owned" hinzugefügt haben (`AddOwnedForm`). **Zusammenfassung:** Du kannst aus der Owner-Form heraus auf die OwnedForm zugreifen, indem du entweder die Instanz speicherst oder über die `OwnedForms`-Eigenschaft iterierst. Über öffentliche Methoden/Eigenschaften der OwnedForm kannst du dann die gewünschten Daten ändern.

Accepted Answer

In VB.NET 2003 (also Visual Basic .NET 1.1) gilt Folgendes: - Der Ausdruck `CInt(True)` ergibt **-1**. - Der Ausdruck `CInt(False)` ergibt **0**. Das liegt daran, dass in VB.NET (wie auch in klassis... [mehr]

Accepted Answer

In VB.NET 2003 (also Visual Basic .NET 1.1) gilt Folgendes: - Der Ausdruck `CInt(True)` ergibt **-1**. - Der Ausdruck `CInt(False)` ergibt **0**. Das liegt daran, dass in VB.NET (wie auch in klassischem VB) der Wert von `True` intern als **-1** (alle Bits gesetzt) und `False` als **0** (alle Bits gelöscht) dargestellt wird. **Beispiel:** ```vb Dim a As Integer = CInt(True) ' a = -1 Dim b As Integer = CInt(False) ' b = 0 ``` **Vergleich:** - `CInt(True) = -1` ergibt `True` - `CInt(False) = 0` ergibt `True` **Fazit:** Ja, in VB.NET 2003 ist die Umwandlung `CInt(True) = -1` und `CInt(False) = 0` zulässig und entspricht dem Verhalten der Sprache.

Accepted Answer

In VB.NET 2003 gibt es keine direkte Möglichkeit, die Transparenzfarbe (TransparentColor) eines Icons zu ermitteln, das mit `SHGetFileInfo` extrahiert wurde, da das von `SHGetFileInfo` zurüc... [mehr]

Accepted Answer

In VB.NET 2003 gibt es keine direkte Möglichkeit, die Transparenzfarbe (TransparentColor) eines Icons zu ermitteln, das mit `SHGetFileInfo` extrahiert wurde, da das von `SHGetFileInfo` zurückgegebene Icon-Handle (`hIcon`) keine Information über die Transparenzfarbe enthält. Icons verwenden in der Regel eine Alphamaske oder eine bestimmte Farbe als transparent, aber diese Information ist nicht explizit im Icon-Handle gespeichert. **Typisches Vorgehen:** 1. **Icon extrahieren:** Mit `SHGetFileInfo` erhältst du ein Handle auf das Icon (`hIcon`). 2. **Icon in ein .NET-Icon-Objekt umwandeln:** ```vb.net Dim icon As Icon = Icon.FromHandle(hIcon) ``` 3. **Icon in Bitmap umwandeln:** ```vb.net Dim bmp As Bitmap = icon.ToBitmap() ``` 4. **Transparenzfarbe ermitteln:** Wenn das Icon keine Alphakanal-Transparenz hat, sondern eine bestimmte Farbe als transparent verwendet, ist das meist die Farbe des Pixels an Position (0,0) oder die untere linke Ecke. ```vb.net Dim transparentColor As Color = bmp.GetPixel(0, 0) ``` **Achtung:** - Viele Icons nutzen mittlerweile einen Alphakanal (32-Bit-Icons). In diesem Fall ist die Transparenz im Alphakanal gespeichert, und es gibt keine "Transparenzfarbe" im klassischen Sinn. - Bei älteren 256-Farben-Icons ist oft die Farbe an (0,0) oder (bmp.Width-1, bmp.Height-1) als transparent definiert. **Zusammengefasst:** - Es gibt keine API, die dir direkt die Transparenzfarbe eines Icons liefert. - Du kannst versuchen, die Farbe an einer Ecke des Bitmaps zu nehmen, aber das ist nicht immer zuverlässig. - Bei Icons mit Alphakanal ist die Transparenz im Alpha-Wert der Pixel gespeichert. **Beispielcode:** ```vb.net ' SHGetFileInfo-Aufruf und Icon-Handle erhalten (hIcon) Dim icon As Icon = Icon.FromHandle(hIcon) Dim bmp As Bitmap = icon.ToBitmap() Dim transparentColor As Color = bmp.GetPixel(0, 0) ' transparentColor enthält jetzt die Farbe des Pixels oben links ``` **Weitere Infos:** - [SHGetFileInfo-Dokumentation (Microsoft)](https://learn.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shgetfileinfoa) - [Icon.FromHandle (Microsoft)](https://learn.microsoft.com/en-us/dotnet/api/system.drawing.icon.fromhandle) **Fazit:** Eine sichere Ermittlung der Transparenzfarbe ist nicht möglich, da moderne Icons meist einen Alphakanal nutzen. Bei klassischen Icons kannst du die Farbe an einer Ecke als Annäherung verwenden.

Accepted Answer

In VB.NET 2003 kannst du eine Farbe aus der Aufzählung `KnownColor` auswählen und daraus ein `Color`-Objekt erstellen. Das geht so: ```vb.net Dim meineFarbe As Color meineFarbe = Color.From... [mehr]

Accepted Answer

In VB.NET 2003 kannst du eine Farbe aus der Aufzählung `KnownColor` auswählen und daraus ein `Color`-Objekt erstellen. Das geht so: ```vb.net Dim meineFarbe As Color meineFarbe = Color.FromKnownColor(KnownColor.Red) ``` Hier wird die bekannte Farbe „Red“ ausgewählt. Du kannst jede beliebige Farbe aus der [KnownColor-Enumeration](https://learn.microsoft.com/de-de/dotnet/api/system.drawing.knowncolor) verwenden, z.B. `KnownColor.Blue`, `KnownColor.Green` usw. **Zusammengefasst:** 1. Wähle einen Wert aus `KnownColor` (z.B. `KnownColor.Red`). 2. Erzeuge das `Color`-Objekt mit `Color.FromKnownColor(...)`. Beispiel für die Zuweisung an eine Steuerelement-Eigenschaft: ```vb.net Button1.BackColor = Color.FromKnownColor(KnownColor.LightGreen) ``` So kannst du per Code eine bekannte Farbe auswählen und verwenden.