Hugo Ribeiro

This Social Movement...

I’m not a fan of how things seam to be going with all these people sharing instant thoughts, comments, and links via Facebook, Twitter, Buzz, etc...

One of these days I was reading this post by Joel Spolsky and I found myself sharing his ideas about Twitter and this new “instant society”...

Having said this, my own company keeps investing more resources in sharing information using Facebook and Twitter...

So, I will give it a try for some time... In “consumer mode”. :)

http://www.facebook.com/people/Hugo-Ribeiro/626367682

http://twitter.com/hgr2012

Posted 18 March 10 10:05 by hgr | 0 Comments
Filed under After Hours

Work Item Manager

This tool by Telerik is a gem that made my work with TFS a lot easier and enjoyable:

TFS Work Item Manager & TFS Project Dashboard

Go get it. It’s free.

Posted 03 December 09 10:58 by hgr | 0 Comments
Filed under Tools, VSTS, Visual Studio

Running that VM Faster

I’ve been running Windows 7 for a while and one of the things that I decided to try is to have all the development environment on a virtual machine.

That’s because my Windows 7 is running on 64 bits and I still need to run a lot of things on 32 bits.

The problem with virtual machines on this scenario is performance.

This little tweak makes my VMWare virtual machine fly. So, if anyone is having issues, try this out.

mainmem.usenamedfile="FALSE"

Posted 21 October 09 12:16 by hgr | 0 Comments
Filed under Tips & Tricks

GASP@Porto: RIA Services

This week – tomorrow (21) to be more precise – GASP will hold a new meeting here in our premises.

This session will be about RIA Services and will be conducted by Nuno Godinho, expert on Silverlight and RIA Services and ASP.NET MVP.

If anyone wants to join us in the discussion, feel free to request it at GASP LinkedIn Group.

Posted 20 October 09 02:41 by hgr | 0 Comments
Filed under GASP, Events, Silverlight

LOB

Great presentation about technologies (becoming) available for developing Line-of-Business Applications (whatever you may think that is…):

http://www.slideshare.net/simonguest/next-generation-lob-line-of-business-applications

Cool stuff there.

Posted 20 October 09 02:30 by hgr | 0 Comments
Filed under Architecture, .NET

Embarrassing…

It’s absolutely incredible that I published only 6 posts this year.

The scenario is even worst if I think that 3 were just to put Feedburner running again and other 2 were just notes about something that as little to do with my work…

Well, this is the 7th… And it’s worst than the previous 6…

Well… management is really making me miserable. :)

Posted 25 September 09 11:44 by hgr | 1 Comments
Filed under After Hours

Why Google Rocks…

Well, it’s not because of Google Docs, not because of Chrome, Wave, Mail, or whatever they do “outside the box”.

It’s just because of this:

Google

The best search engine out there. Ever!

Posted 25 September 09 11:37 by hgr | 1 Comments
Filed under After Hours

FeedBurner and the 512K Maximum File Size III

That’s it! The feed is back online.

Posted 10 July 09 10:54 by hgr | 0 Comments
Filed under Tips & Tricks

FeedBurner and the 512K Maximum File Size II

It didn’t. I think that it’s just another post that needs to go...

Posted 10 July 09 10:50 by hgr | 0 Comments
Filed under Tips & Tricks

FeedBurner and the 512K Maximum File Size

Apparently FeedBurner doesn’t swallow RSS sources that exceed 512K...

Since mine is now at 522K – I suppose because of the source code size in previous posts – this post is just a try to make the older posts go away so that the file size decreases... :)

Let’s hope it will work…

Posted 10 July 09 10:49 by hgr | 0 Comments
Filed under Tips & Tricks

Add-in Express

These past weeks I’ve playing around with Excel add-ins.

Developing an Excel add-in with ribbon customizations, formulas, and task panes is not an easy task.

VSTO doesn’t help a lot. So I’ve been using this great toolset from Add-in Express:

Add-in Express

Try it out if you’re thinking of doing something with Office…

Posted 08 July 09 10:56 by hgr | 0 Comments
Filed under Tools, Tips & Tricks

No Configuration Enterprise Library

From time to time I end up starting a new C# project and bumping into the same old infrastructure requirements like exception handling, logging, caching, etc.

At that point I always get back to Microsoft Enterprise Library... :)

I really like EntLib but this time I had other requirements that prevented me from having a configuration file.

So how the heck can you use EntLib without configuration? It turns out that it’s relatively easy but not so well documented, so that even Google had trouble finding me the solution. :)

I’ll leave it here also for future reference...

Scenario 1 – No Configuration Caching Block

Using the caching block with configuration is very simple. You create the configuration and then simply use the CacheFactory to create the manager. Something like this:

        1: ICacheManager productsCache = CacheFactory.GetCacheManager();

       2: productsCache.Add(product.ProductID, product)

To use it without configuration is a little harder.

First you need to use the CacheManagerFactory to create a factory passing in the configuration settings. Then you use that factory to create the manager.

The magic happens when you create your own class implementing the IConfigurationSource interface (available in Microsoft.Practices.EnterpriseLibrary.Common).

The final code is as follows:

       1: using Microsoft.Practices.EnterpriseLibrary.Caching.Configuration;

       2: using Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations;

       3:  

       4: namespace MyApplication

       5: {

       6:     internal class CacheServiceConfigurationSource : IConfigurationSource

       7:     {

       8:         #region Members

       9:  

        private int expirationFrequencyInSeconds;

        private int maximumElementsBeforeScavenging;

  

        #endregion

  

        #region Constructors

  

        private CacheServiceConfigurationSource()

        {

        }

  

        public CacheServiceConfigurationSource(int expirationFrequencyInSeconds, int maximumElementsBeforeScavenging)

            : this()

        {

            this.expirationFrequencyInSeconds = expirationFrequencyInSeconds;

            this.maximumElementsBeforeScavenging = maximumElementsBeforeScavenging;

        }

  

        #endregion

  

        #region Public Methods

  

        public void Add(IConfigurationParameter saveParameter, string sectionName, ConfigurationSection configurationSection)

        {

        }

  

        public void AddSectionChangeHandler(string sectionName, ConfigurationChangedEventHandler handler)

        {

        }

  

        public ConfigurationSection GetSection(string sectionName)

        {

            if (sectionName.Equals("cachingConfiguration", StringComparison.CurrentCulture))

            {

                CacheManagerSettings result = new CacheManagerSettings();

                result.DefaultCacheManager = "DefaultCacheManager";

  

                CacheStorageData storage = new CacheStorageData();

                storage.StorageEncryption = string.Empty;

                storage.Name = "NullStorage";

                storage.Type = typeof(NullBackingStore);

                result.BackingStores.Add(storage);

  

                CacheManagerData manager = new CacheManagerData();

                manager.Name = "DefaultCacheManager";

                manager.NumberToRemoveWhenScavenging = 10;

                manager.MaximumElementsInCacheBeforeScavenging = this.maximumElementsBeforeScavenging;

                manager.ExpirationPollFrequencyInSeconds = this.expirationFrequencyInSeconds;

                manager.CacheStorage = "NullStorage";

                result.CacheManagers.Add(manager);

  

                return result;

            }

  

            return null;

        }

  

        public void Remove(IConfigurationParameter removeParameter, string sectionName)

        {

        }

  

        public void RemoveSectionChangeHandler(string sectionName, ConfigurationChangedEventHandler handler)

        {

        }

  

        #endregion

    }

}

  

using System;

using System.Configuration;

using System.Text;

using Microsoft.Practices.EnterpriseLibrary.Caching;

using Microsoft.Practices.EnterpriseLibrary.Caching.Expirations;

  

namespace MyApplication

{

    public static class CacheService

    {

        #region Members

  

        private static ICacheManager manager;

  

        #endregion

  

        #region Properties

  

        private static ICacheManager Manager

        {

            get

            {

                if (manager == null)

                {

                    CacheManagerFactory factory = new CacheManagerFactory(new CacheServiceConfigurationSource(Context.Current.Settings.Cache.ExpirationFrequencyInSeconds, Context.Current.Settings.Cache.MaximumElementsBeforeScavenging));

                    manager = factory.CreateDefault();

                }

  

                return manager;

            }

        }

  

        #endregion

  

        #region Public Methods

  

        public static void AddData<T>(string key, T value)

        {

            AddData<T>(key, value, Context.Current.Settings.Cache.ExpirationTimeInSeconds);

        }

  

        internal static void AddData<T>(string key, T value, int expirationInSeconds)

        {

            // Expiration handler

  

            SlidingTime expirationHandler = new SlidingTime(new TimeSpan(0, 0, expirationInSeconds), DateTime.Now);

  

            // Add it

  

            Manager.Add(key, value, CacheItemPriority.Low, null, expirationHandler);

        }

  

        #endregion

    }

}

Notice the GetSection method in CacheServiceConfigurationSource and the Manager property in the CacheService class.

Scenario 2 – No Configuration Logging Block

The logging application block is similar.

With configuration you use the Logger class.

Without configuration you must create a LogWriter using your own IConfigurationSource also.

       1: using System;

       2: using System.Configuration;

       3: using System.Text;

       4: using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;

       5: using Microsoft.Practices.EnterpriseLibrary.Logging.Configuration;

       6: using Microsoft.Practices.EnterpriseLibrary.Logging.Formatters;

       7: using Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners;

       8:  

       9: namespace MyApplication

{

    internal class LoggingConfigurationSource : IConfigurationSource

    {

        #region Public Methods

  

        public void Add(IConfigurationParameter saveParameter, string sectionName, ConfigurationSection configurationSection)

        {

        }

  

        public void AddSectionChangeHandler(string sectionName, ConfigurationChangedEventHandler handler)

        {

        }

  

        public ConfigurationSection GetSection(string sectionName)

        {

            if (sectionName.Equals("loggingConfiguration", StringComparison.CurrentCulture))

            {

                // Logging configuration

  

                LoggingSettings result = new LoggingSettings();

                result.DefaultCategory = "General";

                result.TracingEnabled = true;

                result.LogWarningWhenNoCategoriesMatch = true;

  

                // Listners

  

                FormattedEventLogTraceListenerData listener = new FormattedEventLogTraceListenerData();

                listener.Name = "EventLogListener";

                listener.Source = "Office Extensions";

                listener.Formatter = "TextFormatter";

                listener.Log = "MyApplication";

                listener.MachineName = string.Empty;

                listener.TraceOutputOptions = System.Diagnostics.TraceOptions.None;

                listener.Filter = System.Diagnostics.SourceLevels.All;

                listener.ListenerDataType = typeof(FormattedEventLogTraceListenerData);

                listener.Type = typeof(FormattedEventLogTraceListener);

                result.TraceListeners.Add(listener);

  

                TraceListenerReferenceData listenerReference = new TraceListenerReferenceData();

                listenerReference.Name = "EventLogListener";

  

                // Formatters

  

                StringBuilder template = new StringBuilder();

                template.AppendLine("Timestamp: {timestamp}");

                template.AppendLine("Message: {message}");

                template.AppendLine("Category: {category}");

                template.AppendLine("Priority: {priority}");

                template.AppendLine("EventId: {eventid}");

                template.AppendLine("Severity: {severity}");

                template.AppendLine("Title:{title}");

                template.AppendLine("Machine: {machine}");

                template.AppendLine("Application Domain: {appDomain}");

                template.AppendLine("Process Id: {processId}");

                template.AppendLine("Process Name: {processName}");

                template.AppendLine("Win32 Thread Id: {win32ThreadId}");

                template.AppendLine("Thread Name: {threadName}");

                template.AppendLine("Extended Properties: {dictionary({key} - {value})}");

  

                TextFormatterData formatter = new TextFormatterData();

                formatter.Name = "TextFormatter";

                formatter.Type = typeof(TextFormatter);

                formatter.Template = template.ToString();

                result.Formatters.Add(formatter);

  

                // Category Sources

  

                TraceSourceData exceptionsSource = new TraceSourceData();

                exceptionsSource.TraceListeners.Add(listenerReference);

                exceptionsSource.Name = "Exceptions";

                exceptionsSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

                result.TraceSources.Add(exceptionsSource);

  

                TraceSourceData traceSource = new TraceSourceData();

                traceSource.TraceListeners.Add(listenerReference);

                traceSource.Name = "Trace";

                traceSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

                result.TraceSources.Add(traceSource);

  

                TraceSourceData generalSource = new TraceSourceData();

                generalSource.TraceListeners.Add(listenerReference);

                generalSource.Name = "General";

                generalSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

                result.TraceSources.Add(generalSource);

  

                // Special Sources

  

                result.SpecialTraceSources.AllEventsTraceSource.Name = "AllEvents";

                result.SpecialTraceSources.AllEventsTraceSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

  

                result.SpecialTraceSources.NotProcessedTraceSource.Name = "NotProcessed";

                result.SpecialTraceSources.NotProcessedTraceSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

  

                result.SpecialTraceSources.ErrorsTraceSource.Name = "LoggingErrorsAndWarnings";

                result.SpecialTraceSources.ErrorsTraceSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

                result.SpecialTraceSources.ErrorsTraceSource.TraceListeners.Clear();

                result.SpecialTraceSources.ErrorsTraceSource.TraceListeners.Add(listenerReference);

  

                // Return

  

                return result;

            }

  

            return null;

        }

  

        public void Remove(IConfigurationParameter removeParameter, string sectionName)

        {

        }

  

        public void RemoveSectionChangeHandler(string sectionName, ConfigurationChangedEventHandler handler)

        {

        }

  

        #endregion

    }

}

  

using System;

using System.Diagnostics;

using System.Globalization;

using Microsoft.Practices.EnterpriseLibrary.Logging;

  

namespace MyApplication

{

    public static class LoggingHandler

    {

        #region Constants

  

        private const string CategoryExceptions = "Exceptions";

        private const int PriorityExceptions = 1000;

        private const int EventIdExceptions = 1000;

        private const string TitleExceptions = "Errors Log";

        private const TraceEventType SeverityExceptions = TraceEventType.Error;

  

        #endregion

  

        #region Members

  

        private static LogWriter writer;

  

        #endregion

  

        #region Properties

  

        internal static LogWriter Writer

        {

            get

            {

                if (writer == null)

                {

                    writer = CreateWriter();

                }

  

                return writer;

            }

        }

  

        #endregion

  

        #region Public Methods

  

        public static void Exception(Exception ex)

        {

            // Validation

  

            if (ex == null)

            {

                throw new ArgumentNullException();

            }

  

            // Log

  

            WriteEntry(CategoryExceptions, TitleExceptions, ex.ToString(), PriorityExceptions, EventIdExceptions, SeverityExceptions);

        }

  

        #endregion

  

        #region Private Methods

  

        private static void WriteEntry(string category, string title, string message, int priority, int eventId, TraceEventType severity)

        {

            LogEntry entry = new LogEntry();

            entry.Categories.Add(category);

            entry.TimeStamp = DateTime.Now;

            entry.EventId = eventId;

            entry.Message = message;

            entry.Priority = priority;

            entry.Severity = severity;

            entry.Title = title;

  

            Writer.Write(entry);

        }

  

        private static LogWriter CreateWriter()

        {

            LogWriterFactory factory = new LogWriterFactory(new LoggingConfigurationSource());

            return factory.Create();

        }

  

        #endregion

    }

}

I hope this helps someone in the future.

It turns out that the greater strength of EntLib – configuration – is also, at least in my opinion, its greater weakness. Just think of how many “real-world applications” would you want to have the user messing with the configuration file to setup event viewer listeners and things like that. :)

Posted 15 May 09 12:53 by hgr | 0 Comments
Filed under Architecture, Frameworks, Tips & Tricks

DSL Tools #14 - Double-click in the Model Explorer

Every DSL Tools project generates this handy model explorer where you can browse the domain classes that are on your domain model.

Something like this:

Model Explorer Preview

This is particularly helpful for example to change the properties of a particular domain class. You browse for in the explorer, click on it, and simply edit the properties.

Now there is a fundamental feature that the guys at Microsoft missed in the explorer. The ability to double click a domain class there and have the domain model view show that domain class centered. A feature very useful if you have a model with a few dozens of domains classes (which is very typical).

So I put my mind to implement such behavior on my various DSL explorers. It turns out that it isn't very difficult.

1. Determine the explorer class name

The model explorer class is generated as part of your DSLPackage project. The name of the class depends on the name of your DSL. To find out the correct name, browse the DSLPackage project, under GeneratedCode, and you'll find a file named ModelExplorer.cs. The name of the explorer is the name of the first class on that file.

In my example that is UserInterfaceModelExplorer:

        1: /// <summary>

       2: /// Double-derived class to allow easier code customization.

       3: /// </summary>

       4: internal partial class UserInterfaceModelExplorer : UserInterfaceModelExplorerBase

       5: {

       6:     /// <summary>

       7:     /// Constructs a new UserInterfaceModelExplorer.

       8:     /// </summary>

       9:     public UserInterfaceModelExplorer(global::System.IServiceProvider serviceProvider)

      10:         : base(serviceProvider)

      11:     {

      12:     }

      13: }

2. Create a custom class with that same name

Under the DSLPackage, you will need to create a new custom partial class with the name of your model explorer. All the magic will happen here.

3. Override the CreateElementVisitor method

Here you should subscribe to the ObjectModelBrowser.DoubleClick event:

       1: /// <summary>

       2: /// Executed when the model explorer creates the tree element visitor.

       3: /// </summary>

       4: /// <returns>The tree element visitor.</returns>

       5: protected override IElementVisitor CreateElementVisitor()

       6: {

       7:     // Subscribe double click in the tree view

       8:  

       9:     this.ObjectModelBrowser.DoubleClick += new EventHandler(this.ObjectModelBrowser_DoubleClick);

      10:  

      11:     // Default behavior

      12:  

      13:     return base.CreateElementVisitor();

      14: }

4. Implement the corresponding event handler

The magic consists in:

First, finding the element that is selected in the explorer,
Second, getting the corresponding model element,
And, finally, selecting that shape in the model viewer.

Check the full source code bellow for the implementation of these steps.

5. Transform All templates

Before you test the new behavior of the model explorer, you'll need to transform all the templates to let the DSL know that you have customized your model explorer.

And that's it. Double-click any domain class in the explorer and the model viewer will be updated accordingly.

Full Source Code

       1: using System;

       2: using System.Collections.ObjectModel;

       3: using Microsoft.VisualStudio.Modeling;

       4: using Microsoft.VisualStudio.Modeling.Diagrams;

       5: using Microsoft.VisualStudio.Modeling.Shell;

       6:  

       7: namespace MyDSL.UserInterface

       8: {

       9:     /// <summary>

    /// Custom behavior for UserInterfaceModelExplorer.

    /// </summary>

    internal partial class UserInterfaceModelExplorer

    {

        #region Public Methods

  

        /// <summary>

        /// Executed when the model explorer creates the tree element visitor.

        /// </summary>

        /// <returns>The tree element visitor.</returns>

        protected override IElementVisitor CreateElementVisitor()

        {

            // Subscribe double click in the tree view

  

            this.ObjectModelBrowser.DoubleClick += new EventHandler(this.ObjectModelBrowser_DoubleClick);

  

            // Default behavior

  

            return base.CreateElementVisitor();

        }

  

        #endregion

  

        #region Private Methods

  

        /// <summary>

        /// Selects the specified shape using the given modeling document data.

        /// </summary>

        /// <param name="shapeElement">The shape element that should be selected.</param>

        /// <param name="docData">The modeling document data.</param>

        private static void SelectShape(ShapeElement shapeElement, DocData docData)

        {

            // Validation

  

            if (shapeElement == null)

            {

                throw new ArgumentNullException("shapeElement");

            }

  

            if (docData == null)

            {

                throw new ArgumentNullException("docData");

            }

  

            // Select the shape

  

            ModelingDocView docView = docData.DocViews[0];

            if (docView != null)

            {

                docView.SelectObjects(1, new object[] { shapeElement }, 0);

            }

        }

        

        /// <summary>

        /// Gets the first shape the represents the specified model element.

        /// </summary>

        /// <param name="modelElement">The model element whose shape will be returned.</param>

        /// <returns>The first shape the represents the specified model element.</returns>

        private static ShapeElement GetModelElementFirstShape(ModelElement modelElement)

        {

            // Presentation elements

  

            LinkedElementCollection<PresentationElement> presentations = PresentationViewsSubject.GetPresentation(modelElement);

            foreach (ModelElement element in presentations)

            {

                ShapeElement shapeElement = (element as ShapeElement);

                if (shapeElement != null)

                {

                    return shapeElement;

                }

            }

  

            // Default result

  

            return null;

        }

  

        /// <summary>

        /// Return the model element which is the parent of the specified model element considering that

        /// this element is placed in a compartment.

        /// </summary>

        /// <param name="modelElement">The model element whose parent will be returned.</param>

        /// <returns>

        /// The model element which is the parent of the specified model element considering that

        /// this element is placed in a compartment.

        /// </returns>

        private static ModelElement GetCompartmentElementFirstParent(ModelElement modelElement)

        {

            // Get the domain class associated with model element.

  

            DomainClassInfo domainClass = modelElement.GetDomainClass();

            if (domainClass != null)

            {

                // A element is only considered to be in a compartment if it participates in only 1 embedding relationship

                // This might be wrong for some models

  

                if (domainClass.AllEmbeddedByDomainRoles.Count == 1)

                {

                    // Get a collection of all the links to this model element

                    // Since this is in a compartment there will only be one

  

                    ReadOnlyCollection<ElementLink> links = DomainRoleInfo.GetAllElementLinks(modelElement);

                    if (links.Count == 1)

                    {

                        // Get the model element participating in the link that isn't the current one

                        // That will be the parent

                        // Probably there is a better way to achieve the same result

  

                        foreach (ModelElement linkedElement in links[0].LinkedElements)

                        {

                            if (!modelElement.Equals(linkedElement))

                            {

                                return linkedElement;

                            }

                        }

                    }

                }

            }

  

            // Default result

  

            return null;

        }

  

        #endregion

  

        #region Event Handlers

  

        private void ObjectModelBrowser_DoubleClick(object sender, EventArgs e)

        {

            // Get the node selected in the model explorer tree

  

            ModelElementTreeNode node = (this.ObjectModelBrowser.SelectedNode as ModelElementTreeNode);

            if (node != null)

            {

                // Get the corresponding model element

  

                ModelElement element = node.ModelElement;

                if (element != null)

                {

                    // Get the corresponding shape

                    // If the model element is in a compartment the result will be null

  

                    ShapeElement shape = GetModelElementFirstShape(element);

                    if (shape == null)

                    {

                        // If the element is in a compartment, try to get the parent model element to select that

  

                        ModelElement parentElement = GetCompartmentElementFirstParent(element);

                        if (parentElement != null)

                        {

                            // Get the corresponding shape

  

                            shape = GetModelElementFirstShape(parentElement);

                        }

                    }

  

                    // Select the shape

  

                    if (shape != null)

                    {

                        SelectShape(shape, this.ModelingDocData);

                    }

                }

            }

        }

  

        #endregion

    }

}

Special thanks are in order to Oleg Sych for his fundamental tips to get this working.

Posted 16 December 08 04:22 by hgr | 1 Comments
Filed under Software Factories, DSL

Agile Prototyping

One of these days I went for a periodic review meeting of the project I'm working on. We were going to discuss the implementation of a critical piece for our next major milestone.

We invited our User Experience Specialist and he was going to present us the first UI prototypes.

I was expecting some great WPF "almost-ready" screens with great user experience stuff and a wonderful look-and-feel like all the other prototypes they did before...

This was what I got to see:

Now talk about agile prototyping. :)

Posted 11 December 08 11:28 by hgr | 1 Comments
Filed under User Experience

DSL Tools #13 - Changing the Appearance of a Shape at Runtime

Finally I found some time to document this simple customization to the DSL Tools designers.

The requirement is as follows:

I have a given domain class - called Module Reference - that has a property called Main.
This domain property indicates if that particular class is the "most important" of that kind in the model.
This domain class as an association with another domain class - called Entity. That association allows me to connect multiple entities to any given module reference.
All the entities connected to the main module reference need to presented with a different color (different from the default shape color defined in the DSL definition model).

The domain model is the following:

Achieving this is quite simple:

1. Create a change rule to respond to the change in the Main property of the ModuleReference domain class:

        1: using System;

       2: using Microsoft.VisualStudio.Modeling;

       3: using Microsoft.VisualStudio.Modeling.Diagrams;

       4:  

       5: namespace MyModel

       6: {

       7:     /// <summary>

       8:     /// Defines a change rule for the ModuleReference domain class.

       9:     /// </summary>

    [RuleOn(typeof(Primavera.Athena.Models.Reporting.ModuleReference), FireTime = TimeToFire.TopLevelCommit)]

    public class ModuleReferenceChangeRule : ChangeRule

    {

        #region Public Methods

  

        /// <summary>

        /// Alerts listeners that a property for an element has changed.

        /// </summary>

        /// <param name="e">Provides data for the ElementPropertyChanged event.</param>

        public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e)

        {

            // Validations

  

            if (e == null)

            {

                throw new ArgumentNullException("e");

            }

  

            if (e.DomainProperty.Id.Equals(ModuleReference.MainDomainPropertyId))

            {

                HandleMainChanged(e);

            }

  

            // Default behavior

  

            base.ElementPropertyChanged(e);

        }

        

        #endregion

  

        #region Private Methods

  

        /// <summary>

        /// Handles changes in Main.

        /// </summary>

        /// <param name="e">The <see cref="Microsoft.VisualStudio.Modeling.ElementPropertyChangedEventArgs"/> instance containing the event data.</param>

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")]

        private void HandleMainChanged(ElementPropertyChangedEventArgs e)

        {

            // Something changed?

  

            if (!e.OldValue.Equals(e.NewValue))

            {

                // Get the current shape

  

                ModuleReference moduleReference = e.ModelElement as ModuleReference;

                if (moduleReference != null)

                {

                    // Update all entities colors

  

                    foreach (Entity entity in moduleReference.Entities)

                    {

                        LinkedElementCollection<PresentationElement> presentations =

                            PresentationViewsSubject.GetPresentation(entity);

                        EntityShape entityShape = null;

  

                        if (presentations.Count > 0)

                        {

                            entityShape = presentations[0] as EntityShape;

                        }

  

                        if (entityShape != null)

                        {

                            entityShape.UpdateMainModuleReferencePresentation((bool)e.NewValue);

                        }

                    }

                }

            }

        }

  

        #endregion

    }

}

Note: I first find all the EntityShape instances that are connected with the current ModuleReference and then call the UpdateMainModuleReferencePresentation passing in the new value of the Main property.

2. Register this change rule:

       1: using System;

       2:  

       3: namespace MyModel

       4: {

       5:     /// <summary>

       6:     /// Custom ReportingModel domain model methods.

       7:     /// </summary>

       8:     public partial class ReportingModelDomainModel

       9:     {

      10:         #region Protected Methods

      11:  

      12:         /// <summary>

      13:         /// Returns the non-generated domain model types.

      14:         /// </summary>

      15:         /// <returns>An array of types.</returns>

      16:         protected override Type[] GetCustomDomainModelTypes()

      17:         {

      18:             // Return the rules that should be evaluated for

      19:             // the model

      20:  

      21:             return new System.Type[] 

      22:             {

      23:                 typeof(AssociationConnectorChangeRule), typeof(GenerateDefaultListChangeRule), typeof(ModuleReferenceChangeRule)

      24:             };

      25:         }

      26:  

      27:         #endregion

      28:     }

      29: }

3. Create a new partial class for the EntityShape class and implement the UpdateMainModuleReferencePresentation method:

       1: using System;

       2: using System.Drawing;

       3: using Microsoft.VisualStudio.Modeling.Diagrams;

       4:  

       5: namespace MyModel

       6: {

       7:     /// <summary>

       8:     /// Provides custom code for the EntityShape domain class.

       9:     /// </summary>

    public partial class EntityShape

    {

        #region Internal Methods

  

        /// <summary>

        /// Updates the entity presentation to reflect if the corresponding module reference is the main.

        /// </summary>

        /// <param name="moduleRefereceIsMain">A boolean that indicates if the entity is associated with the main module.</param>

        internal void UpdateMainModuleReferencePresentation(bool moduleRefereceIsMain)

        {

            StyleSet style = this.StyleSet;

            BrushSettings brush = style.GetOverriddenBrushSettings(DiagramBrushes.ShapeBackground);

            if (brush == null)

            {

                brush = new BrushSettings();

            }

  

            if (moduleRefereceIsMain)

            {

                brush.Color = Color.FromKnownColor(KnownColor.CadetBlue);

            }

            else

            {

                brush.Color = Color.FromKnownColor(KnownColor.Lavender);

            }

  

            style.OverrideBrush(DiagramBrushes.ShapeBackground, brush);

        }

  

        #endregion

    }

}

That's it.

Posted 30 October 08 05:43 by hgr | 2 Comments
Filed under Software Factories, DSL

Hugo Ribeiro

Search

This Blog

Tags

Navigation

Archives

Blogs@PRIMAVERA

Blogs@PT

Pages

Syndication