AMULET Automatic Manufacture of Usable and

Learnable Editors and Toolkits

Maria Alice G. V. FerreiraVer. 2003

Características Novo modelo para desenvolvimento de interfaces

• Brad Myers - Carnegie Mellon University• paradigma da orientação a objetos - C++• Plataformas: X11 - Windows 95 - Windows NT• propõe desenho, prototipação, implementação e avaliação de

interfaces• novos modelos:

– para os objetos– restrições– animação– entrada e saída– comandos– UNDO

Características

Arquitetura: aberta• permite a investigação de novas soluções• Ex: “constraints solvers” múltiplos• Widgets modificáveis

Fornecer suporte de alto nível para os “insides” dos programas

• “inside” - conteúdo dos programas. Ex: parte de desenho, como em CADs, sistemas de visualização, editores gráficos, etc

“Application framework”• sistema que permite implementar partes dos aplicativos e não

somente a interface

Características

Suporte:• “redesenho” automático• restrições entre widgets• funcionamento interativo facilitado • comandos de edição, tipo “cut”, “paste”, etc

objetos de interface estão disponíveis em tempo de execução, podendo ser manipulados interativa-mente

EXEMPLO Outros toolkits:

• menus• barras de ferramentas

AMULET • permite implementar o circuito com suas res- trições e compromissos

Destina-se a aplicações de natureza gráfica, principalmente. Usuários potenciais: estudantes, pesquisadores e desenvolvedores

Conceitos básicos

tudo é representado como objeto Utiliza-se de um sistema de objetos denominado

“prototype-instance” nenhuma distinção entre classe e instância (no topo de C++), portanto uma instância pode ser utilizada como protótipo para outras instâncias (objetos)

Objetos possuem “slots” (atributos), porém podem ser criados em tempo de execução (dinâmicos), tipos podem ser atribuídos dinamicamente a estes slots, que podem conter dados ou métodos

Herança é permitida dinamicamente, se o objeto tiver um valor para o “slot”

Criação de objetos• por instanciação - herda “slots”, que podem ser “setados” com

novos valores• por cópia - todos os “slots’ têm os valores copiados• EX: Am_Bitmap objeto de biblioteca Amulet

– and_bitmap_image imagem adequada

Conceitos básicos

Um programa - Hello World!

Padrão já visto em outros sistemas, como VB, SUIT, Motif etc

Interactors O objeto interactor permite que cada objeto responda de forma

conveniente às entradas. Existem alguns tipos de Interactors permitidos. Move Grow é um destes tipos e permite a movimentação e redimensionamento dos objetos:

new_gate.Add_Part(Am_Move_Grow_Interactor.Create());

Am_Move_Grow_Interactor permite as ações de mover e redimensionar o objeto ao qual é adicionado através de Add_Part; por default, funciona com o botão esquerdo do mouse, porém isto pode ser alterado. Em outras palavras, Add_Part adiciona uma nova funcionalidade ao objeto new_gate, criado em uma das transparências anteriores.

Para cada plataforma, cada objeto mantém o “look and feel” conveniente, automaticamente.

“Command objects” Para executar comandos do aplicativo, alocam-se

instâncias de “Command objects”; estes possuem métodos especificados nos slots Am_DO_METHOD

“Command objects” possuem slots para métodos de Undoing, Redoing, Help, Repeating, Enabling e Disabling

Existem “Command objects” de biblioteca, que podem ser usados pelos programas

“Command objects”

Ex:Am_Object my_button = Am_Button.Create(). Add_Part(Am_COMMAND,

Am_Quit_Command.Create() .Set(Am_LABEL,”Goodbye, World!”))));

Compromissos (“Constraints”)

Compromissos

Declarados pelo usuário e mantidos pelo sistema Formula constraints - similar às das planilhas, e

descritas em C++. Definem procedimentos a serem executados pela fórmula

Ex:// define uma fórmula denominada right_of_tool_panel_formula// que retorna uma valor inteiro Am_Define_Formula(int, right_of_tool_panel_formula){ return (int)tool_panel.Get(Am_LEFT) + (int)tool_panel.Get(Am_WIDTH) + 5;

Reconhecimento de gestos

Agate - uma ferramenta interativa que permite este reconhecimento, através do fornecimento de amostras de gestos pelo usuário, e que são associadas a um nome (cadeia de caracteres)

Os nomes são associados com as operações Exemplo: gestos associados à interface de circuitos

apresentada (criação de “gates”)

Reconhe-cimento de

gestos

Interface de Agate(treinamento)

Animação

Animações são criadas com auxílio do sistema de compromissos do Amulet

Quando um compromisso de animação é ligado a um slot e o slot altera o seu valor, o novo valor é removido do slot, este recebe o antigo valor e então, de forma suave, novos valores interpolados entre o valor antigo e o novo são colocados no slot; lembrar que ao ser alterado o valor de um slot, todo o sistema é redesenhado.

Exemplo: Mover os números 0 e 1 entre os gates do circuito.

Animação

Arquitetura

Novo Modelo para objetos ORE - Object Registering and Encoding - nível do

Amulet que implementa o sistema de protótipos e intâncias de objetos (“prototype-instance object system”) no topo da linguagem C++

Objetivos: adquirir um nível mais dinâmico de manipulação dos objetos (manipulação em tempo de execução), poder obter em tempo de execução informação completa sobre os objetos e poder sobrepor métodos de objetos em tempo de execução.

No modelo de protótipos e instâncias dos objetos não existe distinção entre classe e instância; toda instância pode ser usada como protótipo para a geração de novas instâncias

“Slots” - podem conter atributos ou métodos

Instanciação de objetos: os objetos podem ser instanciados ou copiados. Os objetos instanciados herdam todos os “slots” do protótipo; se estes “slots” forem alterados no protótipo, todos os ob-jetos instanciados são alterados também e, se hou-ver alteração de aspecto gráfico, a tela é redese-nhada. Os objetos instanciados que tiverem seus valores redefinidos não são alterados, quando os “slots” do protótipo são alterados.

No caso dos objetos copiados a alteração dos “slots” do protótipo não altera os objetos copiados. Este segundo modelo permite uma alternativa ao modelo de instanciação.

Classes e objetos

As instâncias podem ter os valores “default” (os do protótipo) redefinidos através de comandos Set

Am_Object new_obj = zero_one_proto.Create( ) .Set(Am_LEFT,new_obj_left) .Set(Am_TOP,new_obj_top);//comando instanciação

new_obj . Set (Am_LEFT,40); redefinição dos comandos

new_obj . Set (Am_TEXT,“Hello!”);

os “slots” podem ser excluídos ou adicionados aos objetos em tempo de execução.

os valores dos “slots” podem ser alterados em tempo de execução. os tipos de dados contidos nos “slots” podem ser alterados dinamicamente. Para

isso, todo um mecanismo que execute a alteração destes tipos foi implementado.

“Wrapper” - uma classe que permite manipular os tipos

de dados do C++, em tempo de execução. Esta classe deve ser usada quando se deseja armazenar algum dado em um “slot” que tenha seu tipo verificado pela linguagem.

Am_Object Set (Am_Slot_Key key, Am_Wrapper* value);Am_Object Set (Am_Slot_Key key, void* value);Am_Object Set (Am_Slot_Key key, int value);Am_Object Set (Am_Slot_Key key, float value);

Um “slot” contendo dados pode ser sobreposto por um método, em qualquer instante.

Amulet utiliza um procedimento especial para o mecanismo que nos demais UIMS é manipulado via “callback”, o Am_DO_METHOD.

Am_Define_Method - macro que cria um novo método que tem o tipo do primeiro parâmetro (Am_Object_Method). Este método chama uma função que retorna o tipo do segundo parâmetro (void); a função tem o nome do terceiro parâmetro (clear_selection). O quarto parâmetro especifica a lista de parâmetros, a serem utilizados pelo método

Am_Define_Method (Am_Object_Method, void, clear_selection, (Am_Object /*cmd*/)) { y_selection . Set (Am_VALUE, NULL);

Para se colocar a especificação do método no “slot” conveniente utiliza-se o método Get_Part

tool_panel . Get_Part (AM_COMMAND) . Set (Am_DO_METHOD, clear_selection);

Hierarquia “Part-Owner” “Owner” - grupo de objetos ou objetos associados

a uma janela “Part” - outros grupos ou primitivos como linhas,

textos ou retângulos Hieraquia “Part-Owner” - é uma hierarquia estru-

tural, que permite herança estrutural

Interactors “Interactor” - um objeto que pode ser ligado às

entradas do sistema, para que um objeto gráfico responda a essas entradas.

O “interactor” - por default - inicia sua operação ao ser pressionado o botão esquerdo do mouse, porém este default pode ser alterado.

O “interactor” fornece feedback ao usuário (através de movimentação, redimensionamento dos objetos ou através de caixas de diálogo convenientes).

O “interactor” pode ter seu funcionamento abortado através de chaves apropriadas ou através de chamada, pelo programa, de um método que realiza esta tarefa.

Ao se abortar uma interação, restaura-se o estado do

programa. Quando a interação se encerra normalmente, o feedback

é encerrado, e um objeto de comando é atribuído ao sistema

“Interactors” possuem vários parâmetros, o que permite alto grau de variação de funcionamento (início, fim, abortamento da interação, tipo de feedback, etc)

Existem 6 tipos diferentes de “interactors” Um mesmo “interactor” pode operar sobre um conjunto

de objetos. Ex: move_grow_interactor, ligado a uma janela, opera sobre todos os objetos na janela

“Interactors”- Choice Interactor Escolhe um objeto dentro de um conjunto de

objetos. O usuário move o mouse sobre o conjunto de objetos até encontrar o item desejado. Pode ser usado, também, para a seleção entre itens de menu ou botões de comandos. Permite a selação de um único item (um item de um menu) ou de múltiplos itens (vários arquivos a serem copiados de um diretório).

“Interactors” - Disparo e Move-Grow

Disparo - É utilizado quando se deseja que alguma coisa ocorra logo após o disparo, como por exemplo a digitação de uma tecla, um click do mouse, etc.

Move-Grow - É utilizado para movimentar ou alterar o tamanho de um objeto, como: atividades de “dragging” numa “scroll-bar”, operações de edição de um objeto, etc

“Interactors”: New Points, Text e Reconhecimento de Gestos

New Points - permite que se introduza pontos que podem indicar a posição de novos objetos

Text Edit - permite a introdução de texto nas formas padrões e permite tabelas de tradução e comandos de edição

Reconhecimento de Gestos - Gestos são definidos através de exemplificação e o sistema utiliza o reconhecedor denominado Agate

“Interactors” são ligados aos objetos que devem sofrer interação

Um “interactor” pode ser ligado a um conjunto de objetos

// permite a movimentação de my_object com a pressão do botão // esquerdo do mouse

my_object . Add_Part (A_Move_Grow_Interactor . Create()); // permite que qualquer parte de my_group tenha tamanho // alterado, com pressão do botão direito do mouse my_group. Add_Part (A_Move_Grow_Interactor . Create() .Set (Am_GROWING, true) .Set (Am_START_EVENT, “RIGHT_DOWN”));

Referências Bibliográficas

Links: http://www-2.cs.cmu.edu/~amulet/

permite a obtenção de todo material bibliográfico a respeito, bem como de novos projetos

Figuras: http

://www-2.cs.cmu.edu/afs/cs/project/amulet/www/amulet-all-pictures.html