Gokhan's questions

Adicionei algumas imagens no documento de fluxo, mas todas as imagens estão listadas em ordem de baixo para cima.

Quero posicionar as imagens em sequência, da esquerda para a direita, quebrando o conteúdo para a próxima linha na borda da caixa de conteúdo, como no Painel de Quebra.

Tentei colocar as imagens no ListView e no Wrap Panel, mas não funciona.

Este é meu método para adicionar imagens a um documento de fluxo.

private BlockUIContainer AddImage(BitmapImage bi,double width,double height)
{
    BlockUIContainer blockUI = new BlockUIContainer();
    Image i = new Image();
    i.Source = bi;
    i.Width = width;
    i.Height = height;
    i.HorizontalAlignment = HorizontalAlignment.Left;
    blockUI.Child = i;
    return blockUI;
}

Tenho controle de datagrid em meu projeto e quero adicionar uma dica de ferramenta às células de datagrid. Personalizei o controle de dica de ferramenta e coloquei um controle de caixa de texto nele. Tentei vincular o valor do conteúdo da célula à caixa de texto, mas não funcionou.

Quando utilizo o controle Tooltip diretamente (sem customizar) ele funciona.

Este é o código xaml:

Sem personalizar, a ligação da dica de ferramenta está funcionando.

 <Window.Resources>
            <Style TargetType="{x:Type DataGridCell}">
                <Setter Property="ToolTip" Value="{Binding RelativeSource={RelativeSource Self},Path=Content.Text}"/>          
            </Style>
</Window.Resources>
     <DataGrid ItemsSource="{Binding Persons}"
               AutoGenerateColumns="True"/>

Mas a vinculação de dicas de ferramentas personalizadas não está funcionando.

<Window.Resources>
    <Style TargetType="DataGridCell">
        <Setter Property="ToolTip">
            <Setter.Value>
                <TextBox Text="{Binding RelativeSource={RelativeSource Self},Path=Content.Text}"/>
            </Setter.Value>
        </Setter>
        
       
    </Style>
</Window.Resources>
     <DataGrid ItemsSource="{Binding Persons}"
               AutoGenerateColumns="True"/>

Esta é a classe do modelo:

public class Person
{
    public string PersonName { get; set; }
    public string Surname { get; set; }
    public string Details { get; set; }
}

Esta é a classe ViewModel:

public class MainViewVM:INotifyPropertyChanged
{
    public ObservableCollection<Person> Persons { get; set; }
    public MainViewVM()
    {
        Persons = new ObservableCollection<Person>
        {
            new Person()
            {
                PersonName = "Andrei",
                Surname = "Surname 1"

            },

            new Person()
            {
                PersonName = "Jack",
                Surname = "Surname 2"

            },


            new Person()
            {
                PersonName = "Melisa",
                Surname = "Surname 3"

            }
        };
    }
   

    public event PropertyChangedEventHandler PropertyChanged;
    protected void NotifyOfPropertyChange(string name)
    {
        PropertyChangedEventHandler handler = PropertyChanged;

        if (handler != null)
        {
            handler(this, new PropertyChangedEventArgs(name));
        }
    }

}

Estou tentando criar uma tabela de resumo usando VBA no aplicativo Excel.

Para conseguir isso, reduzirei as linhas com o mesmo CÓDIGO DO ARTIGO em uma única linha. Compartilhei uma imagem abaixo para facilitar a compreensão.

Tentei resolver criando um array, mas era um código muito longo e não consegui resolver.

Eu tenho um projeto WPF que possui 19 botões de opção. Quero definir a propriedade Command de cada um deles. Para separar todas as ações de comando, quero enviar a propriedade RadioButton Content como um CommandParameter.

Tento definir o setter para a propriedade CommandParameter e defini {Binding Path=Content}para Value como você pode ver abaixo.

Mas não é trabalho.

 <Style TargetType="RadioButton">
        <Setter Property="VerticalAlignment" Value="Center"/>
        <Setter Property="HorizontalAlignment" Value="Left"/>
        <Setter Property="Margin" Value="5"/>
        <Setter Property="Command" Value="{Binding SelectionChangedCommand}"/>
        <Setter Property="CommandParameter" Value="{Binding Path=Content}"/>
    </Style>
          

 <RadioButton Content="Area"/>
            <RadioButton Content="Unit"
                         Grid.Row="1"/>
            
            <RadioButton Content="Transom Count"
                         Grid.Row="2"
                         CommandParameter="Transom Count"/>
            <RadioButton Content="Mullion Count"
                         Grid.Row="3"/>
            <RadioButton Content="Transom And Mulliom Count"
                         Grid.Row="4"/>
            <RadioButton Content="Frame Count"
                         Grid.Row="5"/>
            <RadioButton Content="Frame + Transom + Mullion Count"
                         Grid.Row="6"/>
            <RadioButton Content="Corner Points"
                         Grid.Row="7"/>
            <RadioButton Content="T Connections"
                         Grid.Row="8"/>

            <RadioButton Content="Left"
                         Grid.Column="1"/>
            <RadioButton Content="Right"
                         Grid.Column="1"
                         Grid.Row="1"/>
            <RadioButton Content="Top"
                         Grid.Column="1"
                         Grid.Row="2"/>
            <RadioButton Content="Bottom"
                         Grid.Column="1"
                         Grid.Row="3"/>
            <RadioButton Content="Perimeter"
                         Grid.Column="1"
                         Grid.Row="4"/>
            <RadioButton Content="Transom Length"
                         Grid.Column="1"
                         Grid.Row="5"/>
            <RadioButton Content="Mullion Length"
                         Grid.Column="1"
                         Grid.Row="6"/>
            <RadioButton Content="Transom + Mullion Length"
                         Grid.Column="1"
                         Grid.Row="7"/>
            <RadioButton Content="Perimeter + Transom + Mullion Length"
                         Grid.Column="1"
                         Grid.Row="8"/>

Estou convertendo meu aplicativo para o padrão MVVM. Estou tentando descobrir a função de zoom.

Há painel de tela e elipse no meu projeto.

O problema é que a função zoomIn está funcionando, mas apenas quando o ponteiro do mouse está na forma.

Acho que o tamanho do painel de tela que criei em XAML é igual ao tamanho da forma. Portanto, preciso aplicar essa função de zoom ao controle de grade do pai da tela.

Estes são os códigos XAML.

<Window x:Class="CanvasSampleMvvm.View.MainView"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
        xmlns:local="clr-namespace:CanvasSampleMvvm.View"
        xmlns:model="clr-namespace:CanvasSampleMvvm.Model"
        xmlns:vm="clr-namespace:CanvasSampleMvvm.ViewModel"
        mc:Ignorable="d"
        Title="MainView" Height="450" Width="800">

    <Window.Resources>
        <vm:MainViewVM x:Key="vm"/>
    </Window.Resources>
    <Grid DataContext="{StaticResource vm}">

        <ItemsControl ItemsSource="{Binding Path=Shapes}">

            <i:Interaction.Triggers>
                <i:EventTrigger EventName="MouseWheel">
                    <i:InvokeCommandAction Command="{Binding ZoomInCommand}" PassEventArgsToCommand="True"/>
                </i:EventTrigger>
            </i:Interaction.Triggers>
            
            <ItemsControl.Resources>
                <DataTemplate DataType="{x:Type model:mShape}">
                    <Path Data="{Binding Geometry}" Stroke="{Binding Stroke}" Fill="{Binding Fill}" RenderTransform="{Binding Transform}" />
                </DataTemplate>
            </ItemsControl.Resources>
            <ItemsControl.ItemsPanel>
                <ItemsPanelTemplate>
                    <Canvas DataContext="{StaticResource vm}">
                        <Canvas.RenderTransform>
                            <ScaleTransform
                                ScaleX="{Binding Zoomlevel,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay}" 
                                ScaleY="{Binding Zoomlevel,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay}" 
                                CenterX="{Binding ZoomCenterX, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}" 
                                CenterY="{Binding ZoomCenterY, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
                        </Canvas.RenderTransform>
                    </Canvas>
                </ItemsPanelTemplate>
            </ItemsControl.ItemsPanel>
            <ItemsControl.ItemContainerStyle>
                <Style TargetType="ContentPresenter">
                    <Setter Property="Canvas.Left" Value="{Binding Path=XPos}" />
                    <Setter Property="Canvas.Top" Value="{Binding Path=YPos}" />
                </Style>
            </ItemsControl.ItemContainerStyle>
        </ItemsControl>

    </Grid>
</Window>

Estes são os códigos ViewModel:

public class MainViewVM : INotifyPropertyChanged
{
    public ObservableCollection<mShape> Shapes { get; } = new ObservableCollection<mShape>();
    private readonly MatrixTransform transform = new MatrixTransform();
    public ZoomInCommand ZoomInCommand { get; set; }
    public MainViewVM()
    {
        ZoomInCommand = new ZoomInCommand(this);

        Shapes.Add(new mShape
        {
            XPos = 100,
            YPos = 100,
            Stroke = new SolidColorBrush(Color.FromArgb(0xFF, 0x66, 0x66, 0x66)),
            Transform = transform,
            Geometry = new EllipseGeometry { RadiusX = 50, RadiusY = 50 },
            Fill = (SolidColorBrush)new BrushConverter().ConvertFrom("#D3D3D3")

    });
    }
    public void ZoomIn()
    {
        double scaleFactor = zoomLevel;

        Matrix scaleMatrix = Shapes[0].Transform.Matrix;

        scaleMatrix.ScaleAt(scaleFactor, scaleFactor, 0, 0);
        for (int i = 0; i < Shapes.Count; i++)
        {
            double x = Shapes[i].XPos;
            double y = Shapes[i].YPos;
            double sx = x * zoomLevel;
            double sy = y * zoomLevel;
            Shapes[i].XPos = sx;
            Shapes[i].XPos = sy;
            Shapes[i].Transform.Matrix = scaleMatrix;

        }
    }

    private double zoomLevel = 1.1;
    public double ZoomLevel
    {
        get { return zoomLevel; }
        set
        {
            zoomLevel = value;
            OnPropertyChanged("ZoomLevel");
        }
    }

    private double zoomCenterX;
    public double ZoomCenterX
    {
        get { return zoomCenterX; }
        set
        {
            zoomCenterX = value;
            OnPropertyChanged("ZoomCenterX");
        }
    }

    private double zoomCenterY;
    public double ZoomCenterY
    {
        get { return zoomCenterY; }
        set
        {
            zoomCenterY = value;
            OnPropertyChanged("ZoomCenterY");
        }
    }
    private void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
    public event PropertyChangedEventHandler PropertyChanged;

}

Estas são classes de modelo (mShape)

public class mShape
{
    public double XPos { get; set; }
    public double YPos { get; set; }
    public MatrixTransform Transform { get; set; }
    public Geometry Geometry { get; set; }
    public Brush Stroke { get; set; }
    public Brush Fill { get; set; }
}

Estes são os códigos ZoomInCommand:

public class ZoomInCommand : ICommand
{
    event EventHandler ICommand.CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }
    public MainViewVM VM { get; set; }
    public ZoomInCommand(MainViewVM vm)
    {
        VM = vm;
    }
    bool ICommand.CanExecute(object parameter)
    {
        return true;
    }
    void ICommand.Execute(object parameter)
    {
        VM.ZoomIn();
    }
}