TLDR Version:
I need to find a way to implement some sort of “MessageCenter” where any control can register to receive messages from other controls, without knowing where those messages are coming from (or it can know, so long as it doesn’t mean any extra work for me). After typing out this whole thing, I think I’ve helped myself come to the realization of what I’m after, but if you can recommend some pre-packaged solutions, that’d be great!
So, I’m working on this project where the user gets to make some selections and (more-or-less) layout a page. The rules are very strict, though. At every step, they are given a limited number of ways in which they can alter the page. Think of it as a templating system.
There are a number of interfaces:
ITemplate, IContentArea, and ISpecificControl
Each Template has some number of content areas. Each ContentArea has exactly three specific controls.
They get composited together something like this crude drawing:
The big light purple-ish box is the template.
The yellow, pink, and brown boxes are different concrete types of IContentArea.
The green, light blue, and dark purple boxes are different concrete types of ISpecificControl.
Each concrete implementation of these interfaces will have some number of public properties that I would like the user to be able to set.
For instance:
Green boxes might let you set the font size and font color.
Light blue boxes might let you set the background color.
Dark purple boxes might let you set the image size and margin.
Yellow, pink, and brown boxes let you pick which three specific controls you want to use.
The big light purple-ish box lets you choose how the content areas are laid out (some might have only two or three, maybe they’re arranged in a diagonal).
I’ve made a custom attribute that I can apply to properties in the ViewModel that marks them as eligible for user-changes, and I’ve set aside some space to dynamically add settings controls. The idea is that the user can only edit EXACTLY ONE item at a time. When they select it, I’ll use reflection to examine the public properties of the control’s ViewModel and find all the properties that are marked with the editable attribute, look at their types, and dynamically generate controls to edit them (with bindings, of course). We’ll call this the “SettingsWizard.”
So the problem is really two-fold:
1st: How would you recommend I limit the user to only selecting a SINGLE box at a time? Clearly I need some sort of application-wide event or messaging. What form would that take exactly? And how would I register my “SettingsWizard” to pick up on these messages. I feel like this is going to be something really simple, but I’m overlooking it because it doesn’t feel right, or clean.
Anything that let one of these controls send out a message that says, “Hey, I’m the last one to get clicked on. If anyone else was selected, now you’re not,” would solve the problem, so long as the receiving controls didn’t have to know about where the message was coming from.
I was thinking some sort of static “MessageCenter” where when each control is created it registers to be passed messages (in it’s constructor) using a defined interface, and any control has the ability to send out a message to the MessageCenter, which would then pass it along. Does that sound about right? I feel like something of this nature already exists. Like the features in Prism (but I don’t really have the need for any of the rest of the features).
2nd: How would I let my “SettingsWizard” know that he’s got a new item he needs to display settings for? Presumably, a solution for the first item can also be used to solve this one. It’s just a different kind of notification.
Based on your TLDR paragraph, I’d recommend taking a look at the event aggregator pattern. If you’re looking for an existing implementation, you could take a look at Prism’s. I think Prism’s is a little over-engineered and have previously posted a simpler implementation.