Nueva Southworks.SDC Task con p&p Documentation Tools

Tiempo atrás posteaba acerca de p&p Documentation Tools. Las herramientas de patterns & practices para ayudar a los technical writers a generar documentación para MSDN o en formato CHM utilizando documentos escritos con Microsoft Word 2007.

Hoy les presento una nueva task para las Southworks.SDC.Tasks, que fue creada utilizando los assemblies de p&p Documentation Tools y así integrar al proceso de Continuous Integration, la conversión de docx a CHM.

PrepareToCHM task

Esta nueva task para las Southworks.SDC.Tasks, es la encargada de convertir los docxs a html y generar los archivos necesarios para la compilación a CHM.

Recibe como parámetros, el MasterToc generado con la MasterToc tool y el directorio de salida para los archivos html y los necesarios para compilar a CHM, que se van a generar. También puede recibir los archivos de configuración para la conversión a html.

/// <summary>
/// The TOC of the chm file.
/// </summary>
[Required]
public ITaskItem MasterToc { get; set; }

/// <summary>
/// The path of the configuration file for the html pages.
/// </summary>        
public ITaskItem HtmlConfigurationFile { get; set; }

/// <summary>
/// The path of the configuration file for the chm.
/// </summary>        
public ITaskItem ChmConfigurationFile { get; set; }

/// <summary>
/// The output path for the chm file will be generate.
/// </summary>
[Required]
public ITaskItem ChmOutput { get; set; }

Luego, utilizando los assemblies de p&p Documentation Tools generamos los htmls:

/// <summary>
/// Executes the task.
/// </summary>
/// <returns>A value indicating whether the execution was successful or not.</returns>        
public override bool Execute()
{
    try
    {
        XmlDocument masterToc = new XmlDocument();
        masterToc.Load(this.MasterToc.ItemSpec);

        this.PrepareConfigFiles();
        this.PrepareDirectories();

        XslCompiledTransform tranform = new XslCompiledTransform();
        XsltArgumentList arguments = new XsltArgumentList();
        arguments.AddParam(“configFile”, String.Empty, Path.GetFullPath(this.HtmlConfigurationFile.ItemSpec));

        foreach (XmlNode item in masterToc.ChildNodes[1].ChildNodes[0].ChildNodes)
        {
            XmlDocument mainDocument = OpenXmlHelper.DeleteCommentsAndAcceptRevisions(item.InnerText, String.Empty);
            IReferenceResolver resolver = new OpenXmlReferenceResolver(item.InnerText, “..\\html\\images”, String.Concat(this.ChmOutput.ItemSpec, “\\html”, “\\images”), “.png”);
            DocumentConverterEngine converterEngine = new DocumentConverterEngine(mainDocument, resolver, “..\\tools\\DocxConverter\\Microsoft.Practices.DocxConverter.dll.config”);

            IDictionary<string, XmlDocument> converted = converterEngine.SplitAndConvert();

            foreach (KeyValuePair<string, XmlDocument> pair in converted)
            {
                tranform.Load(“..\\tools\\DocxConverter\\xsl\\Domain.xsl”, XsltSettings.TrustedXslt, new XmlUrlResolver());
                StreamWriter writer = new StreamWriter(String.Concat(this.ChmOutput.ItemSpec, “\\html\\”, pair.Key, “.html“));
                tranform.Transform(new XmlNodeReader(pair.Value.DocumentElement), arguments, writer);
            }
        }

        this.GenerateChmProjectFile(”HtmlHelp1Toc.xsl“, “Toc.hhc“, this.ChmConfigurationFile.ItemSpec);
        this.GenerateChmProjectFile(”HtmlHelp1Hhp.xsl“, “Project.hhp“, this.ChmConfigurationFile.ItemSpec);

        this.Logger(”true“, String.Empty);

        return true;
    }
    catch (Exception ex)
    {
        this.Logger(”false“, ex.Message);
        return false;
    }
}

Ustedes pueden encontrar el código completo en: http://code.google.com/p/sdctasks/

CompileCHM task

Pero no todo acaba aquí, una vez que tenemos los htmls y los archivos necesarios para compilar a CHM, tenemos que utilizar el compilador de CHM que nos provee el HTML Help Workshop. Para esto contamos con esta task que recibe como parámetros el directorio donde se encuentran los archivos htmls y los necesarios para compilar a CHM, y el compilador CHM.

/// <summary>
/// The path for the chm project file generated.
/// </summary>
[Required]
public ITaskItem ChmOutput { get; set; }

/// <summary>
/// The chm compiler.
/// </summary>
[Required]
public ITaskItem ChmCompiler { get; set; }

Con estos parámetros, abre un proceso para generar el CHM, utilizando el compilador:

/// <summary>
/// Executes the task.
/// </summary>
/// <returns>A value indicating whether the execution was successful or not.</returns>
public override bool Execute()
{
    try
    {
        if (!this.ChmCompiler.ItemSpec.EndsWith(“hhc.exe”))
            this.Logger(“false”, “The Chm compiler is incorrect”);

        new Process { StartInfo = new ProcessStartInfo(this.ChmCompiler.ItemSpec, String.Concat(this.ChmOutput.ItemSpec, “Project.hhp”)) } .Start();

        this.Logger(“true”, “”);
        return true;
    }
    catch (Exception ex)
    {
        this.Logger(“false”, ex.Message);
        return false;
    }
}

Ustedes pueden encontrar el código completo en: http://code.google.com/p/sdctasks/

Conclusión

Tenemos estas dos nuevas tasks con las que podemos convertir de docx a CHM, en el proceso de Continuous Integration.

Requisitos
Código Fuente
Mas Información

Southworks Tasks en Google Code

Es un placer anunciar nuestro primer proyecto Open Source en Google Code: http://code.google.com/p/sdctasks/.

 

Las Southworks SDC Tasks son tareas para MSBuild y fueron creadas pasa hacer la vida de nuestro equipo de desarrollo, mas facil. Estas se pueden usar como parte del proceso de Build o como referencia para crear nuevas tareas.

Actualmente contamos con 8 tasks: Agregar copyright header a los archivos, Correr MSTests, Generar reportes de Code Coverage de los MSTests, Correr Source Analysis, Actualizar la informacion de los assemblies, Remover archivos duplicados, Generar paquetes SFX y Abilitar el Web Application Code Coverage para los MSTests.

El release actual es el Codigo fuente de las tasks. Muy pronto, entregaremos un instalador.

Pueden ver el anuncio en ingles en el blog de Johnny Halife.

Gracias!

patterns & practices Documentation Tools on CodePlex

Después de un largo y gran trabajo realizado en conjunto con Ed Rossetto, Eze Bella, Gabriel Szlechtman, Marce Rodriguez y bajo la tutela del Gran Mawolo.

Es un placer anunciar que las Documentation Tools (a.k.a Lebon) ya están disponibles en CodePlex!

Vision

Disrfutenlas!

Ribbon UI - Usando imágenes personalizadas

Todos los que han desarrollado add-ins para Word saben que pueden agregar botones y demás componentes a la ribbon que están desarrollando y asignarle una imagen prediseñada, utilizando uno de los atributos que poseen los componentes, este atributo es imageMso en donde especificamos el nombre de la imagen que posee el paquete Office que queremos utilizar.

ribbon_code

Pero! ¿Cómo hacer si queremos utilizar nuestras propias imágenes? En esta oportunidad vamos a ver como utilizar imágenes personalizadas en los botones del add-in que ustedes pueden desarrollar.

Implementando

Lo primero que debemos hacer es setear uno de los atributos de la customUI, loadImage. Esta define el callback que se utiliza para cargar nuestras imágenes personalizadas. En este ejemplo vamos a asignarle al atributo loadImage el valor GetImage, que será el método encargado de cargar nuestras imágenes personalizadas.

<customUI xmlns=”http:”//schemas.microsoft.com/office/2006/01/customui” onLoad=”OnLoad” loadImage=”GetImage”>

El esqueleto de este callback es el siguiente:

public object loadImage(string imageId)

Ahora, una vez que hemos seteado el atributo loadImage y conocemos el esqueleto del callback, pasamos a implementar nuestro método GetImage para empezar a utilizar nuestras imágenes personalizadas.

Primero debemos agregar la referencia a System.Drawing en nuestro proyecto.

using System.Drawing;

Y luego implementamos la funcionalidad:

public Bitmap GetImage(string imageName) { Assembly assembly = Assembly.GetExecutingAssembly(); string[] resourceNames = assembly.GetManifestResourceNames(); Stream stream = assembly.GetManifestResourceStream (CustomImagesSample.Images. + imageName); return new Bitmap(stream); }

Este método lo que hace es leer de nuestro assembly la imagen embebida, instancia un bitmap y lo devuelve.

El método se puede implementar de distintas maneras para leer nuestra imagen personalizada, lo mas importante es setear el atributo loadImage y seguir el esqueleto del callback.

Nota: Para este ejemplo, asumimos que tenemos una carpeta Images en nuestro proyecto y que las imágenes fueron agregadas como recursos embebidos.

solution

Una vez que implementamos nuestro metodo GetImage remplazamos el atributo imageMso por el atributo image al cual le asignamos el nombre de nuestra imagen, tal como se ve en el código:

<toggleButton id=”toggleButton1″
                        size=”large”
                        label=”My Button”
                        screentip=”My Button Screentip”
                        onAction=”OnToggleButton1″
                        image=”custom.jpg” />

Ahora cuando corramos nuestra aplicación, en la ribbon aparecerá el botón con nuestra imagen personalizada:

result

Espero que este post les sea de utilidad, aquí les dejo el código.

Saludos!

SaaS HOLs publicados

Semanas atras, estuvimos trabajando con Mati Woloski, Eze Bella y Gustavito Azcona, desarrollando los Hands On Labs para SaaS (Software As A Service) que Mati presento en un Workshop.

Ahora, estos Hands On Labs estan disponibles para que ustedes se los descarguen, desde el blog de Fred Chong.

Disfrutenlos!!! :)

Mas info, acerca de SaaS.

Posted in Uncategorized. Tags: . No Comments »