Yeeehaaaa!
what's up, dudes?
I'm kicking some code to see if I can give you some good news
This message was deleted
This message was deleted
I have to ask you something, @grokys
listBox.DataTemplates = new DataTemplates
{
new DataTemplate<Person>(o => new Button() { Content = o.Name}),
};
this works as expected
BUT this doesn't:
listBox.DataTemplates = new DataTemplates
{
new DataTemplate(o => new Button() { Content = ((Person)o).Name}),
};
it throws an exception
the non-typed DataTemplate without the match function passes an ItemsPresenter instead of the actual data :S (of type Person)
ok, there's a reason for that
DataTemplate has a
Match function which is called to check if the DataTemplate matches the data
when you use a
DataTemplate<Person> it automatically generates the Match function for you
but you're not passing a
Match so the DataTemplate is matching anything
in the template for
ListBox is a ScrollViewer which contains the ItemsPresenter, i.e. ScrollViewer.Content = new ItemsPresenter()
the when you set the
Content property, a DataTemplate is applied
so it goes up the tree looking for a
DataTemplate that matches ItemsPresenter
it comes to your
DataTemplate and asks it "do you handle ItemsPresenters?" and your DataTemplate says "Yes I do!"
So it passes the
ItemsPresenter in and bang :fire:
does that make sense?
does that make sense?
Aha! Now it has sense!
I think it's something to expect after your explaination
let me think about something
aloud
in the context of XAML, I have a XamlDataTemplate (that inherits from Perspex' DataTemplate)
Then, for example, you have a ListBox and you want to define the template for the Items. You could have something like:grinning:
<ListBox.DataTemplates>
<XamlDataTemplate DataType="SomeType" >
....
</XamlDataTemplate>
</ListBox.DataTemplates>
But DataType should be optional
when you only have one DataTemplate, you should use the only one
but... then, how to match?
if you set the match function to return true always, then it will handle the ItemsPresenter!
I can only think of matching only when the data isn't of type "Control"
but I don't know which consequences could it have
(that kind of matching)
Sorry I don't understand?
What are you trying to do?
Sorry, I wasn't here :S
Look at this XAML
<Window Width="300" Height="300" xmlns:m="model">
<ListBox Items="{Binding Path=People}">
<ListBox.DataTemplates>
<XamlDataTemplate>
<Button Content="Hello world!" />
</XamlDataTemplate>
</ListBox.DataTemplates>
</ListBox>
</Window>
there is a special kind of DataTemplate inside: XamlDataTemplate
it inherits from DataTemplate (your type)
each DataTemplate has a Match and Build
when it comes to XamlDataTemplates, I should define a Match like this:
Match = data =>
{
if (DataType == null)
{
return !(data is Control);
}
return DataType == data.GetType();
};
this works perfectly
but the !(data is Control) part seems weak
the goal of it is that, if you don't specify any DataType for the XamlDataTemplate, it will always match
that is useful when you only have one template :)
do you understand what I'm doing now?
Yes I think so - sorry at a bar right now, will be back home in 15 mins and can talk
ok, back home now
ok, so i think the only difference between Perspex and WPF in this regard is that WPF's
ItemsControl has an ItemTemplate property
I have wondered if that was necessary, but I've not added it because I didn't see a compelling reason
as usually the items in a
ListBox etc have a known type
so you could write:
<Window Width="300" Height="300" xmlns:m="model">
<ListBox Items="{Binding Path=People}">
<ListBox.DataTemplates>
<XamlDataTemplate Type="Person">
<Button Content="Hello world!" />
</XamlDataTemplate>
</ListBox.DataTemplates>
</ListBox>
</Window>
and it would work
the only time you'd need a template without a type is when the items aren't the same type and don't share a base class
which personally I've never needed
do you follow me?
yes, yes
I understand you
there are a few differences from WPF here which I'm only just realising
I was trying to make the DataType optional in the case of having only one type of item
yeah, i agree that that is convenient
but also because I didn't want to implement the converter from string => Type
:D
haha
now that is no excuse ;)
now you see the full reason!
haha yes
but yes, right now it works
yesterday I had problems with TabControl and its items
I'm goint to test them again
yeah - i'm sure there are problems there
i basically got TabControl working well enough to work in the TestApp and then moved to something else!
haha, OK!
i've been looking at WPF DataTemplates and i'm learning some interesting things
I will see if they are inflated just right
<ContentControl>
<ContentControl.Resources>
<DataTemplate DataType="{x:Type local:Item}">
<Label>WHAT?</Label>
</DataTemplate>
</ContentControl.Resources>
<local:Item Value="Hello"/>
</ContentControl>
displays "WHAT?" as you would expect
when I see something that doesn't work, I prioritize the issue and attack it depending on my personal "work items" :)
sure me too
however, in WPF this:
<ContentControl>
<ContentControl.Resources>
<DataTemplate DataType="sys:String">
<Label>WHAT?</Label>
</DataTemplate>
</ContentControl.Resources>
<sys:String>Hello</sys:String>
</ContentControl>
displays "Hello"
so it seems you can't template System.String
:O
interesting
but why?
likewise:
<ContentControl>
<ContentControl.Resources>
<DataTemplate DataType="Label">
<Label>WHAT?</Label>
</DataTemplate>
</ContentControl.Resources>
<Label>Hello</Label>
</ContentControl>
displays "Hello" so it seems you can't template other controls
hahaha
it's a bit heavy to template other controls!
I mean, how would you want that level of wrapping?
i seem to remember at the beginning of perspex i didn't allow you to template other controls
but then i found a use for it
it's like saying "wherever you see an item of type Button use this (...)"
i need to try and remember what it was!
yeah, exactly
you're supposed to template something that doesn't have have an inherent graphic representation
ahhh i know what it was
and with "graphic" I mean "something that is part of the UI"
like ViewModels
what it was?
try going to Perspex.Controls/Templates/DataTemplateExtensions
and at the beginning of
MaterializeDataTemplate add this
if (data is Control)
{
return (Control)data;
}
which is saying "if the data is already a control, don't template it - return it"
then run the test app
OK!
see what happens?
oh dear!
yes, I see!
:)
what's the meaning of this effect?
the items in the TabControls are instances of TabItem
O_O
the tab strip at the top is a simple selecting listbox which displays the items
argghhh!
magical trick!
at least, it sounds like a trick!
in the area below the tab items, i have a content control whose Content is set to TabString.SelectedItem
but I don't know how TabControls should work in terms of composition, so I can be wrong
well, i'm not saying the way it works is the best way ;)
haha, OK. So... TabControls aren't like ListBoxes
from what I understand
so anyway, the
ContentControl templates TabItem to display the tab content instead of the tab control
I get a brief idea of what's happening
but I have to take a look at how controls are templated
this may be completely brain-dead but it's how it works right now ;)
the whole styling thing in Perspex is magic for me
OK!
for the moment, I will test the TabControl in XAML
to see if the items inside are inflated OK
let me check
ok yeah, let me know of any problems
(yesterday it didn't work)
make sure you remove the code I just told you to add though! ;)
(but I have changed a lot of stuff)
haha, don't worry. I have a pristine copy!
I usually have 3 VS instances open at the same time!
<Window Width="300" Height="300" xmlns:m="model">
<StackPanel>
<TabControl>
<TabItem Header="One" />
<TabItem Header="Two" />
<TabItem Header="Three" />
</TabControl>
</StackPanel>
</Window>
Haha! works!
cool!
it inflates just right
by the way
I'm sure you would like the part of the "deferred" XAML loading
it's delicious!
I used the Decorator pattern to allow templates to be caught and replayed
it's great, clean and the best thing is that it works!
without that feature, the Templates wouldn't work
I will show you the XAML that works
(with templates)
cool! so wasn't as difficult as you feared?
it had complex parts
the main part wasn't so difficult (seeing that it could be implemented using a Decorator)
basically you wrap an object assembler into the template-aware decorator
it intercepts every instruction to the original objectAssembler
but when the node that is going to be written is a template, it just records it
(it's not written to the original object assembler)
then, when the template finished, it collects every node that has been written as part of the template and injects it into the deferred loader
then, the loader receives the recorded nodes and can do whatever with them
yeah, i think i undestand
i think that makes perfect sense
if you see it working, you'll understand it 100%, I'm sure
if i understand you correctly i imagine that's how System.Xaml does it
or something similar
no, no
it does a very weird thing!
in fact, I think it handles it far worse
there is not adapter
it just looks if the current member to be written has a deferring writer associated with it
if it has one, the invokes the write to it
and checks if it handled the call using a "if (deferringWriter.Handled==true)"...
if the deferring writer handled the call, it just returns
so, the intercepting code is right there, in the object assembler
the deferred write feature is cluttering the design of the object assembler
2 responsibilities
- assemblying objects
. 2. writing nodes into a guy that records things
my approach is letting the assembler do what it knows how to do: assembling objects and nothing more
makes sense
you may be curious about the object assembler
yeah, point me to the code!
it sounds like a mysterious machine!
and it is, indeed!
Argh,I lost the connectivity!
Home connection went to hell 😞
Writing in mobile now
oh no :(
Well, this is the link to the code!
Be warned that is plain shit ATM
It's the only remaining part that I have to rewrite from scratch
sucks hard
looks good on first glance!
you've been really busy!!!
nah, it's rubbish
you can see it like CPU
you tell it to perform instructions
and it produces a result
you tell the object assembler: start object SomeObject
and after that: end object
and the result is an instance of SomeObject
the instructions are XamlNodes
a stream of them
it's the higher level structure that interprets XAML
BTW, this is the XAML that uses templates
cool! just need to get {x:Type} working ;)
I didn't include any binding inside the template for now because the contents inside the templates don't handle extensions for now
yeah, binding need writing
yes! I got it working before
but the binding works!
not inside templates
but yes :D
oh really? what do you use for binding?
the same syntax as in good-old WPF
look at this
did you write a binding library?
something like that
cool! i assume that you're just simply binding to a single property at the moment
DataContextChangeSynchronizer is the core around that
so {Binding Foo.Bar} won't work?
with change tracking and everything
no, it works!
n-level binding, too!
wow
where is that implemented?
inside this little folder
wow!
you have really been busy!!!
very impressed!
how does the conversion to IObservable<> happen?
It uses INotifyPropertyChanged
it's the base of all of the change monitorization
ahhh ok, so it sets the properties explicitly instead of binding them to an IObservable?
I couldn't find a better way
Yes, but observables should be even easier!
well just setting the properties is good enough for now!
I wanted to make it work like classic MVVM
IObservables will only really be needed when writing control templates i think
anyways, I thought about observables a lot
and saw some problems, I cannot remember what were them
(in ViewModels)
anyways, we could like to observables natively with a special markup extension
yeah, well WPF doesn't even support binding to observables
{Observe}
yeah
watch that!
haha
like i say they're really only needed for binding styles etc
I hope to have the showcases running with Perspex+OmniXAML soon
I'm already loading simple XAML
look forward to it!
there's still so much to do in Perspex itself
:D
good to know you're taking care of XAML!
as soon as it gets 90% done, I can switch and help you
good to know you're taking care of Perspex!
yeah - at the moment it would still be a bit difficult for anyone to help i think as so much is still broken or a work in progress
yes, it's difficult
implementing Menu has been really good because it's exercising pretty much every part of Perspex
even popups!
ha yeah
and eventing
input
bubbling hell
tab navigation
arrow key navigation
terrible! I don't want to know how complex is that
but I'm sure it's a whole lot
f**king ItemsControls with their ItemsPresenter in a different visual tree!
oh God...
so when the template is applied the ItemsPresenter doesn't actually exist
until the popup opens
popups were always a nightmare
yeah
I understand you, bro
and being almost alone
they were always a pain in WPF
i understand why
it's the hard way you're learning!
hey, I'm going to bed
ok good night!
and amazing work!
tomorrow I'll try to make extensions work for DataTemplates
thanks :D the project well deserves it
:)
Perspex with XAML, it's just like Salt and Pepper!
haha, push it good!
well, but Perspex is a whole f**ing framework!
hahaha
aw yeahhh
see you soon!
good night everyone :D
night!