Develop Reference

Serialize multiple object of class but list value are the same

I would like to serialize this class by creating multiple objects. the method works and the objects are saved in the xml file but the values of the List variable are always the same for all objects. how can i do to correct.?
[Serializable()]
public class TextureValues
{
[XmlAttribute("Texture_Info")]
public string Name { get; set; }
public string Date { get; set; }
public List<Point> Points { get; set; }
public int Pensize { get; set; }
public int Width { get; set; }
public int Height { get; set; }
public TextureValues() { }
public TextureValues(string name, string date ,List<Point> points,int pensize,int width,int heigth)
{
this.Name = name;
this.Date = date;
this.Points = points;
this.Pensize = pensize;
this.Width = width;
this.Height = heigth;
}
}
Below the method I used in the form to enter object parameters:
public partial class TextureMaker : Form
{
List<TextureValues> textureInfo = new List<TextureValues>();
List<Point> p = new List<Point>();
public TextureMaker()
{
InitializeComponent();
}
private void panelText_Click(object sender, EventArgs e)
{
p.Add(panelText.PointToClient(Cursor.Position));
}
private void buttonSave_Click(object sender, EventArgs e)
{
textureInfo.AddRange(new TextureValues[]
{
new TextureValues(textBoxName.Text,DateTime.Now.ToString(),p,(int)numericPenSize.Value,(int)numTextWidth.Value,(int)numTextHeight.Value)
});
var path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\textures.xml";
FileStream stream = File.Create(path);
XmlSerializer xmlSerializer = new XmlSerializer(typeof(List<TextureValues>));
xmlSerializer.Serialize(stream, textureInfo);
stream.Close();
p.Clear();
}
}

Binding image in listview just displaying string

What's wrong with this picture?
Instead of displaying a nice picture of a prehistoric plant, the string of the location of the bitmap is being displayed!
Here's the XAML (snippet):
<DataTemplate x:Key="YoungPicCell">
<StackPanel Orientation="Horizontal">
<Image Height="200" Width="200" Stretch="None" Source="{Binding Path=YoungPicBmp}" />
</StackPanel>
</DataTemplate>
The filenames (and other data) are loaded at runtime from an XML file.
Here is the data being loaded from the XML file at runtime:
public class LVData
{
public string Name { get; set; }
public string YoungPic { get; set; }
public BitmapSource YoungPicBmp { get { return new BitmapImage(new Uri("{YoungPic}")); } }
public string MediumPic { get; set; }
public BitmapSource MediumPicBmp { get { return new BitmapImage(new Uri("{MediumPic}")); } }
public string AdultPic { get; set; }
public BitmapSource AdultPicBmp { get { return new BitmapImage(new Uri("{AdultPic}")); } }
public bool SaltWater { get; set; }
public bool FreshWater { get; set; }
public bool Grasslands { get; set; }
public bool Swamp { get; set; }
public bool TropicalForest { get; set; }
public bool Forest { get; set; }
public bool ForestEdge { get; set; }
public bool Sand { get; set; }
public bool Coastal { get; set; }
public bool RiverBorder { get; set; }
public bool LakeBorder { get; set; }
public bool Floodplain { get; set; }
}
public class WindowViewModel : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
//called when a property is changed
protected void RaisePropertyChanged(string PropertyName)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(PropertyName));
}
}
private ObservableCollection<LVData> _plantList = new ObservableCollection<LVData>();
public ObservableCollection<LVData> lsvData
{
get { return _plantList; }
set { _plantList = value; RaisePropertyChanged("lsvData"); }
}
public void PopulateDataFromXML(string filename)
{
XDocument loaded = XDocument.Load(#"DinoIslandPlants.xml");
var Plants = from x in loaded.Descendants("Plants")
select new
{
Name = x.Descendants("Name").First().Value,
YoungPic = x.Descendants("YoungPic").First().Value,
MediumPic = x.Descendants("MediumPic").First().Value,
AdultPic = x.Descendants("AdultPic").First().Value,
SaltWater = x.Descendants("SaltWater").First().Value,
FreshWater = x.Descendants("FreshWater").First().Value,
Grasslands = x.Descendants("Grasslands").First().Value,
Swamp = x.Descendants("Swamp").First().Value,
TropicalForest = x.Descendants("TropicalForest").First().Value,
Forest = x.Descendants("Forest").First().Value,
ForestEdge = x.Descendants("ForestEdge").First().Value,
Sand = x.Descendants("Sand").First().Value,
Coastal = x.Descendants("Coastal").First().Value,
RiverBorder = x.Descendants("RiverBorder").First().Value,
LakeBorder = x.Descendants("LakeBorder").First().Value,
Floodplain = x.Descendants("Floodplain").First().Value
};
foreach (var _plant in Plants)
{
_plantList.Add(new LVData {
Name = _plant.Name,
YoungPic = _plant.YoungPic,
MediumPic = _plant.MediumPic,
AdultPic = _plant.AdultPic,
SaltWater = Convert.ToBoolean(_plant.SaltWater),
FreshWater = Convert.ToBoolean(_plant.FreshWater),
Grasslands = Convert.ToBoolean(_plant.Grasslands),
Swamp = Convert.ToBoolean(_plant.Swamp),
TropicalForest = Convert.ToBoolean(_plant.TropicalForest),
Forest = Convert.ToBoolean(_plant.Forest),
Sand = Convert.ToBoolean(_plant.Sand),
Coastal = Convert.ToBoolean(_plant.Coastal),
RiverBorder = Convert.ToBoolean(_plant.RiverBorder),
LakeBorder = Convert.ToBoolean(_plant.LakeBorder),
Floodplain = Convert.ToBoolean(_plant.Floodplain)
});
}
RaisePropertyChanged("lsvData");
}
}

When binding to an Image control you need to bind to a BitmapSource. This should be pretty straight forward. Change the type of the property (or add a new one) to BitmapSource and then in the get do something like this:
... get { return new BitmapImage(new Uri("{PathToImage}")); }
where PathToImage is a recognizable path to the image you want to display.

Match 2 differents object with the same instance name

I would like to know if it is possible to match object with their instance name.
I got :
class AnimatedEntity : DrawableEntity
{
Animation BL { get; set; }
Animation BR { get; set; }
Animation TL { get; set; }
Animation TR { get; set; }
Animation T { get; set; }
Animation R { get; set; }
Animation L { get; set; }
Animation B { get; set; }
Orientation orientation ;
public virtual int Draw(SpriteBatch spriteBatch, GameTime gameTime)
{
//draw depends on orientation
}
}
and
enum Orientation {
SE, SO, NE, NO,
N , E, O, S,
BL, BR, TL, TR,
T, R, L, B
}
Where Orientation is an Enum and Animation a class.
Can I call the correct Animation from the Orientation with the same name ?

Instead of storing the Animations in properties, how about using a dictionary?
Dictionary<Orientation, Animation> anim = new Dictionary<Orientation, Animation> {
{ Orientation.BL, blAnimation },
{ Orientation.BR, brAnimation },
{ Orientation.TL, tlAnimation },
{ Orientation.TR, trAnimation },
{ Orientation.T, tAnimation },
{ Orientation.R, rAnimation },
{ Orientation.L, lAnimation },
{ Orientation.B, bAnimation }
};
You can then use anim[orientation] to access the appropriate animation.

Indeed a Dictionary would be a good option. It could even have an Animation index if the animations would be set from outside:
class AnimatedEntity : DrawableEntity
{
Dictionary<Orientation, Animation> Animations { get; set; }
public AnimatedEntity()
{
Animations = new Dictionary<Orientation, Animation>();
}
public Animation this[Orientation orientation]
{
get{ return Animations[orientation]; }
set{ Animations[orientation] = value;}
}
Orientation Orientation { get; set; }
public void Draw(SpriteBatch spriteBatch, GameTime gameTime)
{
Animation anim = Animations[Orientation];
}
}
Would be used like:
AnimatedEntity entity = new AnimatedEntity();
entity[Orientation.B] = bAnimation;
entity[Orientation.E] = eAnimation;
entity[Orientation.SE] = seAnimation;

Add visual to Custom UI Object

I have a Custom UIElement I created below.
class ClickItem : UIElement
{
public ClickItem()
{
}
public ClickItem(Color color)
{
this.Color = color;
Ellipse _e = new Ellipse();
_e.Fill = new SolidColorBrush(this.Color);
_e.StrokeThickness = 1;
_e.Stroke = Brushes.Black;
_e.Width = 10;
_e.Height = 10;
this.Plotter = _e;
}
public Point CenterPoint { get; set; }
public Ellipse Plotter { get; set; }
public Color Color { get; set; }
}
How do I make the Plotter Ellipse the visual for the UIElement so when I add a ClickItem to a canvas, the `Plotter' shows up.
Canvas canvas = new Canvas();
ClickItem clickItem = new ClickItem(Colors.Red);
canvas.Add(clickItem);
I can do this but I don't know how to get the ClickItem from this if I click on it.
canvas.Add(clickItem.Plotter);

I think you should inherit from user control, or some other relevant lower class, and add the ellipse as a child of your ClickItem.

Simple WPF data binding question with icons

I have a few types that make up a hierarchy like this:
+ Image0.Name
Effect0.Name
Effect1.Name
Effect2.Name
Layer0.Name
Layer1.Name
Layer2.Name
...
+ Image1.Name
Effect0.Name
Effect1.Name
Effect2.Name
Layer0.Name
Layer1.Name
Layer2.Name
...
+ Image2.Name
Effect0.Name
Effect1.Name
Effect2.Name
Layer0.Name
Layer1.Name
Layer2.Name
...
But I can't get my head around the data binding. Here is the code for the types:
public class Image
{
public string Name { get; set; }
public IEnumerable<Effect> Effects { get; set; }
public IEnumerable<Layer> Layers { get; set; }
}
public class Effect
{
public string Name { get; set; }
public Effect ( string name )
{
this.Name = name;
}
}
public class Layer
{
public string Name { get; set; }
public Layer ( string name )
{
this.Name = name;
}
}
public class EditorView : INotifyPropertyChanged
{
IEnumerable<Node> images;
public IEnumerable<Node> Images
{
get { return images; }
set
{
this.images = value;
this.RaisePropertyChanged ( "Images" );
}
}
public event PropertyChangedEventHandler PropertyChanged;
void RaisePropertyChanged ( string propertyName )
{
var handler = this.PropertyChanged;
if ( handler != null )
handler ( this, new PropertyChangedEventArgs ( propertyName ) );
}
}
Additionally these types (Effect, Layer) has a unique icon per type, if you can also show how to bind this, that would help me a lot in understanding it all.

This is how I normally do it, create a base class for the child items and then create I property that returns all the child Items
public class Image
{
public string Name { get; set;}
public IEnumerable<Effect> Effects { get; set; }
public IEnumerable<Layer> Layers { get; set; }
public IEnumerable<Node> Nodes { get { return ((IEnumerable<Node>)Layers).Union((IEnumerable<Node>)Effects); } }
}
public class Effect : Node
{
public Effect(string name)
{
this.Name = name;
}
}
public class Layer : Node
{
public Layer(string name) { this.Name = name; }
}
public class Node
{
public string Name { get; set; }
public Image Icon { get; set; }
}
You should be able to set the Image Property (url of image but you can change the property type) of the respective Effects and Layers and then I've already wired it up, this should work
<TreeView Height="221" HorizontalAlignment="Left" Margin="12,12,0,0" Name="treeView1"
VerticalAlignment="Top" Width="479" ItemsSource="{Binding Images}">
<TreeView.ItemTemplate>
<HierarchicalDataTemplate ItemsSource="{Binding Nodes}">
<StackPanel Orientation="Horizontal">
<TextBlock Text="{Binding Name}"></TextBlock>
<Image Source="{Binding Icon}"></Image>
</StackPanel>
</HierarchicalDataTemplate>
</TreeView.ItemTemplate>
</TreeView>
EDIT
And then set the TreeView Item's DataContext to your ViewModel, just as an example I did this in the code behind:
Image img = new Image();
Effect effect = new Effect("Effect1");
Layer layer = new Layer("Layer1");
img.Name = "Image1";
List<Effect> effects = new List<Effect>();
effects.Add(effect);
img.Effects = effects;
List<Layer> layers = new List<Layer>();
layers.Add(layer);
img.Layers = layers;
List<WpfApplication1.Image> Images = new List<Image>();
Images.Add(img);
EditorView ev = new EditorView();
ev.Images = Images;
treeView1.DataContext = ev;
EDIT2: Pasted complete code (without using statements):
namespace WpfApplication1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
this.DataContext = new EditorView();
}
}
public class Image
{
public string Name { get; set;}
public IEnumerable<Effect> Effects { get; set; }
public IEnumerable<Layer> Layers { get; set; }
public IEnumerable<Node> Nodes { get { return ((IEnumerable<Node>)Layers).Union((IEnumerable<Node>)Effects); } }
}
public class Effect : Node
{
public Effect(string name)
{
this.Name = name;
}
}
public class Layer : Node
{
public Layer(string name) { this.Name = name; }
}
public class Node
{
public string Name { get; set; }
public string Icon { get; set; }
}
public class EditorView : INotifyPropertyChanged
{
public EditorView()
{
Image img = new Image();
WpfApplication1.Effect effect = new WpfApplication1.Effect("Effect1");
WpfApplication1.Layer layer = new Layer("Layer1");
img.Name = "Image1";
List<Effect> effects = new List<WpfApplication1.Effect>();
effects.Add(effect);
img.Effects = effects;
List<Layer> layers = new List<Layer>();
layers.Add(layer);
img.Layers = layers;
List<WpfApplication1.Image> Images = new List<Image>();
Images.Add(img);
this.Images = Images;
}
IEnumerable<Image> images;
public IEnumerable<Image> Images
{
get
{
return images;
}
set { this.images = value; this.RaisePropertyChanged("Images");
}
} public event
PropertyChangedEventHandler
PropertyChanged;
void RaisePropertyChanged(string propertyName)
{ var handler = this.PropertyChanged;
if (handler != null)
handler(this, new PropertyChangedEventArgs(propertyName));
}
}
}

You need to implement the HierarchicalDataTemplate. For sample of it look at the last of this article - http://msdn.microsoft.com/en-us/library/ms742521.aspx and this one - http://blogs.msdn.com/b/chkoenig/archive/2008/05/24/hierarchical-databinding-in-wpf.aspx