5

我正在按照此处将 a 绑定MenuItem到数据对象的示例进行操作。

<Menu Grid.Row="0" KeyboardNavigation.TabNavigation="Cycle"
      ItemsSource="{Binding Path=MenuCommands}">  
    <Menu.ItemContainerStyle>
        <Style>
            <Setter Property="MenuItem.Header" Value="{Binding Path=DisplayName}"/>
            <Setter Property="MenuItem.ItemsSource" Value="{Binding Path=Commands}"/>
            <Setter Property="MenuItem.Command" Value="{Binding Path=Command}"/>
            <Setter Property="MenuItem.Icon" Value="{Binding Path=Icon}"/>
        </Style>
    </Menu.ItemContainerStyle>                
</Menu>

除了MenuItem' 图标显示为字符串之外，这一切都可以正常工作System.Drawing.Bitmap。有问题的位图由编译资源中的数据对象返回。

internal static System.Drawing.Bitmap folder_page
{
    get
    {
        object obj = ResourceManager.GetObject("folder_page", resourceCulture);
        return ((System.Drawing.Bitmap)(obj));
    }
}

我究竟做错了什么？

4

5 回答 5

9

肯特（当然）有正确的答案。但我想我会继续发布从 System.Drawing.Bitmap (Windows Forms) 转换为 System.Windows.Windows.Media.BitmapSource (WPF) 的转换器的代码......因为这是一个常见问题/问题。

这需要三个步骤：

  1. 在装订中使用图像转换器。
  2. 创建转换器。
  3. 在您的资源中声明转换器。

以下是在绑定中使用图像转换器的方法：

<Setter
    Property="MenuItem.Icon"
    Value="{Binding Path=Icon, Converter={StaticResource imageConverter}}"
/>

而且，这是转换器的代码（将其放入名为 ImageConverter.cs 的文件中）并将其添加到您的项目中：

[ValueConversion(typeof(Image), typeof(string))]
public class ImageConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        BitmapSource bitmapSource;

        IntPtr bitmap = ((Bitmap)value).GetHbitmap();
        try
        {
            bitmapSource = Imaging.CreateBitmapSourceFromHBitmap(bitmap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
        }
        finally
        {
            DeleteObject(bitmap);
        }

        return bitmapSource;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return null;
    }

    [DllImport("gdi32.dll", CharSet=CharSet.Auto, SetLastError=true)]
    static extern int DeleteObject(IntPtr o);
}

以下是您在资源部分中声明它的方式（注意您必须添加的本地命名空间）：

<Window
    x:Class="WpfApplication1.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:WpfApplication2"
>
    <Window.Resources>
        <local:ImageConverter x:Key="imageConverter"/>
    </Window.Resources>
    <!-- some xaml snipped for clarity -->
</Window>

就是这样！

更新

在快速搜索了类似问题后，我注意到Lars Truijens在这里指出之前的转换器实现存在漏洞。我已经更新了上面的转换器代码......这样它就不会泄漏。

有关泄漏原因的更多信息，请参阅此 MSDN链接上的备注部分。

于 2010-04-21T16:42:10.057 回答
5

WPF 适用于ImageSources，而不是System.Drawing类。您需要绑定到ImageSource. 您可以使用转换器将您的转换为Bitmap，ImageSource或者您可以放弃资源并以不同的方式做事。

于 2009-11-24T12:47:12.403 回答
1

WPF 的菜单项有些奇怪，因为它们不像WPF 框架的其余部分那样与ImageSource对象一起使用。

最简单的方法是在视图模型中简单地拥有一个返回完整图像控件的属性，这将使您头疼的程度最小：

public Image MenuIcon
{
    get
    {
        return new Image()
               {
                   Source = CreateImageSource("myImage.png")
               };
    }
}

然后在您的<Style>for 菜单项（例如，您可以在ItemContainerStyle中设置）中，您只需将菜单项的Icon属性绑定到视图模型中的MenuIcon属性：

<Setter Property="Icon" Value="{Binding MenuIcon}" />

有人可能会争辩说，这违背了 MVVM 的精神，但在某些时候，你只需要务实并转向更有趣的问题。

于 2014-02-25T08:56:54.457 回答
0

以下是我为菜单项制作 ViewModel 的方法：AbstractMenuItem。特别注意图标区域：

    #region " Icon "
    /// <summary>
    /// Optional icon that can be displayed in the menu item.
    /// </summary>
    public object Icon
    {
        get
        {
            if (IconFull != null)
            {
                System.Windows.Controls.Image img = new System.Windows.Controls.Image();
                if (EnableCondition.Condition)
                {
                    img.Source = IconFull;
                }
                else
                {
                    img.Source = IconGray;
                }
                return img;
            }
            else
            {
                return null;
            }
        }
    }
    private BitmapSource IconFull
    {
        get
        {
            return m_IconFull;
        }
        set
        {
            if (m_IconFull != value)
            {
                m_IconFull = value;
                if (m_IconFull != null)
                {
                    IconGray = ConvertFullToGray(m_IconFull);
                }
                else
                {
                    IconGray = null;
                }
                NotifyPropertyChanged(m_IconArgs);
            }
        }
    }
    private BitmapSource m_IconFull = null;
    static readonly PropertyChangedEventArgs m_IconArgs =
        NotifyPropertyChangedHelper.CreateArgs<AbstractMenuItem>(o => o.Icon);

    private BitmapSource IconGray { get; set; }

    private BitmapSource ConvertFullToGray(BitmapSource full)
    {
        FormatConvertedBitmap gray = new FormatConvertedBitmap();

        gray.BeginInit();
        gray.Source = full;
        gray.DestinationFormat = PixelFormats.Gray32Float;
        gray.EndInit();

        return gray;
    }

    /// <summary>
    /// This is a helper function so you can assign the Icon directly
    /// from a Bitmap, such as one from a resources file.
    /// </summary>
    /// <param name="value"></param>
    protected void SetIconFromBitmap(System.Drawing.Bitmap value)
    {
        BitmapSource b = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
            value.GetHbitmap(),
            IntPtr.Zero,
            Int32Rect.Empty,
            System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
        IconFull = b;
    }

    #endregion

您只需从此类派生，并在构造函数中调用 SetIconFromBitmap 并传入 resx 文件中的图片。

这是我在Workbench Window中绑定到那些 IMenuItems 的方式：

    <Menu DockPanel.Dock="Top" ItemsSource="{Binding Path=(local:Workbench.MainMenu)}">
        <Menu.ItemContainerStyle>
            <Style>
                <Setter Property="MenuItem.Header" Value="{Binding Path=(contracts:IMenuItem.Header)}"/>
                <Setter Property="MenuItem.ItemsSource" Value="{Binding Path=(contracts:IMenuItem.Items)}"/>
                <Setter Property="MenuItem.Icon" Value="{Binding Path=(contracts:IMenuItem.Icon)}"/>
                <Setter Property="MenuItem.IsCheckable" Value="{Binding Path=(contracts:IMenuItem.IsCheckable)}"/>
                <Setter Property="MenuItem.IsChecked" Value="{Binding Path=(contracts:IMenuItem.IsChecked)}"/>
                <Setter Property="MenuItem.Command" Value="{Binding}"/>
                <Setter Property="MenuItem.Visibility" Value="{Binding Path=(contracts:IControl.Visible), 
                    Converter={StaticResource BooleanToVisibilityConverter}}"/>
                <Setter Property="MenuItem.ToolTip" Value="{Binding Path=(contracts:IControl.ToolTip)}"/>
                <Style.Triggers>
                    <DataTrigger Binding="{Binding Path=(contracts:IMenuItem.IsSeparator)}" Value="true">
                        <Setter Property="MenuItem.Template">
                            <Setter.Value>
                                <ControlTemplate TargetType="{x:Type MenuItem}">
                                    <Separator Style="{DynamicResource {x:Static MenuItem.SeparatorStyleKey}}"/>
                                </ControlTemplate>
                            </Setter.Value>
                        </Setter>
                    </DataTrigger>
                </Style.Triggers>
            </Style>
        </Menu.ItemContainerStyle>
    </Menu>
于 2009-12-05T02:45:48.653 回答
0

为了后代：我想出了这个： 

<Menu.ItemContainerStyle>
    <Style TargetType="MenuItem">
        <Setter Property="Icon" Value="{Binding IconUrl, Converter={ns:UrlToImageConverter Width=16, Height=16}}"/>
    </Style>
</Menu.ItemContainerStyle>

转换器是MarkupExtension和 a的组合IValueConverter，因此您可以内联指定它，而不必使其成为静态资源。

它使用System.Windows.Media.ImageSourceConverter将 uri 转换为 an ImageSource，然后使用该源创建Image控件。作为奖励，它使用serviceProvider提供的参数，ProvideValue因此它可以像 WPF 那样解析相对图像 url。

[ValueConversion(typeof(string), typeof(Image))]
[ValueConversion(typeof(Uri), typeof(Image))]
public class UrlToImageConverter : MarkupExtension, IValueConverter
{
    public int? MaxWidth { get; set; }

    public int? MaxHeight { get; set; }

    public int? MinWidth { get; set; }

    public int? MinHeight { get; set; }

    public Stretch? Stretch { get; set; }

    public StretchDirection? StretchDirection { get; set; }

    private static readonly ImageSourceConverter _converter = new System.Windows.Media.ImageSourceConverter();

    private readonly IServiceProvider _serviceProvider;

    public UrlToImageConverter()
    {
        _serviceProvider = new ServiceContainer();
    }

    /// <summary>  </summary>
    private UrlToImageConverter(UrlToImageConverter provider, IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider ?? new ServiceContainer();
        MaxWidth = provider.MaxWidth;
        MaxHeight = provider.MaxHeight;
        MinWidth = provider.MinWidth;
        MinHeight = provider.MinHeight;
        Stretch = provider.Stretch;
        StretchDirection = provider.StretchDirection;
    }

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value == null) return null;

        var context = GetTypeDescriptorContext();

        bool canConvert;
        if (context == null)
            canConvert = _converter.CanConvertFrom(value.GetType());
        else
            canConvert = _converter.CanConvertFrom(context, value.GetType());

        if (canConvert)
        {
            if (context == null)
                value = _converter.ConvertFrom(value);
            else
                value = _converter.ConvertFrom(context, CultureInfo.CurrentCulture, value);

            if (value is ImageSource source)
            {
                var img = new Image { Source = source };
                if (MaxWidth != null) img.MaxWidth = MaxWidth.Value;
                if (MaxHeight != null) img.MaxHeight = MaxHeight.Value;
                if (MinWidth != null) img.MinWidth = MinWidth.Value;
                if (MinHeight != null) img.MinHeight = MinHeight.Value;                    
                img.Stretch = Stretch ?? System.Windows.Media.Stretch.Uniform;
                img.StretchDirection = StretchDirection ?? System.Windows.Controls.StretchDirection.Both;
                return img;
            }
        }

        return null;
    }

    private ITypeDescriptorContext GetTypeDescriptorContext()
    {
        if (_serviceProvider is ITypeDescriptorContext context)
            return context;
        else
            return (ITypeDescriptorContext)_serviceProvider?.GetService(typeof(ITypeDescriptorContext));
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotSupportedException();
    }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return new UrlToImageConverter(this, serviceProvider);
    }
}
于 2017-10-04T15:14:58.827 回答