ICode

First Web Application ever

redb@student-partners.com — Fri, 05 Mar 2010 01:33:50 +0000

I’m not a web guy, (at all) but some day even I had to build a Web Application.

That day was today.

The first thing you’ll notice if you have cable tv and live in Portugal is that the logo resembles a lot like the one in FoxLife. (What the hell?) That was just a coincidence. Belive me.

So what’s the site about?

Its all about realtors that want to sell properties and buyers, the exact same thing that REMAX does.

It’s main features are:

Url Routing.
Multi-Language, (English, Portuguese, Chinese, etc.)
Multi-Culture, (Automatic Currency Convertion and Parsing, same for areas, etc.)
Can load/change/create new Languages/Cultures on the fly, without the need to recompile or restart the application through a custom XML file.
Custom System Cache, (you can cache your application from within without the need to configure IIS, and this includes any SQL Server database access you do or even single controls)
Custom generated pictures, (this includes, banners, resources, compression, etc.)

If you check the previous picture you’ll notice they are the same, the first is in English and the second is in Portuguese, (Take a look at the prices and areas, they are relative to a specific culture).
There’s also a lot of AJAX going on.
A custom built jQuery carrousel.
A Bing map editor, (including drawing).
Comments.
Login.
You can insert YouTube videos.
All errors, (even regular 404), are logged into the database.
Quick Search.

For those of you more interesed in the technical details, such as caching:

You can take a look at the source code here:

File Attachment:

DAW.zip

Or you can check these videos.

File Attachment:

Products.wmv

File Attachment:

Manage.wmv

File Attachment:

Presentation.wmv

Cheers.

Serve Dynamic Javascript using Generic Handlers

redb@student-partners.com — Sun, 10 Jan 2010 22:04:53 +0000

Actually I want to serve other dynamic files too, such as Css for instance.

How in hell am I gonna do that without embedding that dreadful code in Asp.Net pages?

I’m glad you ask.

If you’re anything like me you’ll want to keep your Css/Javascript files apart from your Html and serve them separately, (maybe even offload them to another server).

First things first.

You’ll need to be able to compile Asp.Net pages on the fly, if you want you can take a look at this post. (It explains how to Programatically Render/Load an Asp.Net Page in more detail)

Then you’ll a need a Generic Handler.

Let’s go ahead an create one:

public class DynamicFile : IHttpHandler
{
      public void ProcessRequest(HttpContext context)
      {
            ProcessJScriptRequest("~/Scripts/JS.aspx");
      }

      public bool IsReusable
      {
            get { return true; }
      }
}

You’ll need one of these Handlers for each dynamic file you have.

As you can see this section is pretty easy to follow.

Next ProcessJScriptRequest() handles all that pluming involved in serving a Javascript file.

public static void ProcessJScriptRequest(string path)
{
            try
            {
                var page = ((BasePage)(BuildManager.CreateInstanceFromVirtualPath(path, typeof(Page))));
                var sb = new StringBuilder();
                var tw = new HtmlTextWriter(new StringWriter(sb));

                page.Server.Execute(path, tw, true);
                page.RenderControl(tw);

                tw.Flush();
                
                HttpContext.Current.Response.ContentType = "application/x-javascript";
                HttpContext.Current.Response.Write(sb.ToString());
            }
            catch (Exception ex)
            {
                //Logger.Add(new PageException(HttpContext.Current, ex), ExceptionLevel.High);
            }
}

If you’ve read my previous blog post then there isn’t anything specially interesting going on here.

By now you may be wondering...

If we’re just compiling Asp.Net pages on the fly what about Javascript/CSS intellisense, can we have it? (If they are aspx files)

Yes...

But you’ll need a hack.

Let’s take a look at you dynamic file being requested by the generic handler:

<%@ Page   Language="C#" ... %>
<%@ Import Namespace="System.Linq"%>
<%@ Import Namespace="System.Xml"%>
<%@ Import Namespace="System.Xml.Linq"%>
<%@ Import Namespace="System.IO"%>

<!--//

<% var empty = string.Empty; %>

function isNull(s) {
	return (s == undefined || o == null);
}

//-->

This alone won’t provide any intellisense you must surround you’re code with the <script type=”text/javascript”> tag.

Once you’ve done it you can remove it from the release version.

To call your dynamic Javascript file you only need to do something like this:

<script
    language="javascript"
    type="text/javascript"
    src_="Scripts/DynamicFile.ashx?YourQueryString=IfYouWant"
></script>

Et voila!!!

Programatically Render/Load an Asp.Net Page

redb@student-partners.com — Sun, 10 Jan 2010 21:59:03 +0000

How to programatically render or load an Asp.Net page/control?

First of all why would you wanna render/load your own pages/controls instead of letting Asp.Net do it?

Well you might wanna cache the results of that request and build your own custom cache system for example.

If you want you can choose to cache selectively.
You can use it for routing, (Asp.Net MVC uses the technique described here).
You can use it for UnitTesting, (by calling pages with arguments as you do for your methods, although it won’t be very clean).
Or better yet you can use this technique to serve dynamic javascript or css files, (or any type of file for that matter).

The main core is the method BuildManager.CreateInstanceFromVirtualPath(...).

Basically what this method does is to “render”, (I’m using quotes because simply calling this method won’t render a thing), an Asp.Net page into a specific HtmlTextWriter.

After that you’ll need to provide the server context in which the page will be compiled by calling: Server.Execute(...).

Now, depending how you created a new instance of HtmlTextWriter you’ll have access to a StringBuilder object that captures the page output based in the specified server context.

Here’s the code:

StringBuilder  sb = new StringBuilder();
StringWriter   sw = new StringWriter(sb);
HtmlTextWriter tw = new HtmlTextWriter(sw);

var path = HttpContext.Current.Request.Url.ToString();
var page = ((Page)(BuildManager.CreateInstanceFromVirtualPath(path, typeof(Page))));

HttpContext.Current.Server.Execute(page, tw, true);

tw.Flush();
sw.Flush();
return sb.ToString();

What about serving dynamic files with this technique?

Well that’s the next post.

C# Sudoku Solver, (WPF)

redb@student-partners.com — Thu, 23 Jul 2009 12:55:40 +0000

I’m not a Sudoku type of person, actually this is probably one of the puzzles that I most hate to solve manually.

Too many variables, Sudoku is one of those problems that is perfect to be crunched by computers.

And since I’m a computer guy…

There are several techniques to solve a puzzle either by logic or using brute force, I’m not going to discuss neither since you can already find lots of good documentation all over the internet, (I used “resources” from here).

The techniques that I’m using are:

Single Position, (link).
Single Candidate, (link).
Candidate Line, (link).
Brute Force.

These techniques are more than sufficient to solve any puzzle, (I hope )

Techniques not used:

Double Pair, (link).
Multi-Line, (link).
Naked Pairs/Triples, (link).
Hidden Pairs/Triples, (link).
X-Wing, (link).
Swordfish, (link).
Forcing Chains, (link).

I’m not going to bore anyone with the implementation details, I will just leave the source code in C#:

File Attachment:

Sudoku%20C%7C3%20WPF...

The zip file contains:

A Library,
A Command Prompt Demo,
Unit Testing, (NUnit),
A rather slow WPF implementation.

Since I’m not a designer a used pictures from deviantart.com to build the WPF application, the designers that I borrowed art from are:

~Ginnyhaha-Stock, (link).
~Divinity-bliss, (link).
=aR-Ka, (link).

Please note that due to time constraints the WPF app is just a front-end with lot’s of functionality still to implement.

Cheers.

Project Cambridge (CLR Mapper + Linq Provider) Part I

redb@student-partners.com — Sat, 18 Jul 2009 06:40:08 +0000

For those who follow my blog, (if I don’t count with my mom I believe I have exactly one follower), I’ll start posting in English.

Why? Well I think that English is a much more natural language when dealing with technical terms, and yes, I can reach a much broader audience, (shame on you).

Anyway…

This will be the first in a serious of ongoing posts how to build a CLR, (Common Language Runtime), Mapper + Custom Linq Provider.

First things first, what is a CLR Mapper?

Figure 1

Well instead of designing your data in the database and then mapping it back into Visual Studio. You design your data model directly in a DotNet Language, e.g C#, and than we map it, either to SQL Server 2008, SQL Server 2005, MySQL, XML, JSON, etc…

Quite like NHibernate but without all those dreadful configuration files scattered all over the place, data manipulation and modern programming languages have been diverging for too long.

That way we can keep all of those nice features that C# provides us but that are really hard to implement in SQL Server, (Object Orientation being the single most important feature), map IEnumerable data, map Enums, etc.

If we take a look at figure 1 we’ll see that we have a class Client that derives from User that derives from Person.

Not only that but a Client has a list of Orders each one containing a list of Products.

Finally we have two enums: Country and ProductCategory.

How are we going to map this? (Remember this is just a proof of concept from a guy that understands squat about SQL Server)

We take each class that we want to map, (Person, User, Client, Country, ProductCategory, Order, Product), and adorn it with a TableAttribute, furthermore we gather these classes under a DataProvider class and feed it to our CLRMapper.

namespace Cambridge
{
    public abstract class DataProvider
    {
        public      string       Name    { get; private set; }
        protected   IList<Table> Tables  { get; private set; }

        protected DataProvider(Type t)
        {
            CLRMapper mapper = new CLRMapper(t);
            this.Name = mapper.Name;
            this.Tables = mapper.Tables;
        }
    }
}

The CLRMapper “converts” by reflection all classes adorned with TableAttribute into Table classes, each Table instance contains a collection of Column objects.

With this information at hand we create a new class, (SQLDataProvider), that derives from DataProvider.

Now the only thing left to do is to transverse the tables and create the corresponding table definition.

public sealed class SQLDataProvider : DataProvider
{
    public SQLDataProvider(Type t) : base(t)
    { }

    // Map Tables
    private string MapTable(Table t)
    {
        const string DbOwner = "dbo";
        const int Identation = 1;

        StringBuilder sb = new StringBuilder();

        sb.AppendFormat("Create Table [{0}].[{1}].[{2}]{3}(",
            base.Name, DbOwner, t.Name, Environment.NewLine
        );

        foreach (var item in t.Columns)
        {
            sb.Append(MapColumn(item, Identation, DbOwner));
        }

        sb.Append(");");

        return sb.ToString();
    }

    // Map Columns
    private string MapColumn(Column c, int identation, string owner)
    {
        string dataType = GetSQLDataType(c);
        string nullable = c.AllowNulls ? string.Empty : "Not Null";
        string isUnique = c.IsUnique == false ? string.Empty : "Unique";

        // Todo: Remove
        string CNS = new string(' ', 20 - c.Name.Length);
        string DTS = new string(' ', 15 - dataType.Length);
        string ISN = new string(' ', 10 - nullable.Length);
        string IDT = new string('\t', identation);

        if (c.IsPrimaryKey && c.Base != null)
        {
            // This type inherits from another mapeable type.
            return string.Format(
                "{0}[{1}]{2}{3}{4}{5}{6}Primary Key Identity(1,1)" +
                " References [{7}].[{8}].[{9}]([__PK]),{10}",
                IDT, c.Name, CNS, dataType, DTS, nullable, ISN,
                base.Name, owner, c.Base.Name, Environment.NewLine
            );
        }
        if (c.IsPrimaryKey)
        {
            return string.Format("{0}[{1}]{2}{3}{4}{5}{6}Primary Key Identity(1,1),{7}",
                IDT, c.Name, CNS, dataType, DTS, nullable, ISN, Environment.NewLine
            );
        }

        return string.Format(
                "{0}[{1}]{2}{3}{4}{5}{6}{7}{8},{9}",
                IDT, c.Name, CNS, dataType, DTS, nullable, ISN,
                isUnique, DefaultSqlCheck(c.Name, c.DataType), Environment.NewLine
            );
        }

    }
    
}

This will output the following SQL:

Although far from complete the generated SQL represents our data model indeed.

It is really easy to derive from DataProvider and create an implementation that spits XML, XOML, XAML; JSON, or any other DSL (Domain Specific Language).

In the next post I’ll try to create a Custom Linq Provider, (a very simple one) to query the data model.

(Yacks!!! That’s not gone be easy)

Multi-Wallpaper Manager (Version 0.1)

redb@student-partners.com — Mon, 29 Jun 2009 20:07:06 +0000

Este deve ser sem qualquer sombra de dúvida o pior código que já escrevi este ano.

Sabem aquela “coisa” que o Windows tem para mudar o wallpaper? (Sim! Essa coisa horrorosa!!!)

Que nem sequer dá para escolher os wallpapers individualmente.

Por exemplo, quem tem mais de um monitor talvez gostasse de ter um wallpaper diferente em cada monitor, melhor ainda se cada ecrã tivesse as suas “settings”, Tile, Stretch, Center, etc.

Isso é que era fixe!

Existem algumas aplicações no mercado, mas ao que parece nenhuma suporta mais de três monitores em simultâneo, embora isso possa ser um defeito das minhas “google skills”.

De qualquer forma eu tenho uma certa aversão a pagar por software, (Ricardo!!! Chama-se a isso ser português)

Assim sendo, e dando origem a algum do meu melhor “código pedreiro”, apresento-vos o “Wallpaper Manager”.

Sim… Eu sei…

Eu e a minha enorme imaginação para nomes.

Então o que é que eu posso fazer com isto???

Encher o teu desktop de imagens “rafeiras” que vão por os teus pais com os cabelos em pé!!!

Não vos quero assustar, mas lembrem-se que este software, foi feito tão à pressa que cada linha de código tem 32 bugs ou mais.

Microsoft Web & Gaming 2009 - Videos

redb@student-partners.com — Sun, 28 Jun 2009 07:06:03 +0000

Demorou mas foi.

Nunca me passou pela cabeça que a edição de video fosse tão pesada.

Houve videos que demoraram quase 6 horas a serem editados. (Yacks!!! Kill me now!!!)

O pobre computador quase que fritava com o calor gerado, (ainda para mais nestes dias quentes de Verão).

Anyway…

Nada disso importa porque os videos já estão aí e podem dar-lhes uma vista de olhos aqui.

Alguns videos, (se não mesmo a maioria), encontram-se imcompletos ou com pequenos cortes ou então começam practicamente a meio.

Isto deve-se ao facto de cada DVD suportar aproximadamente 30 min de video, mas cada sessão tem mais ou menos 1 hora, isto aliado ao facto de um dos DVDs ter ido “à vida” originou o resultado final que podem ver.

Cumprimentos pessoal.

Microsoft Student Partner 2010 - UAlg

redb@student-partners.com — Wed, 24 Jun 2009 03:25:56 +0000

Olá rapaziada e "raparigada".

Mais uma vez más noticias.

Voltei a falhar na minha demanda para me tornar Miss Cabelo Pantene 2009, (não desistirei assim tão facilmente).

Mas em compensação irei ser, (pelo segundo ano consecutivo), Microsoft Student Partner pela Universidade do Algarve.

No primeiro ano em que ingressei no programa e me falaram sobre o que é ser um MSP, (Microsoft Student Partner), confesso que fiquei um pouco céptico especialmente sobre aquela "parte" do crescimento pessoal e social...

Não podia estar mais enganado.

Agora, após um ano, posso sem qualquer sombra de dúvida dizer que um dos maiores beneficios deste programa é definitivamente o crescimento pessoal e social.

No ano anterior encontrava-me um pouco "receoso", afinal de contas não sabia bem ao que vinha, este ano o sentimento não podia ser o mais possivel o oposto desse.

Estou completamente "fired-up" para que o programa comece, para pôr as minhas ideias em práctica, para conhecer os novos MPS, rever os "antigos".

I can't wait

Um abraço a todos, muito obrigado por me terem dado a oportunidade de continuar mais um ano no programa.

Closest Pair Of Points in a 2D Plane

redb@student-partners.com — Fri, 19 Jun 2009 08:23:39 +0000

Ora aqui está um problema que me ia tirando a vontade de viver.

Podem encontrar mais informação sobre este problema aqui, aqui, aqui e aqui.

Na sua essência o "Closest Pair Of Points in a 2D Plane" é um algoritmo que procura o par de pontos com a menor distância entre si num plano em 2D.

E a maneira de o resolver não podia ser mais simples, "basta" usar força bruta.

O problema desta abordagem é a sua complexidade temporal.

Que no minimo se pode considerar como péssima.

Existem dois excelentes algoritmos que podem ser usados, um de divisão e conquista e outro denominado Plane Sweep.

Este último encontrei uma descrição num livro da Wrox, (Begining Algorithms).

Infelizmente não tenho muito tempo para descrever pormenorizadamente cada um dos 3 algoritmos.

Em compensação deixo-vos um Pdf que fiz que descreve com algum detalhe cada um dos algoritmos, respectivo código, (versão Java), performance e complexidade:

File Attachment:
Report4.pdf
(421,0029 kB)

E aqui, (como vem sendo habitual), deixo o código fonte:

File Attachment:

ClosestPair%20Java.z...

File Attachment:

ClosestPair%20C%7C3....

"Aurevoir"

The Knapsack Problem

redb@student-partners.com — Mon, 15 Jun 2009 14:54:52 +0000

Olá novamente.

Para aqueles que não conhecem o Knapsack Problem deixo aqui um link da wikipedia.

De um modo muito resumido o Knapsack problem ou Rucksack problem é um problema de optimização combinatorial.

O objectivo é "enfiar" na nossa mala a maior quantidade de objectos possivel, maximizando sempre o lucro e nunca a quantidade de objectos.

Ou seja, se fossemos ladrões iriamos tentar levar a maior quantidade possivel de objectos que nos dessem o maior lucro possivel, tendo sempre em conta que cada objecto tem um valor e peso pré-definidos, a nossa mala tem capacidade finita em termos de peso.

Existem várias maneiras de resolver o problema, este post vai explorar 3 vias diferentes.

A primeira via, (a mais simples), e também a mais ineficiente em termos computacionais é a abordagem naïve.

Ou seja, vamos gerar todas as hipóteses possiveis, (aka Combinações), seguidamente corremos todas as hipóteses geradas anteriormente e das que cabem dentro do saco, (ou seja, não excedem o limite de peso imposto), verificamos qual a que contém o contéudo mais valioso.

É quase como determinar o Max/Min de uma lista de números, mas um "bocadinho" de nada mais complexo.

Este algoritmo na melhor das hipóteses pode ser usado como referência para Unit Testing.

A segunda via é um bocadinho mais inteligente.

A abordagem é a seguinte: Um objecto tem duas hipóteses ou se encontra na solução óptima ou não se encontra na solução óptima.

Com base nesta premissa podemos usar divisão e conquista, dividimos o problema em vários sub problemas óptimos.

Em português sff.

Ok.

Se olharmos para a figura seguinte temos inicialmente os objectos {A, B, C, D, E}, como é tipico na abordagem de divisão e conquista vamos subdividir o problema, (neste caso 2 sub-problemas), uma das ramificações considera que o objecto "E" pertence a uma solução óptima, a outra ramificação considera que o objecto "E" não faz parte de uma solução óptima.

O problema vai sendo constanemente "ramificado" até que chegamos aos casos base, {A}, sempre que estamos a ramificar a árvore e esta ultrapassar a capacidade da mochila, a ramificação é interrompida/descartada.

A grande vantagem desta abordagem é que tem uma menor complexidade que a primeira via.

Finalmente a terceira via usa exactamente a mesma técnica da segunda, mas "memoriza" os resultados.

Esta técnica é denominada de Programação Dinâmica, como se pode ver pela figura anterior existem imenso cálculos repetidos vezes sem conta, quando isto acontece, o emprego de divisão e conquista tem muitas poucas vantagens.

Nestes casos devemos complementar o problema com Programação Dinâmica, que no fundo é um nome muito fino para: "Memoriza todas as chamadas que já fizeste para não teres que as fazer novamente".

Típicamente é usada uma matriz bi-dimensional para guardar os resultados, mas como o autor deste post é muito "fino" e forreta em termos de memória, vamos usar um dicionário de chave dupla.

O Código fonte encontra-se disponivel em dois "sabores" C# e Java.

File Attachment:

Knapsack%20C%7C3.zip

File Attachment:

Knapsack%20Java.zip

Microsoft Web & Gaming 2009 - Photos

redb@student-partners.com — Fri, 12 Jun 2009 18:41:27 +0000

Já se encontram online as fotos do evento que decorreu nos dias 9 e 10 de Maio de 2009 na universidade do Algarve.

Um grande abraço ao João Antão por ter ajudado com as fotos e a todos os participantes que tornaram este evento possivel, (com sorte pode ser que se venha a repetir para o ano).

Para acederem às fotos: dirijam-se a este site.

Assim que pudermos iremos disponibilizar os videos.

(x64 + Java) Disassembler Library in C#

redb@student-partners.com — Thu, 04 Jun 2009 21:58:32 +0000

Olá novamente.

Este post é a continuação deste aqui.

Apesar de me encontrar com muito pouco tempo e com os trabalhos acumularem-se não consegui resistir a adicionar suporte para Java.

Como podem ver pela imagem ainda existe imensa coisa por fazer, (leia-se: tudo)

É mais o que se encontra por fazer do que aquilo que está feito.

(Estas coisas são tão giras de se fazer)

Ignorando este momento idiota.

Se estiverem interessados em compreender o formato *.class a minha principal recomendação é este site.

Se o vosso interesse forem somente os opcodes então este é o vosso site.

Ambos os sites são mantidos pela Sun, ou seja é a especificação oficial.

Ou então, melhor ainda, podem usar o livro:

O download do 1º livro pode ser feito aqui. (Pena que não exista uma versão em Pdf.)

O segundo livro nunca o vi, mas o preço é brutalmente aliciante, $1,99!!!! Uau!!!! Acho que vou encomendar um para mim!

(Nem que seja para matar a curiosidade)

x64 Disassembler Library in C#

redb@student-partners.com — Mon, 01 Jun 2009 15:42:26 +0000

Finalmente!!!

Há imenso tempo que queria escrever uma biblioteca para fazer “disassembling” de unmanaged code x64, mas o tempo era sempre escasso.

Decidi aproveitar esta semana de férias para fazer isso mesmo, dar os primeiros passos neste mundo assustador, (Unmanaged Code).

A primeira coisa a fazer é localizar o código dentro de um ficheiro executável; em Windows um *.exe típico (PECOFF), contém uma secção denominada “.text”.

Com base nessa secção, VirtualSize informa sobre a quantidade de bytes que o código ocupa e VirtualAddress indica a sua localização.

Com essa informação extraímos os bytes que sabemos serem código executável.

Depois para efecuar o “parse” recomendo vivamente irem ao site da Intel, da AMD e aqui.

Especialmente estes dois manuais da Intel.

Se lerem os manuais atentamente verão que não é muito dificil, (têm é que ler bem).

Ainda falta escrever muitissimo código, (como pode ver pelas images).

Seria muito giro agarrar neste código e transformá-lo, (quando possivel), em Managed Code, (seja ele Java bytecode ou MSIL)

Microsoft Web & Gaming 2009

redb@student-partners.com — Thu, 30 Apr 2009 22:23:44 +0000

O grupo de Microsoft Student Partners da UAlg deseja convidar todos os interessados em novas tecnologias a participarem no nosso próximo evento:

A entrada é completamente livre de quaisquer encargos e não existe necessidade de pré-reserva, o evento terá lugar nos dias 9 e 10 de Maio, (Sexta e Sábado), no Anfiteatro B do Complexo Pedagógico, (aquele que fica no primeiro andar)

Vamos ter revistas PCGuia para distribuir, (revista + DVD).

Sorteio de livros Microsoft Press e outras surpresas.

Terás também a possibilidade de privar directamente com os oradores.

O registo no evento não é obrigatório, embora gostássemos de saber a tua opinião de modo a podermos melhorar de ano para ano.

Para te registares, (caso o desejes fazer), podes dirigir-te:

http://wg.gozoomin.com/Register.aspx.

Para acederes à agenda:

http://wg.gozoomin.com/Agenda.aspx

No final da sessão e/ou evento ficarão disponíveis os vídeos de cada orador, também terás acesso às demos e PowerPoints.

Vai consultando aqui:

http://wg.gozoomin.com/Sessions.aspx

PS: Se quiserem podem levar o portátil.

Ficaremos à vossa espera.

Microsoft Certified Technology Specialist

redb@student-partners.com — Sun, 19 Apr 2009 11:25:15 +0000

A Microsoft está a oferecer a todos os estudantes universitários vouchers de certificação MCTS, Technology Specialists.

Apenas tens que te dirigir a este site:

https://www.dreamspark.com/Products/Product.aspx?productid=24

Caso não tenhas o software necessário a Microsoft disponibiliza-te tudo o que precisares, basta aceder a:

https://www.dreamspark.com/

Messenger.API + Messenger.WebServices Part 1

redb@student-partners.com — Fri, 17 Apr 2009 07:05:23 +0000

Isto não é bem um post…

Então é o quê???

É aquilo que se pode chamar de Source Control Management, (SCM), dos pobres, uma espécie de Subversion para os projectos do Ricardo, mas… Bem… Sem o SCM propriamente dito.

Ou seja, estou de certa forma a usar este blog e o SkyDrive como repositório de código.

Em que vou publicando as várias etapas do processo, muito antes ainda de o código se encontrar sequer em fase alpha.

Assim com sorte talvez encontre algum “colaborador” que me queira ajudar/contribuir/opinar/etc…

Este post é de certa forma o sucessor deste, não é obrigatório mas aconselho a darem uma olhadela.

Ok! Então vamos lá por as mãos na massa:

O projecto encontra-se dividido essencialmente em 3 grupos.

Uma Stream Assyncrona de Leitura, (que se encontra “relativamente” estável), Messenger.IO.
Web Services que o Windows Live Messenger usa, (login no serviço “Live”, lista de Contactos, Membership, Storage, etc).
A API propriamente dita, onde é efectuado o parse das mensagens, buffer e desfragmentação das streams, modelação de pacotes, essa sucata toda.

Este útimo ponto não só é o mais importante como também é aquele que se encontra na sua fase mais precoce.

Cabe-me a mim criar esta criança sozinha.

Os restantes projectos ou são de Unit Testing, (tenho que adicionar MUITO mais testes) ou são meros interfaces, na generalidade não são de grande importancia, servem apenas de apoio.

No que diz respeito ao interface uma pessoa bem tenta, mas…

Não há nada a fazer.

Aqui SIM!!!

Aqui é onde acontece toda a magia, esta é a parte que interessa.

Para terminar deixo aqui o código fonte em C#

File Attachment:

Messenger.Services%2...

Red Blanc Puzzle, (State Search A* e IDA*)

redb@student-partners.com — Sat, 11 Apr 2009 02:47:53 +0000

Este post é de certa forma uma continuação do anterior.

Não sei se já ouviram falar do Red Blanc Puzzle, (na internet não existe realmente muita informação sobre o “assunto”).

O Red Blanc Puzzle, (RBPUzzle), parece-se com duas instâncias do 8Puzzle sobrepostas:

Ahhhhh! Uma imagem vale mil palavras!

Parece uma espécie de jogo de damas com regras “esquisitas”.

As peças brancas apenas se podem mover para a direita ou para baixo, desde que a posição adjacente se encontre vazia.
Peças brancas podem saltar sobre uma peça vermelha para uma posição vazia, (respeitando as regras anteriores).
As peças vermelhas podem mover-se para cima ou para a esquerda com as mesmas restrições das peças brancas.

Digam lá!!! Já tive interfaces muito mais feios que este!

Neste momento sinto que é impossivel criar uma aplicação em WinForms sem que me cheire logo a bolor!

Comparado com as capacidades de WPF, WinForms já está com olhos de carneiro mal morto. (Just kidding)

Para não “destoar”, a típica versão em linha de comandos:

Vou tentar manter este post curto!

Código Fonte em C#:

File Attachment:

RBPUzzleStateSearch%...

8Puzzle Solver, (State Search Classics A* e IDA*)

redb@student-partners.com — Tue, 31 Mar 2009 22:49:11 +0000

Chega um momento na vida de um homem em que ele tem que implementar os clássicos de procura em espaço de estados.

Não se deixem enganar rapaziada!

Um homem tem que fazer três coisas durante a vida, (não necessáriamente por esta ordem):

Plantar uma árvore.
Escrever um livro.
Ter um filho.

Um programador deve fazer tudo isso e mais. Deve implementar os mais famosos algoritmos de procura em espaço de estados, (AStar e IDAStar).

Chega de blá, blá, blá…

Esta talvez seja a minha primeira aplicação WPF/XAML digna desse nome:

Faz uso de styles.
Tem animações.
Skin da “Janela”.

Ok certo!! São só três “coisinhas”, mas por algum lado temos que começar não é?!

Estou a tentar tornar-me um programador prolífico e isso inclui programar “selvaticamente” este algoritmo em várias linguagens, Java, C#, VB.NET, Spec# e eventualmente quem sabe C++/CLI, F# e C++

Enquanto alguns ports são triviais, (a tal palavra usada pelos nossos professores de análise matemática), (Java, VB.NET, Spec#), outros são capazes de dar luta, (C++/CLI, C++, F#)…

Pelo menos para mim que não as costumo usar…

Quem sabe não escrevo uma versão em Silverlight e meto aqui no Blog??? (Bem pensado!!!) Hi5 para mim mesmo!!!

(Sim vocês adivinharam, tive uma infância conturbada )

Mais disso adiante.

Para já ficam com as imagens “sofridas” da versão linha de comando.

E voilá!!! (Como é óbvio este post durou mais de um dia a escrever)

Não está tão giro como a versão WPF, mas também não anda muito longe.

Uma coisa que me surpreendeu e bastante foi que programar em Silverlight e WPF não é exactamente a mesma coisa!!

Na verdade para uma tecnologia que é um subset de outra existem demasiadas diferenças.

Anyway aqui fica:

Código Fonte em C#:

File Attachment:

8PuzzleStateSearch%2...

Código Fonte em VB.NET: (Não contém projecto Silverlight por preguiça do autor)

File Attachment:

8PuzzleStateSearch%2...

Código Fonte em Java: (Não contém GUI por preguiça do autor)

File Attachment:

8PuzzleStateSearch%2...

As outras versões, (Spec#, C++/CLI), ficam para quando tiver mais tempo disponivel, (se alguma vez um milagre desses acontecer)

Se por alguma motivo não conseguirem compilar, (em C# por exemplo), devido ao seguinte erro:

basta mudar isto:

para isto:

Proxy Changer v0.3

redb@student-partners.com — Mon, 23 Mar 2009 05:33:32 +0000

Ninguém diria que o meu browser favorito havia de ser o Google Chrome, (sendo eu um MSP)

(A Microsoft dá cabo de mim, não dão nada, eles são altamente).

Contudo existe um pequeno senão!!!

Acontece que este browser tem um “defeito” horrível!!!

Para mudarmos as definições do Proxy somos reencaminhados para as definições do Internet Explorer. ??

(Não compreendo lá muito bem porque carga de agua fizeram isto, mas ok)

Se forem como eu, sempre que mudam de local têm de estabelecer um proxy diferente, ao fim de apenas um par de dias o mais certo é passarem-se completamente da carola!

E então se forem programadores vão querer resolver vocês próprios o problema! Certo?

Dito e feito!

Como nunca programei nada em WPF e para mim XAML era quase Chinês.

Decidi juntar o útil ao agradável, (ou pelo menos tentar).

Porque não escrever o programa em XAML?

Por onde começar?

Tenho que admitir que tirei algumas ideias daqui.

Se querem começar aprender XAML/WPF sobre a perspectiva de um programador WinForms, então este é o lugar certo.

Oh Ricardo!!! Como é que conseguiste fazer uma aplicação em WPF tão feia???

É um dom que eu tenho.

Brincadeiras à parte WPF é extremamente interessante, infelizmente ainda tem alguns drawbacks.

Especialmente no que diz respeito à aceleração por hardware.

Experimentem fazer o resize de uma janela e até vos dá uma coisa!

Tirando isso recomendo vivamente.

Download aqui:

File Attachment:

ChangeProxy.zip

Nota:

O programa é tão básico que nem tem botão para encerrar, (façam Alt + F4)
Clicar em qualquer zona da janela para a arrastar.

Vector Designer

redb@student-partners.com — Sat, 30 Aug 2008 08:57:23 +0000

Com base num programa anterior, aqui, comecei a desenvolver um editor vectorial, (ainda está numa fase muito "fanhosa", fase alpha, ainda nem sequer tem direito a ser beta ).

Para quem leu o post sobre o XGL Designer e viu o ScreenCast, deve ter reparado, (ou melhor! Horrorizado), em como o editor não era assim grande coisa! E se houve algum LOUCO que decidiu correr o código, então deve ter reparado que funcionalidade não é o forte "coisa".

Assim sendo, decidi/tentei fazer um fork daquilo, e foi assim que nasceu o meu Frankenstein a "quem" decidi chamar: Vector Designer:

É uma tentativa ainda muito fraquinha, (admito), de escrever um editor vectorial, com:

1. Layers

2. Grouping

3. Transformações, (Move/Translate, Rotate, Matrix, etc...)

Algumas funcionalidades ainda não existentes, (mas desejadas):

1. Suporte para Managed DirectX.

(Oh YES!!! Quando o editor tiver 1milhão de figuras, fazer as transformações por software ia ser uma péssima ideia)

2. Menu Context

3. Que o editor seja capaz de limpar a minha casa enquanto eu não estou cá, (Just kidding)

Desta vez não deixo código, porque ainda está numa fase muito horrível! (Admitindo que vou alguma vez vou ter tempo para continuar e melhorar isto).

MAS... Deixo o ScreenCast, (que na minha modesta opinião até está muito catita )

Tenham é em atenção que o ScreenCast foi filmado a uns 3 a 5fps, (para poupar espaço), por isso algumas animações não são assim tão fluidas

File Attachment:

Vector%20Designer.wm...

Nota: O ScreenCast e as imagens presentes neste post foram tiradas do mesmo programa, mas em versões ligeiramente diferentes!
As imagens são de uma versão ligeiramente mais recente.

Designer + OpenGL 2.0 = XGL Designer

redb@student-partners.com — Fri, 29 Aug 2008 05:54:39 +0000

XGL?! Mas o que vem a ser isto do XGL?

Bem... Há não muito tempo atrás numa cadeira de Computação Gráfica o professor queria que desenvolvêssemos um projecto à nossa escolha em OpenGL numa linguagem também ela à nossa escolha.

(Decisão arrojada, se pensarmos que aqui na universidade Linux = Bom, Microsoft = Mau).

Havia uma "contrapartida" interessante nesta cadeira, não haveria aulas teóricas, apenas aulas práticas e dois livros de OpenGL na sala de aula para os alunos consultarem.

A presença do professor pautava-se mais pela ausência do que pela presença, (Andava pelo gabinete acho eu! Apesar desta descrição foi uma das cadeiras mais interessantes que já tive)

Ora bem... O que fazer?!

Eu já tinha "tocado" apenas como hobby/curiosidade em Managed DirectX, (mais info, aqui, aqui e aqui).

Mas OpenGL?! Cruzes Credo!!!

Assim sendo comecei a "chafurdar" nas bibliotecas nativas (Sempre com pensamento positivo, podia ser pior Ricardo, podia ser COM, pior ainda!!! Podia ser Linux, Just Kidding)

E aos poucos e poucos foi surgindo um wrapper muito fininho à volta disto, (que não era propriamente veloz ou eficiente).

Foi então que encontrei a The Tao Framework, que era basicamente tudo o que eu estava a fazer, mas MELHOR, (espero eu).

Se eu tivesse que descrever a The Tao Framework diria que é um wrapper sem qualquer orientação a objectos, era C# estruturado.

O que eu fiz foi construir novo wrapper muito básico à volta da "Tao", (gestão de recursos, disposing, etc...).

OpenGL pode e deve ser considerada como uma máquina de estados, (ver The Redbook), (quase ao nível de Assembly na minha opinião. )

por exemplo, definir uma luz do tipo Specular em C com OpenGL:

/* 
  Este "simples" método é usado para definir uma luz, ou seja, 
  O tipo de luz, (Specular, Diffuse), qual a luz a modificar ou criar... 
  Local para onde aponta, onde se encontra a cor, etc... 
 
  Mas reparem, só temos 3 argumentos, 2 inteiros e um ponteiro para float 
*/  
void glLightfv(GLenum light, GLenum pname, const GLfloat * params);

Para criar uma simples luz teria que escrever toda esta tralha:

int light = 2;  
  
float  color[] = float {0.5f, 0f, 0f, 0f};  
float vertex[] = float { x, y, z, isInfinite ? 0.0f : 1.0f };  
  
glLightfv(light, GL_SPECULAR, color);  
glLightfv(light, GL_POSITION, vertex);  
glEnable(light);

O mesmo método serve para fazer várias coisas, (confuso e muito pouco produtivo)

O que XGL faz é simplificar as coisas, (ou melhor, simplificar a minha vida).

Para definir a mesma luz bastaria usar um destes métodos.

public static void Specular(Light light, Color color)  
{  
    Gl.glLightfv((int)light, Gl.GL_SPECULAR, XglCore.ColorToFloat(color));  
}  
  
//Como todas estas chamadas são a métodos estáticos estou apostar que a CLR esta a fazer  
//inlining onde é possivel, não prejudicando muito a performance  
public static void Specular(Light light, Vertex position, bool isInfinite, Color color)  
{  
    Gl.glLightfv((int)light, Gl.GL_SPECULAR, XglCore.ColorToFloat(color));  
    float[] vertex = new float[] { position.X, position.Y, position.Z, isInfinite ? 0.0f : 1.0f };  
    Gl.glLightfv((int)light, Gl.GL_POSITION, vertex);  
    Gl.glEnable((int)light);  
}

O mesmo é válido para texturas, para carregar uma Mesh para memória, animações, etc...

Como não tinha nome para esta "Framework" até que tivesse alguma ideia chamei-lhe, XGL, (X de incógnita e GL de OpenGL).

Acabou por pegar entre os colegas do meu grupo e deixei ficar assim.

Esta cangalhada de 800 linhas apenas para explicar o nome?! JESUSSSS!!!

Então vamos para a parte que eu espero ser mais interessante

Depois de ter a "Framework" semi encaminhada, (famoso código à pedreiro), não podia apresentar a "coisa" assim ao professor e pronto.

"Olhe! Tome esta dll em C# professor, é só experimentar quando chegar a casa"

Faltava-me ainda arranjar alguma coisa para exercitar todo o código que tinha escrito, foi então que me ocorreu!

"Então e se eu escrevesse um editor vectorial aqui à pressa e os meus colegas fizessem os desenhos?!"

Dito e feito!

E assim surgiu Drawing Board, (ou como eu gosto de lhe chamar, o programa do copo).

O "programa do copo" é um editor vectorial MUITO primitivo com capacidades de desenho muito rudimentares, que permite gerar objectos 3D a partir de perfis de sólidos de revolução.

Como por ex:

Isto é só um pequeno exemplo.

Apesar de não ter inserido aqui nenhum exemplo é possível usar texturas.

Um colega meu desenhou uma lapiseira, uma garrafa de água e uma de vinho que tão o máximo!

A minha funcionalidade favorita de TODOS os tempo é converter um objecto noutro, (Morphing, por exemplo uma garrafa de água numa de vinho!)

Se estiverem interessados em ver o programa a funcionar, (morphing incluindo), tenho aqui um ScreenCast, (Notem é que isto foi filmado a umas 2 ou 5 frames por segundo, assim sendo não é lá muito fluido).

File Attachment:

Platform.Xgl.wmv

E se forem ainda mais loucos/desvairados do que eu pensava têm aqui o código fonte!

Atenção que existe um requisito especial, têm que copiar Platform.Xgl\bin\freeglut.dll para C:\Windows\, (unmanaged API)

Ao fazer o download deste código recomendo especial atenção a este post.

File Attachment:

Platform.Xgl%20Sourc...
Vão encontrar na pasta Platform.Xgl\Vertexes ficheiros de extensão *.vertex, (podem e devem abrir esses ficheiros com o programa)

Windows Vista Sidebar Look-Alike Transparency

redb@student-partners.com — Fri, 29 Aug 2008 04:21:31 +0000

Olá novamente!

Hoje venho mostrar uma coisa assim mais do género "eyecandy".

Se derem uma olhadela à Sidebar do Windows Vista vão certamente reparar que tem umas transparências todas "catitas" e não só, tem ali um LinearGradientBrush de certeza.

Como é que eles fazem aquilo?

Quer dizer... É perfeitamente possível ter janelas transparentes com Windows Forms, (trivial até), (sempre desejei dizer esta palavra, os meus professores de Análise Matemática não conseguiam dizer duas palavras sem espetar trivial pelo meio)

Agora o resultado é que não era lá muito agradável:

1. A janela ao ser "clicada" não recebia focus, (às vezes esta é a intenção), quem o recebe é a janela que se encontra por trás.

2. Os gráficos desenhados com GDI/GDI+ saíam HORRÍVEIS sem qualquer anti-aliasing, (Só usando mesmo pngs).

Conclusão não faço a ideia como é que o pessoal que programou a Sidebar do Windows resolveu esse problema, , MAS encontrei um conjunto de soluções através de PInvoke e Windows Vista, (é obrigatório o Windows Vista, não funciona com o XP, mais à frente vais compreender porquê), que produzem resultados muito semelhantes

Ok! Para começar, vamos ter que sujar as mãos em código compilado para X86, (Espera!!! Não fujas eu prometo que isto não vai doer nada!!!)

Onde é que eu já ouvi esta frase? Não teria sido um famoso pedófilo português?! Adiante...

Eis o que vamos precisar:

using System;  
using System.Windows.Forms;  
using System.Runtime.InteropServices;  
  
[DllImport("dwmapi.dll", PreserveSig = false, EntryPoint = "DwmEnableComposition")]  
private static extern int EnableComposition(int value);  
  
[DllImport("dwmapi.dll", PreserveSig = false, EntryPoint = "DwmIsCompositionEnabled")]  
private static extern int IsCompositionEnabled(out bool value);  
  
[StructLayout(LayoutKind.Sequential)]  
public struct Margin  
{  
    public int Left     { get; set; }  
    public int Right    { get; set; }  
    public int Top      { get; set; }  
    public int Bottom   { get; set; }  
}  
  
[DllImport("dwmapi.dll", PreserveSig = false, EntryPoint = "DwmExtendFrameIntoClientArea")]  
private static extern int ExtendFrameIntoClientArea(IntPtr hWnd, [In] ref Margin margins);  
  
[StructLayout(LayoutKind.Sequential)]  
private struct BlurBehind  
{  
    public Settings Flags               { get; set; }  
    public bool Enable                  { get; set; }  
    public IntPtr Region                { get; set; }  
    public bool TransitionOnMaximized   { get; set; }  
  
    [Flags]  
    public enum Settings  
    {  
        Enable              = 0x00000001,  
        Region              = 0x00000002,  
        TransitionMaximized = 0x00000004  
    }  
  
}  
  
[DllImport("dwmapi.dll", PreserveSig = false, EntryPoint="DwmEnableBlurBehindWindow")]  
private static extern int EnableBlurBehindWindow(IntPtr hWnd, [In] ref BlurBehind pBlurBehind);  
  
public static void EnableTransparentForm(Control control, bool enable)  
{  
    EnableBlurBehindWindow(control, new Region(new Rectangle(-1,-1, 1, 1)), enable);  
}

(Afinal não foi assim tão mau pois não)

EnableComposition - Liga e desliga compositon, (Basicamente liga e desliga o theme Aero)

IsCompositionEnabled - Verifica se é possível efectuar composition, (pode estar desligada, ou não ser suportada)

ExtendFrameIntoClientArea - Estende as frames para a área cliente, (As frames tem "Glass Effect")

EnableBlurBehindWindow - Define um rectângulo ou Region para aplicar "Glass Effect"

Glass Effect, Glass Effect, Glass Effect, Glass Effect, Mas o que é que isso tem a ver com transparência?! (Já lá vamos)

Para que uma janela apresente "Glass Effect" usamos EnableBlurBehindWindow e especificamos a região que queremos aplicar o efeito, se indicarmos uma região inválida, (algo que se encontre fora da janela como por exemplo new Rectangle(-10, -10, 1, 1)) o Windows, (mais concretamente dwmapi.dll), em vez de delegar o "trabalho de pintura" a nós, pinta-o ele mesmo, (numa zona à nossa escolha), ou seja, fica tudo "transparente", porque a "pintura" se encontra numa zona "além fronteiras".

Mas continuamos a receber o focus como normalmente, o que pode ou não ser um bónus.

Ex:

using System;
using System.Windows.Forms;  
  
public class Transparent : Form  
{  
    public Transparent()  
    {  
        //Há que ter em atenção ao "eventos" Composition Enabled/Disabled  
        if (VistaApi.IsCompositionEnabled())  
        {  
            VistaApi.EnableTransparentForm(this, true);  
        }  
    }  
}

Então e para obtermos o "Efeito Sidebar"?

Basta efectuarmos um override ao método OnPaint(PaintEventArgs e) com o seguinte código:

using System;  
using System.Drawing;
using System.Windows.Forms;  
  
public class Transparent : Form  
{  
    public Transparent()  
    {  
        //Há que ter em atenção ao "eventos" Composition Enabled/Disabled   
        if (VistaApi.IsCompositionEnabled())  
        {  
            VistaApi.EnableTransparentForm(this, true);  
        }  
    }  
  
    protected override void OnPaint(PaintEventArgs e)  
    {  
        base.OnPaint(e);  
  
        Graphics g = e.Graphics;  
  
        this.DoubleBuffered = true;  
  
        g.FillRectangle(  
            new LinearGradientBrush(  
             this.DisplayRectangle,  
             Color.FromArgb(0x00, Color.Black),  
             Color.FromArgb(0xff, Color.Black),  
             90f),  
        this.ClientRectangle);  
    }  
}

A quantidade de "efeitos" que se podem fazer é quase ilimitada

Por fim deixo aqui o código e o ScreenCast para vocês brincarem um bocadinho

File Attachment:

WindowsVistaGlass.wm...

File Attachment:
Windows Glass Effect.zip
(68,91016 kB)

Windows Live Messenger Clone

redb@student-partners.com — Thu, 28 Aug 2008 10:25:21 +0000

Já toda a gente, (ou quase toda a gente), deve ter visto/escrito a sua própria versão do Windows Live Messenger.

Sim eu confesso , eu também não resisti e há uns tempos atrás também escrevi a minha própria implementação do protocolo, (MSNP15).

Para quem estiver interessado em obter mais informações sobre o protocolo pode dirigir-se aqui.

Então e o que é que esta versão tem de especial - Perguntam vocês.

Para além da carga habitual de bugs, da interface horrível, do famoso código à pedreiro, etc...

Bem...espante-se, a interface encontra-se implementada em Linha de Comandos.

(Um tipo não pode fazer tudo, código e interface.)

De qualquer modo QUALQUER interface criado por mim JAMAIS teria melhor aparência do que a linha de comandos, (falo do fundo do coração).

Funcionalidades (Nada demais)

Autenticação

Contactos

Grupos

Mensagem Pessoal

Estado

PSM, (Onde vem a vossa mensagem e música que estão a ouvir)

Chat, (Sim porque conversar numa janela DOS é o sonho que qualquer utilizador), etc...

Depois de verem estes screenshots horrendos é bastante possível que alguns de vocês tenham ficado a pensar que eu sou um fan de Telnet e que o Windows devia ser TODO acedido através de Telnet! Nada disso!

Foi só mesmo para "despachar".

ScreenCast se estiverem interessados

File Attachment:

CommandPrompt.Window...

Desta vez não deixo código para vocês darem uma olhadela por dois simples motivos:

1. O código está uma desgraçada!!!

2. O protocolo não é público, é um protocolo proprietário.

Como tal é normal que a sua implementação mude sem qualquer aviso prévio, (como já tem acontecido), e o código deixa de funcionar por COMPLETO!!!

Windows Live Writer Add-in - Attachment

redb@student-partners.com — Thu, 28 Aug 2008 09:55:50 +0000

Este post assume que já leste outros posts pertencentes a esta mesma categoria.

Se ainda não o fizeste aconselho-te vivamente a começares aqui ou aqui.

Vamos continuar a partir do ponto onde ficamos anteriormente.

O objectivo desta vez é inserir conteúdo, (attachments) directamente no blog em vez de usar um serviço externo como o SkyDrive por exemplo, como fizemos na última vez.

Que no final ficará com este aspecto:

O processo é em tudo idêntico ao anterior, mas em vez de herdarmos de ContentSource, herdamos de SmartContentSource, que é muito mais flexível e poderoso.

[WriterPlugin("97c76bc7-0030-4e33-960f-b4356277aaac", "Attachment",  
Description = "Uploads Attachments into your blog and providing a link")]  
[InsertableContentSource("Attachment")]  
public class InsertAttachmentAddin : SmartContentSource  
{  
    //Painel que vai aparecer à direita!!!  
    public override SmartContentEditor CreateEditor(ISmartContentEditorSite editorSite)  
    {  
        //ContextEditor herda de SmartContentEditor que por sua vez herda de UserControl  
        //Ou seja, não passa de um simples controlo como aqueles usados nos Windows Forms  
        return new ContextEditor();  
    }  
  
    public override DialogResult CreateContent(IWin32Window dialogOwner, ISmartContent content)  
    {  
        //O Equivalente de ContentSource.CreateContent mas para SmartContentSource.CreateContent  
        //Em vez do segundo argumento ser uma string é do tipo ISmartContent.  
    }  
  
    //Aqui é onde vão gerar o vosso HTML que pode muito bem ser simplesmente JavaScript  
    //Ou seja sem conteúdo visível  
    public override string GeneratePublishHtml(ISmartContent content, IPublishingContext publishingContext)  
    {  
    }  
  
}

1. CreateEditor() - Responsável pela criação do painel que se encontra à direita, (não será abordado aqui)

2. CreateContent() - É este o método chamado sempre que clicam num "Insert Picture |Table | etc...", ou seja, o equivalente de main() em C.

2. GeneratePublishHtml() - Aqui é onde geram todo o vosso HTML se assim o entenderem.

Então e como fazer o upload de um ficheiro para o servidor?

public override string GeneratePublishHtml(ISmartContent content, IPublishingContext publishingContext)  
{  
    string fakeFilePath = @"C:\AttachThis.zip";  
    //Adiciona um ficheiro!  
    string fileName = Path.GetFileName(fakeFilePath)  
    content.Files.Add(fileName, Path.GetFullPath(fakeFilePath));  
    return string.Format(Properties.Resources.AttachmentHtml, fileName, "15kb");    
}

Simples basta usar content.Files.Add(string fileName, string filePath);

O código encontra-se BASTANTE reduzido para efeitos de simplificação.

Podem fazer o download da solução que contém a versão original e explorar Properties.Resources.AttachmentHtml e verificar exactamente o HTML que está a ser emitido.

File Attachment:
Attachment.zip
(34,7627 kB)

Vão também precisar de uma folhas de estilos para meterem no vosso blog.

File Attachment:
Download.css
(636 bytes)

Windows Live Writer Add-in - SkyDrive - Part 2

redb@student-partners.com — Thu, 28 Aug 2008 09:42:32 +0000

Este post faz parte de uma série de posts.

Se ainda não leste nenhum dos post que ficaram para trás aconselho-te vivamente a começares aqui.

Existem duas opções ao criar uma classe ou herdam de ContentSource ou de SmartContentSource.

ContentSource é extremamente básico, (e é por aqui que vamos começar), permite-vos modificar o texto seleccionado ou caso nada se encontre seleccionado inserir texto.

SmartContentSource é bem mais sofisticado e permite-vos ter maior controlo sobre o conteúdo presente na janela, o vosso conteúdo passa a ser "seleccionável" e ainda têm direito a um painel à vossa direita.

Vamos meter as mãos na "massa" e programar o Add-in mais simples que conseguirmos.

using System;  
using WindowsLive.Writer.Api;  
  
public class InsertSkyDriveAttachmentAddin : ContentSource   
{  
    
}

Podem obter mais informações sobre esta API aqui.

Precisamos também de dois atributos: WriterPlugin e InsertableContentSource.

WriterPlugin descreve o vosso Add-in, (nome, url, descrição, blá, blá, blá).

InsertableContentSource indica quais os nomes que devem aparecer neste menu, (ver imagem abaixo), e na sidebar.

Assim sendo:

using System;  
using WindowsLive.Writer.Api;  
[WriterPlugin("97c76bc7-0030-4e33-960f-b4356277aaaa",          //GUID - tem que ser único!  
"SkyDrive Link",                                               //Nome  
Description = "Inserts a link into SkyDrive content",          //Descrição  
HasEditableOptions = false,                                    //Opções no menu ferramentas  
PublisherUrl = "http://localhost"  
//ImagePath = "code.ico"                                       //Ainda não consegui fazer funcionar  
)]   
[InsertableContentSource("SkyDrive Link")]                     //Insert -->SkyDrive Link<--...  
public class InsertSkyDriveAttachmentAddin : ContentSource  
{  
    public override DialogResult CreateContent(IWin32Window dialogOwner, ref string content)  
    {  
  
    }  
}

Apenas nos falta um passo, (tá quase), fazer a sobrecarga de um destes membros.

CreateContent (Do Menu Inserir).

CreateContentFromUrl (Colar URL).

CreateContentFromLiveClipboard(usando o LiveClipboard).

Vamos usar o primeiro, (CreateContent).

public override DialogResult CreateContent(IWin32Window dialogOwner, ref string content)  
{  
    //dialogOwner - janela mãe  
    //content     - conteúdo selecionado que vocês vão modificar!  
                 
    //Código trivial que abre uma janela onde inserem o link que é validado.  
    using (AddLink form = new AddLink())  
    {  
        //Não é obrigatório usarem dialogOwner, mas fica sempre bem!  
        form.ShowDialog(dialogOwner);  
        if (form.CanInsert == false)  
        {  
            return DialogResult.Cancel;  
        }  
        if(form.IsValidLink() == false)  
        {  
            MessageBox.Show("Invalid Hyperlink");  
            return DialogResult.Abort;  
        }  
        string embed = form.EmbedLink;  
        //E por fim o vosso HTML.  
        content = embed;  
        return DialogResult.OK;  
    }  
}

Não me querendo alongar muito para não por ninguém a dormir, deixo aqui o zip da solução para os curiosos poderem explorar.

File Attachment:
SkyDrive.zip
(15,42871 kB)

Vão precisar também de uma folha de estilos para meterem no vosso blog.

File Attachment:
Download.css
(636 bytes)

Windows Live Writer Add-in - SkyDrive - Part 1

redb@student-partners.com — Thu, 28 Aug 2008 09:38:44 +0000

Isto de ter um blog tem muito que se diga

Não faço a mínima ideia de como é que a maioria das pessoas "bloga", (este palavrão existe?!)

Mas eu cá gosto de faze-lo com o menor atrito possível, (Rei da preguiça).

Gosto do Windows Live Writer, mas ainda assim acho que lhe faltam ali algumas umas funcionalidades que dariam imenso jeito!

Como por exemplo inserir conteúdos directamente do SkyDrive para o vosso blog.

Fazendo aparecer algo deste género no vosso blog:

É exactamente isso que vamos fazer.

Antes de meter as mãos no código vamos criar um projecto com o Visual Studio e configurá-lo correctamente para podermos depurar o código enquanto o Add-in corre, (Assim não ficamos às cegas).

1. Criar um novo projecto do tipo: Class Library

2. Definir Post-build event command line como: XCOPY /D /Y /R "$(TargetPath)" "C:\Program Files\Windows Live\Writer\Plugins\"

3. Start External Program: C:\Program Files\Windows Live\Writer\WindowsLiveWriter.exe

Claro que podem e devem mudar os caminhos consoante o local onde instalaram a vossa aplicação.

4. Finalmente adicionar esta Assembly: "C:\Program Files\Windows Live\Writer\WindowsLive.Writer.Api.dll" e marcar Copy Local como false, (preferencialmente)

Com isto em mãos já podem programar e correr o vosso Add-in no Live Writer e efectuar o respectivo Debug.

Continuar

About Moi

redb@student-partners.com — Thu, 28 Aug 2008 09:33:12 +0000

Olá Pessoal!

O meu nome é Ricardo Bartolomeu e muito recentemente, (um grande ênfase no “muito recentemente”), fui eleito MSP, (Microsoft Student Partner).

O que é que isto significa?

Boa pergunta! Eu também ainda não sei muito bem...

Para dizer a verdade o que eu queria mesmo era ser vencedor do concurso Miss Pantene

(Mas não pensem que eu vou desistir só porque não ganhei este ano!!!)

Assim sendo, enquanto o meu "verdadeiro" sonho não se concretiza vou começando a dar os meus primeiros passos nesta coisa de ser MSP!

Para já vou aproveitar a oportunidade para fazer algo que desejava HÁ MUITO tempo! Ter um blog todo à maneira

Ok! Vamos lá à parede dos horrores!

A típica foto junto à subsidiária portuguesa da Microsoft que todos os MSPs devem ter tirado pelo menos uma dúzia de vezes

"Mug Shot", (Nem estava a olhar devidamente para a câmara, que grande "bezana" meu Deus! Se esta foto não vos dá vontade de rir então NADA vos fará rir!!! NADA!!!)

E finalmente a minha versão Simpson Ou pelo menos uma tentativa!

Espero que se divirtam por aqui e acima de tudo que os meus conteúdos vos cativem. Fiquem bem