C # WinForms-WPF Interop

Question

Attualmente ho un'applicazione WinForms che si basa su effetti transpareny. Tuttavia, questo sta dimostrando di essere un dolore assoluto nel preverial dietro! WinForms l'apprendimento Im non affronta la trasparenza particolarmente bene.

Mi chiedevo se questo sarebbe qualsiasi utilizzando componenti WPF più facile per il bit di trasparenza e WinForms per il resto (nota ma decorate Id piace spostare l'intera applicazione verso WPF questo proprio non è fattibile!). Non so quasi nulla di WPF, quindi il motivo Im qui! Quello che stavo considereing era:

1) Ospitare un componente WPF all'interno di un controllo utente WinForms per esempio Esempio di WPF di controllo:

<UserControl x:Class="WindowsFormsApplication1.UserControl1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Height="300" Width="300">
    <Grid>
         <Rectangle Name="rectangle1" Stroke="White" Fill="Black" RadiusX="10" RadiusY="10" Opacity="0.7" />
        <Rectangle Margin="57,101,43,99" Name="dialog" Stroke="Gray" Fill="White" RadiusX="10" RadiusY="10" />
    </Grid>
</UserControl>

2) Ospitare un controllo utente WinForms (contenuto) all'interno del rettangolo bianco (finestra) del controllo WPF. 3) consentire il contenuto (controllo utente WinForms) per chiamare codice sul padre del WPF-Control.

Per prima cosa ...

• E 'una cosa ragionevole da fare o sono io ad abbaiare contro l'albero sbagliato?
• questo può essere realizzato in modo più facile?
• Qualcuno mi può aiutare qui? (Codice di esempio sarebbe ben accetto!)
• Infine ... ci sono risorse online che possono aiutare me a) imparare WPF e b) diventare più autosufficienti?

Answer 1

Ecco la soluzione che ho usato per risolvere il problema in questione. Questa soluzione si basa sul controllo sovrapposizione di rendere la sua controllante come immagine bitmap. Questo poi viene dipinta come sfondo del controllo sovrapposizione.

public class OverlayingControl : UserControl
{
    /// <summary>
    /// Overrides the c# standard Paint Background to allow the custom background to be drawn 
    /// within the OnPaint function
    /// </summary>
    /// 
    /// <param name="e">Arguements used within this function</param>
    protected override void OnPaintBackground( PaintEventArgs e )
    {
        //Do Nothing 
    }

    protected override void OnPaint( PaintEventArgs e )
    {
        // Render the Parents image to a Bitmap. NB: bitmap dimensions and Parent Bounds can be changed to achieve the desitred effect
        Bitmap background = new Bitmap( Width, Height, PixelFormat.Format64bppArgb );
        Parent.DrawToBitmap( background, Parent.Bounds );

        // Paint background image             
        g.DrawImage( background, 0, 0, new RectangleF( Location, Size ), GraphicsUnit.Pixel );

        // Perform any alpha-blending here by drawing any desired overlay e.g.
        // g.FillRectangle( new SolidBrush( semiTransparentColor ), Bounds);
    }

}

Ciò avviene esclusivamente all'interno del dominio WinForms, tuttavia Ritengo che possa essere possibile passare questa immagine bitmap a un controllo WPF rendere come richiesto. Attualmente non v'è alcuna disposizione per l'aggiornamento del Bitmap quando cambia il genitore, tuttavia, dovrebbe essere banale per creare un metodo personalizzato che cancella il bitmap e ri-disegna il controllo Overlayng. Non è una soluzione elegante mi rendo conto ... ma sembra funzionare abbastanza bene.

Answer 2

E 'certamente possibile, e credo che lei abbia ragione che sarebbe il modo più semplice per lavorare con trasparenza.

Non ho provato io stesso, ma secondo questo articolo su CodeProject , dovrebbe essere abbastanza semplice. Si dovrebbe usare la ElementHost controllo per ospitare il contenuto WPF.

Hosting WPF in un controllo WinForms è uno scenario supportato, una funzione integrata nel framework. Quindi non ci dovrebbero essere problemi in questo modo. V'è anche una componente WPF per andare nella direzione opposta, WinForms di hosting in un'applicazione WPF.