MVC - Implementação

Olá,

Quanto as suas colocações referentes as camadas de controle, visão e persistência, eu não tenho nenhuma objeção, não sei os demais amigos do fórum.

Eu aconselho você a dar uma sapiada naquela apostila da caelum, a fj21, tem vários exemplos de aplicações cliente/servidor, no meu caso, foi de grande ajuda: tanto no âmbito de arquitetura quanto no de desenvolvimento.

Fica ai a dica, espero ter ajudado!

[]'s

Olá getAdicted,

Vou ler a apostila, muito obrigado pela dica!
Só uma outra pergunta: tem diferenças entre a implementação entre o MVC pra web e o desktop? Pq já li sobre o MVC2 aqui, em que diziam ser pra web, e também algumas recomendações da sun que diziam o mesmo.

Muito obrigado pela participação, getAdicted!

Olá novamente amigo,

Eu sempre mantive contato com aplicações cliente/servidor, somente, seja através do GUJ, seja através de apostilas (também disponibilizadas pelos companheiros), entretanto, em uma breve pesquisa que eu fiz logo após você postar, conclui que esse padrão de arquitetura também é empregado em aplicações Desktop:

http://www.guj.com.br/posts/list/60570.java

Se os demais amigos postarem nesse tópico, poderão lhe informar melhor.

[]'s

getAdicted , em primeiro lugar muito obrigado por disponibilizar parte do seu tempo para me ajudar.

Então, já dei uma lida aqui no forum tmb, e encontrei algumas informações sim.
Li alguns exemplos teóricos sobre implementação do MVC em sistemas web, o que já deu uma boa clareada.

Porém, para desktop (o que necessito), funciona de maneira um pouco diferente, já que nesse caso, o MVC trabalha de forma tringular (view -> controller -> model -> view).
Contudo, claro que terei que fazer algum pequeno sistema web (para estudos), tentando usar o mesmo model futuramente, já que, pelo que entendi, MVC serve justamante para isso: ter o mesmo model sendo usado em vários ambientes, como web, desktop etc.
Tô certo ou falando bobeira?

Novamente muito obrigado pela atenção e ajuda!

Abraços!

Encontrei um ótimo material sobre patterns, estou estudando nesse momento.
Quem quiser dar uma olhada: http://www.patterndepot.com/put/8/DesignJava.PDF

Abraços!

Olá pessoal.

Estou estudando o pattern Observer(para utilização com MVC), porém, estou encontrando muitas, dificuldades.
A idéia é a seguinte:

Tenho 3 classes:

Model: possui o atributo texto(String) que herda Observable

View1: possui um JFrame com um Jtxt(txtTexto) e um Jbtn(btnAlterar)

View2: possui um JFrame com u JLabel(lblTexto)

O que estou tentando fazer: Quando btnAlterar da View1 for clicado, pegar o valor de txtTexto e mandá-lo para o atributo texto de Model, que ao receber o valor, informa a View2 que seu estado(do Model) foi alterado, e exibindo
o valor do atributo texto de Model na View2 .

Abaixo segue o código para entenderem melhor:

Model

package observercomheranca;

import java.util.Observable;

public class Model extends Observable{

    /*variável que será passada por View1 e recebida por View2*/
    private String texto = "";


    /*Getter e Setter*/
    public String getTexto() {
        return texto;
    }

    public void setTexto(String texto) {
        this.texto = texto;
        setChanged();
        notifyObservers();
    }

}

View1

package observercomheranca;

import javax.swing.*;

/*janela que terá um txt e um btn, que, quando clicado no btn, enviará o texto
 para o Model, que enviará aos seus observadores*/
public class View1 {
    
    private JFrame janela = new JFrame();
    private JPanel painel = new JPanel();

    private JTextField txtTexto = new JTextField();
    private JButton btnAlterar = new JButton("Alterar");

    public View1() {
        txtTexto.setColumns(15);

        painel.add(txtTexto);
        painel.add(btnAlterar);

        janela.add(painel);
        janela.setResizable(false);
        janela.setLocation(800, 450);

        janela.pack();
        janela.setVisible(true);
    }

    public static void main(String[] args) {
        View1 v1 = new View1();
    }



    public String getTexto() {
        return txtTexto.getText();
    }

    public void setTxtTexto(String texto) {
        this.txtTexto.setText(texto);
    }

}

View2

package observercomheranca;

import javax.swing.*;

/*janela que possui apenas uma label para receber o valor digitado no txt
 de View1*/
public class View2 {

    private JFrame janela = new JFrame();
    private JPanel painel = new JPanel();

    private JLabel lblTexto = new JLabel(" ");

    public View2() {
        painel.add(lblTexto);

        janela.add(painel);
        janela.setResizable(false);
        janela.setLocation(800, 450);
        janela.setSize(200, 200);

        janela.pack();
        janela.setVisible(true);
    }

    public static void main(String[] args) {
        View2 v2 = new View2();
    }



    public String getTexto() {
        return lblTexto.getText();
    }

    public void setTxtTexto(String texto) {
        this.lblTexto.setText(texto);
    }


}

Não quero nada pronto, apenas que me me ajudem com dicas, pois não estou conseguindo entender muita coisa, mesmo pesquisando até a documentação do Java.
Estou me esforçando pra aprender alguns design patterns, conto com a ajuda de vocês para conseguir me virar com esse.

Abraços a todos e muito obrigado desde já!

lembrei de uma discussão sobre o assunto que li aqui no fórum.

http://www.guj.com.br/posts/list/129277.java

Boa tarde wbdsjunior,

Primeiramente, muito obrigado pela colaboração!

Então, li praticamente o tópico todo (apesar do tamanho dele ser monstruoso, já havia lido parte ele, e agora li mais um bom trecho), e pra essa dúvida atual quanto ao observer não me tirou as dúvidas ainda.

Vou continuar procurando por algo aqui no fórum e pelo google tmb.

Novamente muito obrigado!

Continuo esperando a colaboração do pessoal, abraços!

Pelo que tô entendo:

Meu model tem que herdar Observable, chamando os métodos setChanged() e notifyObservers() quando algo for alterado no próprio model.
Depois, cada observador deve implementar Observer, sobrescrevendo o método abstrato update() para atualizar o modelo.

É isso mesmo?

Acho que estou começando a entender como funciona, só está um pouco dificil de implementar.

Vou continuar tentando por aqui.

Obrigado, abraços!

O método update do Observer é chamado quando há uma atualização no Observable. É sua responsabilidade atualizar o Observer baseado na atualização do Observable. Se Observer é uma tela, vc atualizaria com o estado mais recente do Observable.

esmiralha, muito obrigado por me ajudar!

Então, pelo que entendi, o update deve ser feito quase “no braço”, é isso?

Consegui o seguite:

No model:

/*add observer já na instanciação*/
public Model(Observer obs){
        this.addObserver(obs);
    }
    /*atualiza o valor da variável texto e notifica observers*/
    public void atualizar(String texto){
        this.texto = texto;
        setChanged();
        notifyObservers(texto);
    }

Na View2

/*add observador */
Model model = new Model(this);

public View2() {

        painel.add(lblTexto);

        janela.add(painel);
        janela.setResizable(false);
        janela.setLocation(800, 450);
        janela.setSize(200, 200);

        janela.pack();
        janela.setVisible(true);


        model.atualizar("TESTE");
    }
/*aqui atualizo a lblTexto da View2 com o valor da variável texto do model*/
public void update(Observable o, Object texto) {
       if (o instanceof Model){
           lblTexto.setText((String)texto);
       }

Tá correto ai, ou é muita gambiarra? Lembrando que estou apenas tentando entender como funciona, pra depois pra poder implementar de forma correta.

Novamente, muito obrigado pela ajuda!

Abraços!

Certo está, mas leia esse artigo aqui: http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/arqu/observer.htm

esmiralha, muito obrigado pelo link!

Dei uma lida por cima agora (tenho que ir à aula daqui a pouco), e pelo que entendi, essa é a forma correta de trabalhar com Observer(usando interfaces e tal).
Ainda hoje estarei lendo com mais tempo.

Novamente muito obrigado pela ajuda!

Abraços!

Pessoal, consegui da forma que segue abaixo:

Model

package observercomheranca;

import java.util.Observable;
import java.util.Observer;

public class Model extends Observable{

    /*variável que será passada por View1 e recebida por View2*/
    private String texto = "";

    public Model(Observer obs){
        this.addObserver(obs);
    }

    /*Getter e Setter*/
    public String getTexto() {
        return texto;
    }


    public void atualizar(String texto){
        this.texto = texto;
        setChanged();
        notifyObservers(texto);
    }


}

View1

package observercomheranca;

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Observable;
import java.util.Observer;
import javax.swing.*;

/*janela que terá um txt, que, recebendo entradas via teclado, enviará o texto
 para o Model, que enviará aos seus observadores*/
public class View1 implements Observer{

    Model model = new Model(this);

    private JFrame janela = new JFrame();
    private JPanel painel = new JPanel();

    private JTextField txtTexto = new JTextField();

    public View1() {

        /*passa o model de View1 para View2 como parametro ao instanciar View2
         para ambos poderem trabalhar com a mesma instancia de model*/
        View2 v2 = new View2(model);


        /*add keylistener para quando a tecla for liberada passar o seu valor
         para o atributo texto pertencente a model*/
        txtTexto.addKeyListener(new KeyListener() {

            public void keyTyped(KeyEvent e) {
               
            }

            public void keyPressed(KeyEvent e) {
                
            }

            public void keyReleased(KeyEvent e) {
                model.atualizar(txtTexto.getText());
            }
        });

        txtTexto.setColumns(15);

        painel.add(txtTexto);

        janela.add(painel);
        janela.setResizable(false);
        janela.setLocation(800, 450);

        janela.setLocation(800, 450);

        janela.pack();
        janela.setVisible(true);
    }

    public static void main(String[] args) {
        View1 v1 = new View1();
    }

    public void update(Observable o, Object arg) {
        /*aqui entraria algum código caso uma atualização do model
         devesse causar algum impacto nesta classe*/
    }


}

View2

package observercomheranca;

import java.util.Observable;
import java.util.Observer;
import javax.swing.*;

/*janela que possui apenas uma label para receber o valor digitado no txt
 de View1*/
public class View2 implements Observer{

    /*precisamos de um model para poder registrar View2 como observer
     então primeiramente passamos um model vazio*/
    Model model = null;

    private JFrame janela = new JFrame();
    private JPanel painel = new JPanel();

    private JLabel lblTexto = new JLabel(" ");

    public View2(Model model) {

        /*como View1 chamará View2, passamos o model da View como parametro
         para View2 quando esta última for instanciada, para poder reistrá-la
         como observer*/
        this.model = model;

        /*registra View2 como observer de model*/
        model.addObserver(this);

        painel.add(lblTexto);
        
        janela.add(painel);
        janela.setResizable(false);
        janela.setLocation(800, 450);
        janela.setSize(200, 200);

        janela.setLocation(650, 450);

        janela.pack();
        janela.setVisible(true);
    }

    /*aqui atualizo a lblTexto da View2 com o valor da variável texto do model*/ 
    /*aqui o Object seria o próprio Model instanciado? */
    public void update(Observable o, Object texto) {
       if (o instanceof Model){
           lblTexto.setText((String)texto);
       }
    }
}

Pelo link passado por vc esmiralha, pude perceber que é uma gambiarra e das fortes o que fiz, rs.
Porém, também gostaria de saber se meus conceitos inseridos como comentários no código estão corretos ou não?
Minha maior dúvida: aqui o Object texto seria o próprio Model instanciado, correto? Já que o instanceof Model retorna true.

/*aqui o Object seria o próprio Model instanciado? */ public void update(Observable o, Object texto) { if (o instanceof Model){ lblTexto.setText((String)texto); }

Porém, como ele é uma instancia de Model, como o seu cast para String com (String)texto, retorna o valor do atributo texto do objeto Model?

Críticas são muito bem vindas, estou aqui justamente tentando aprender, com a grande ajuda de vocês, é claro!

Abraços!

Olá pessoal, dei uma sumida, muita correria, mas não deixei o Java de lado!

Implementei o padrão observer para adequar um de meus projetos da faculdade ao MVC, e fiz da seguinte maneira:

Criei duas interfaces: Observer e Observable

Observable.java

public interface Observable {
    
    public void addObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
    
}

Observer.java

package interfaces;

public interface Observer {

    public void update();

}

A cada classe de modelo que tenho no projeto, tenho que implementar a interface Observable, pra isso crio uma lista de observadores que, quando alterado algum atributo do modelo, chama notifyObservers(), percorrendo a lista e notificando os observadores sobre a atualização no modelo

A view implementa a interface Observer, definindo o método update(). Neste método, a view atualiza a sua interface de acordo com a sua instancia do modelo.

Pelo que podem ver, é uma implementação muito simples do pattern Observer, mas já é um começo.
Pelo esquema UML do pattern, parece estar tudo certo, porém, venho pedir a opinião de vocês sobre essa implementação, o que devo mudar, se tem algo errado, qualquer coisa.
Quero realmente aprender este pattern para poder dar seguimento ao meu estudo sobre MVC, e ficarei muito grato a quem puder me ajudar.

Um grande abraço a todos!

Olá pessoal!

Bem, continuando com as minhas dúvidas (que agora começam a ser poucas), quero saber o seguinte:

O controlador recebe o modelo, para tratamento dos dados enviados pelo usários via visão, até ai entendi tudo perfeitamente.

O que gostaria de saber é: a visão também deve receber o modelo? Isto é, deve haver mesmo uma referência ao modelo dentro da visão?

Já agradeço antecipadamente por quem puder ajudar!

Abraço a todos.

Outra pergunta: qual o real papel do controlador?

Quanto mais pesquiso, mais encontro pessoas com conceitos diferentes quanto ao papel do controlador, me deixando mais confuso ainda.

Só lembrando que estou me empenhando ao máximo para aprender sobre mvc, mas nunca vi algo tão complicado de encontrar definições(até encontro algumas, mas são genéricas a tal ponto que não consigo entender).

Ficarei muito grato caso alguem possa me ajudar.

Um grande abraço a todos!

Olá pessoal, eu aqui novamente!

Em primeiro lugar, deixar claro que não eestou tentando “floodar” por aqui, tanto que agora venho agora apenas postar algo que achei ser o verdadeiro conceito sobre o controlador neste link http://www.enode.com/x/markup/tutorial/mvc.html

Já pesquisei muito aqui no fórum e realmente vi muitos feras dizerem que o Swing usa MVC, e neste artigo isso fica bem claro, um componente com os componente gráficos para receber o valor, para aumentar e decrementar esse mesmo valor, ou seja:

Visão é o próprio componente gráfico e o Modelo é atualizado (pelo Controlador) de acordo com a seta clicada na componente gráfico (aumenta ou decrementa o valor no Modelo).

Acho que agora começa a clarear a idéia aqui, já que neste mesmo artigo diz que o controlador usar listeners para saber como agir e atualizar o Modelo de acordo com entrada.

É isso mesmo ou estou falando bobagem?

Muito obrigado a todos que já participaram e aos que leem com atenção o tópico!

Um abração a todos!

Esse tutorial foi muito esclarecedor pra mim (apesar de ser de 2007). Acessa ele e vê se te ajuda.

http://www.oracle.com/technetwork/articles/javase/mvc-136693.html

No fim do tutorial você pode baixar o fonte todo e também existem alguns links para outros sites que explicam de forma
bem esclarecedora esse pattern.

Sim. A visão precisa do modelo para exibir os dados na tela (imagine, por exemplo, que o modelo represente um produto; na tela de modificar produtos - que é uma visão - é preciso ter acesso às informações deste produto).

1. Atualizar o modelo em resposta a ações na visão.

Exemplo prático: o usuário altera um dado sobre um produto e pressiona o botão OK (tudo isso na visão). O controlador é notificado e atualiza o modelo com os novos dados.

2. Opcionalmente, determinar qual nova visão deve ser mostrada.

Exemplo prático: ainda no caso da atualização do produto, se o produto foi atualizado corretamente, mostra uma informação dizendo isso. Caso haja algum problema, notifica o usuário.

A figura 2 em http://www.oracle.com/technetwork/articles/javase/mvc-136693.html#2 deixa isso bem evidente.

valmorpe:

Já pesquisei muito aqui no fórum e realmente vi muitos feras dizerem que o Swing usa MVC, e neste artigo isso fica bem claro, um componente com os componente gráficos para receber o valor, para aumentar e decrementar esse mesmo valor, ou seja:

Visão é o próprio componente gráfico e o Modelo é atualizado (pelo Controlador) de acordo com a seta clicada na componente gráfico (aumenta ou decrementa o valor no Modelo).

Boa tarde pessoal!

joyle, li o link que me passou e realmente foi muito esclarecedor, principalmente por tratar do MVC clássico e o chamado MVC2 também! Um exemplo desses é um ótimo ponto de partida, muito obrigado!

marcobiscaro2112, juntando o link que vc e joyle passaram, mais os seus esclarecimentos, agora tenho uma base sólida quanto a teoria, bastando implementar o que aprendi (alias, o que aprendi com vocês todos), já que minha principal dúvida era mesmo quanto ao controlador.

Agora vou tentar uma implementação mais simples e tentar ir colocando mais funcionalidades até ter um código enxuto.

Mas acho que vocês ainda não se viram livres de mim, talvez eu volte pra tirar mais alguma dúvida! hehe

Não tenho como agradecer tamanha ajuda que vocês, do GUJ, tem me dado nos últimos meses, mas fica aqui o meu mais sincero agradecimento.
E espero, em breve, também poder contribuir com os outros membros.

Abraços!

Olá pessoal!

Depois das dúvidas tiradas quanto a parte teórica, agora me restam algumas dúvidas quanto a implementação do con troller no mvc.

Agora já sei que o controlador deve atualizar o modelo com base nas ações do usuário na view, de acordo com a ação feita pelo usuário.

O gande problema é: como faço isso, sem o controlador receber uma referencia da view? até pode-se usar uma referencia da view no controlador, mas isso dificulta na hora de colocar uma nova view para o controlador tmb.

Tô pesquisando aqui e vendo que pode-se usar classes e interfaces para add listeners, mas ainda estou meio perdido.
Só lembrando que não quero me aproveitar de ninguem aqui, já que se trata apenas de estudos mesmo, quem quiser postar algum código para exemplificar, fico muito grato tmb, ou links para eu mesmo estudar.

Um grande abraço a todos!

No link que te passei acima tem tudo a respeito disso.
Na classe AbstractController tem um método addView() onde vc pode adicionar as suas views ao controller.

public void addView(CrudView view) { registeredViews.add(view); }

No meu caso toda view implementa a interface CrudView, por isso o parâmetro view é uma CrudView.

Leia todo o tutorial.
Baixe os fontes.
Estude a implementação.
Tire suas dúvidas.

E na interface CrudView:

import java.beans.PropertyChangeEvent;

public interface CrudView {
    /**
     * Called by the controller when it needs to pass along a property change
     * from a model. Note that the method checks each GUI parameter to determine
     * if the current value is already equal to the incoming value. If it is,
     * the method will not reset the value. This is done to prevent looping from
     * occurring when a model property is reset.
     * @param evt The property change event
     */
    public void modelPropertyChange(PropertyChangeEvent evt);
}

Olá, joyle!

Estou lendo o artigo com mais atenção (realmente ontem dei apenas uma lida por cima, peço até desculpas por isso, mas foi devido a estar no trabalho).

Já baixei o fonte e estou estudando, e fiquei com mais uma dúvidas quanto à parte teórica: o controller serve apenas para receber métodos que serão executados na sua(s) view(s) e receber a lista de listeners? isso faria que, a partir desse tipo de implementação, eu poderia criar uma app desktop com o MVC “clássico” (onde a view é atualizada pelo model), e poder usar o model e o controller dessa mesma app para uma app web, por exemplo, apenas adicionando uma nova view?
E pelo que perebi tmb, view sempre recebe uma referência ao controller, para, a partir dai, poder executar os métodos adequados do controller, conforme a interação do usuário nos componentes da view. Isso é correto?

Tenho mais algumas dúvidas em relação a essa implementação, dúvidas mais técnicas, mas espero primeiro as respostas a estas perguntas para fazê-las.

Mais uma vez lhe peço desculpas joyle, por não ter lido com mais atenção o artigo que você postou, como já lhe disse, foi por falta de tempo ontem mesmo.

Muito obrigado pela sua ajuda, não imagina o quanto ela é importante pra mim!
Abraços!

Resposta:

Como você ainda está com muita dúvida na parte teórica, procure mais sobre o assunto.
O link abaixo já foi passado e tem o assunto bem discutido.
http://www.guj.com.br/java/129277-perguntas-sobre-mvc-desktop-existe-solucao–mvpmvc-webobserver-e-exceptions
Estude mais também sobre OO (Orientação a Objetos), no inicio é meio difícil mesmo, mas depois você vai entendendo como tudo funciona.
Dá uma olhada nas apostilas da Caelum, são excelentes apostilas pra se estudar.

Faça o contrário. Faça a visão receber o controlador. Nesse caso, por exemplo, quando o usuário pressionar o botão “Atualizar” a visão chama o método para atualizar no controlador.

Assim o mesmo controlador pode estar em várias visões. A desvantagem é que a visão está acoplada ao controlador (o que, em geral, não representa um problema).

Visão acoplada à Visão :?:

Faça o contrário. Faça a visão receber o controlador. Nesse caso, por exemplo, quando o usuário pressionar o botão “Atualizar” a visão chama o método para atualizar no controlador.

Assim o mesmo controlador pode estar em várias visões. A desvantagem é que a visão está bastante acoplada à visão (o que, em geral, não representa um problema).

acho q vc quis dizer o controller ligado a visão certo?
acho q não fica aclopado
pois a view só conhecera o controller pela api

ou seja

não importa as chamadas pq a implementação a visão não sabe como é
ela só sabe os ingredientes, a eu sei q pra consultar um usuario, eu preciso dos dados, mas eu nao sei como consultar, mas o controller sabe

e assim por diante
meu ponto de vista

Se você for seguir a implementação do link que te passei, adicione as views ao controller também!

Na classe AbstractController há um método chamado propertyChange(PropertyChangeEvent evt) que implementa a interface PropertyChangeListener.
Esse método é utilizado para notificar suas views sempre que há uma alteração no model, que notifica o controller.

Visão acoplada à Visão :?:
Sorry, a visão fica acoplada ao controlador. Já corrigi ali em cima.

Olá pessoal, desculpem a demora em responder, correria de sempre, hehe.

Novamente muito obrigado pela colaboração de todos, é admirável a solidariedade do pessoal desse forum!

marcobiscaro2112 , estou seriamente pensando em fazer isso, só acho que fica um pouco fora do esquema que o joyle postou lá em cima, com a imagem (já que não há chamadas de métodos diretamente da view para o controller), porém, concordo com vc que isso parece não acarretar problemas, acho interessante começar dessa forma, e ir estudando mais, como o próprio joyle me indicou.

joyle, quanto ao model utilizei minha própria implementação do pattern observer, acho que ficou até bacana pra um iniciante (mas qualquer critica é sempre muito bem vinda!). Estou aqui tentando aprender com feras como vcs mesmo!

Muito obrigado e um grande abraço a todos!

No link que te passei anteriormente com o exemplo, funciona praticamente da maneira que o marcobiscaro2112 citou, todas as views recebem uma referência do controller, isso caso vc queira que essa view notifique o controller de mudanças! Assim vc vai também adicionando ao controller suas views para que elas possam ser notificadas quanto ocorrer alguma mudança no seu model. Lembrando que a notificação acontece na implementação do método modelPropertyChange(PropertyChangeEvent evt).

joyle, quanto ao model utilizei minha própria implementação do pattern observer, acho que ficou até bacana pra um iniciante (mas qualquer critica é sempre muito bem vinda!). Estou aqui tentando aprender com feras como vcs mesmo!
Muito obrigado e um grande abraço a todos!

De fato, eu não sei lhe dizer o correto a respeito disso, mas verifique sobre o assunto para ter maior segurança na sua implementação.

Olá joyle,

Quanto ao pattern Observer, não utilizei Observable da java.util não. Os nomes estão iguais, mas criei duas interfaces (tanto para Observer quanto para Observable) com os mesmo nomes, sendo que cada view e model implementam essas interfaces, e o próprio model é quem notifica a view sobre as suas mudanças de estado para view se atualizar (um esquema bem parecido com o Observer do java, talvez por isso você tenha confundido).
O ruim de se utilizar Observable é que mata a única herança disponível em java.

Quanto ao link que me passou, é show e bola! mas quanto a essa parte do controller atualizar a view, isso funciona bem pra app web, conforme o próprio artigo diz, estou implementando o MVC “original”, da SmallTalk.
Mas com certeza o artigo ajudou bastante, já que eu não sabia se era correto ter ref do controller na view, o que já clareou bem o caminho.
No entanto, ainda estou estudando mais para tentar desacoplar um pouco a view do conroller (se é que isso é possivel).

Vou terminar o controller aqui e continuar com as pesquisas, depois volto a postar por aqui.

Muito obrigado pela ajuda, e volto em breve na busca por novas soluções, hehe …
Um gande abraço e ótimo 2011 a todos!