AMULET
Automatic Manufacture of Usable and
Learnable Editors and Toolkits
Maria Alice G. V. Ferreira
Ver. 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 interativamente
EXEMPLO
Outros toolkits:
• menus
• barras de ferramentas
AMULET
• permite implementar o
circuito com suas restriçõ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”
Conceitos básicos
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
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”)
Reconhecimento 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 objetos instanciados são alterados também e, se houver alteração de aspecto gráfico, a tela é redesenhada. 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
Am_Object
Am_Object
Am_Object
Set (Am_Slot_Key key, Am_Wrapper* value);
Set (Am_Slot_Key key, void* value);
Set (Am_Slot_Key key, int value);
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 estrutural, 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 MoveGrow
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://www2.cs.cmu.edu/afs/cs/project/amulet/www/amuletall-pictures.html