/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package desenho;
import controlador.Editor;
import controlador.Diagrama;
import controlador.inspector.InspectorProperty;
import desenho.formas.Forma;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
*
* @author Rick
*/
public class FormaElementar extends Elementar {
private static final long serialVersionUID = -1032848572397943975L;
// <editor-fold defaultstate="collapsed" desc="Criação">
/**
* Futuro
*/
public FormaElementar() {
}
public FormaElementar(FormaElementar pai) {
super(pai);
ID = pai.getMaster().getElementarID();
}
public FormaElementar(Diagrama master) {
ID = master.getElementarID();
// ancorasCode.add(Ancorador.CODE_ANCORAR);
// ancorasCode.add(Ancorador.CODE_DEL);
InitElementar(master);
}
protected void InitializeSubItens(Diagrama criador) {
SetFontAndBackColorFromModelo();
this.subItens = new ArrayList<>();
}
private void InitElementar(Diagrama master) {
setMaster(master);
if (getMaster() != null) {
getMaster().Add(this);
InitializeSubItens(master);
}
this.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
}
// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="Campos">
private List<Elementar> subItens = null;
//private boolean nulo = false;
//private boolean atualizando = false;
private boolean selecionado = false;
protected boolean PontosIsHide = false;
protected boolean Selecionavel = true;
protected int ID = -1;
private boolean raiseMuda = true;
/**
* Poderá ser utilizado para dizer quais objetos podem ou não ser ajustados por comandos na iterface - alinhamento.
*/
protected boolean AceitaAjusteAutmatico = true;
public boolean isRaiseMuda() {
return raiseMuda;
}
public void setRaiseMuda(boolean raiseMuda) {
this.raiseMuda = raiseMuda;
}
protected void setID(int ID) {
this.ID = ID;
}
public int getID() {
return ID;
}
public boolean isSelecionavel() {
return Selecionavel;
}
public void setSelecionavel(boolean Selecionavel) {
this.Selecionavel = Selecionavel;
}
public boolean isPontosIsHide() {
return PontosIsHide;
}
protected void setPontosIsHide(boolean PontosIsHide) {
this.PontosIsHide = PontosIsHide;
}
// public boolean isAtualizando() {
// return atualizando;
// }
// public void setAtualizando(boolean atualizando) {
// this.atualizando = atualizando;
// }
// public boolean isNulo() {
// return nulo;
// }
// public void setNulo(boolean nulo) {
// this.nulo = nulo;
// }
public boolean isSelecionado() {
return selecionado;
}
public void setSelecionado(boolean selecionado) {
this.selecionado = selecionado;
}
public void setSubItens(ArrayList<Elementar> subItens) {
this.subItens = subItens;
}
public List<Elementar> getSubItens() {
return subItens;
}
/**
* Define se o objeto ficará fixo no diagrama
*/
private boolean ancorado = false;
public boolean isAncorado() {
return ancorado;
}
public void setAncorado(boolean ancorado) {
if (this.ancorado == ancorado) {
return;
}
this.ancorado = ancorado;
//InvalidateArea();
}
// </editor-fold>
/**
* Roda por meio de um comando disparado pelo inspector.
*
* @param Tag
*/
public void DoAnyThing(int Tag) {
}
/**
* Quais cores o objeto usa. Serve para o objeto legenda capturar as cores e mostrar.
*
* @param cores
*/
public void PoluleColors(ArrayList<Color> cores) {
if (cores.indexOf(getForeColor()) == -1) {
cores.add(getForeColor());
}
if (cores.indexOf(getBackColor()) == -1) {
cores.add(getBackColor());
}
}
/**
* Em ordem de criação --> os sub componetes (independente de ser tratado como subitem.
*
* @param i: index
* @return
*/
public FormaElementar getSub(int i) {
return null;
}
/**
* Caso mova-se o mouse sobre o objeto
*
* @param b: está sobre?
*/
public void setOverMe(boolean b) {
}
// Versao 3.2
/**
* No Tree de navegação, quando seleciona o subitem de um artefato.
* @param index
*/
public void DoSubItemSel(int index) {
}
public enum nomeComandos {
cmdNothing, cmdLoadImg, cmdDlgLegenda, cmdCallDrawerEditor, cmdExcluirSubItem,
cmdAdicionarSubItem, cmdDoAnyThing, cmdFonte
}
/**
* Distância entre a borda de um FomraElementar.
*/
public final int distSelecao = 2;
public void HidePontos(boolean esconde) {
setPontosIsHide(esconde);
}
public void DoPontoCor(boolean verde) {
}
public boolean IntersectPath(Rectangle recsel) {
return recsel.intersects(getBounds());
}
public void RemoveSubItem(Elementar si) {
si.Destroy();
subItens.remove(si);
}
@Override
public Elementar IsMeOrMine(Point p) {
Elementar res;
for (Elementar el : subItens) {
res = el.IsMeOrMine(p);
if (res != null) {
return res;
}
}
return super.IsMeOrMine(p);
}
@Override
public Elementar IsMeOrMine(Point p, Elementar nor) {
Elementar res;
for (Elementar el : subItens) {
res = el.IsMeOrMine(p, nor);
if (res != null) {
return res;
}
}
return super.IsMeOrMine(p, nor);
}
@Override
public Elementar IsMeOrMineBase(Point p, Elementar nor) {
Elementar res;
for (Elementar el : subItens) {
res = el.IsMeOrMineBase(p, nor);
if (res != null && res instanceof Forma) {
return res;
}
}
return super.IsMeOrMineBase(p, nor);
}
@Override
public void DoPaint(Graphics2D g) {
super.DoPaint(g);
if (isVisible()) {
PinteSelecao(g);
//paintAncora(g);
for (int i = subItens.size() - 1; i > -1; i--) {
if (subItens.get(i).CanPaint()) {
subItens.get(i).DoPaint(g);
}
}
}
}
// public void paintAncora(Graphics2D g) {
// }
/**
* Rearranja o componente de acordao com a posição dos pontos que o circunda quando selecionado.
*/
public void reSetBounds() {
}
//public void Recalcule() {
//}
/**
* Rearranja o componente de acordo com a posição dos pontos que o circunda quando selecionado.
*
* @param posicao Em qual das oito posições possíveis (0-7) está o ponto movimentado.
* @param xleft Qual o novo Left do Ponto
* @param ytop Qual o novo Top do Ponto
*/
public void reSetBounds(int posicao, int xleft, int ytop) {
}
public void PinteSelecao(Graphics2D g) {
}
public void DoRaizeReenquadreReposicione() {
}
// <editor-fold defaultstate="collapsed" desc="Mouse">
transient Point down = new Point(0, 0);
private transient Point inidown = new Point(0, 0);
protected Point getIniDown() {
return inidown;
}
transient boolean isMouseDown = false;
@Override
public void mousePressed(MouseEvent e) {
super.mousePressed(e);
isMouseDown = true && !isAncorado();
down = new Point(e.getX(), e.getY());
inidown = new Point(e.getX(), e.getY());
}
@Override
public void mouseReleased(MouseEvent e) {
isMouseDown = false;
DoRaizeReenquadreReposicione();
if (isPontosIsHide()) {
getMaster().HidePontosOnSelecao(false);
}
Point enddown = new Point(e.getX(), e.getY());
if (!enddown.equals(inidown)) {
DoMuda();
}
super.mouseReleased(e);
}
@Override
public void mouseDragged(MouseEvent e) {
if (!isPontosIsHide()) {
getMaster().HidePontosOnSelecao(true);
}
super.mouseDragged(e);
int X = e.getX();
int Y = e.getY();
if (isMouseDown) {
int movX = X - down.x;
int movY = Y - down.y;
if ((movX != 0) || (movY != 0)) {
DoRaiseMove(movX, movY);
down.setLocation(e.getPoint());
}
}
}
@Override
public void mouseDblClicked(MouseEvent e) {
super.mouseDblClicked(e);
ProcessaDblClick(e);
}
// </editor-fold>
@Override
public void Reposicione() {
super.Reposicione();
}
public void DoRaiseMove(int movX, int movY) {
DoMove(movX, movY);
}
/**
* Métdo responsável por receber cliques de subItens
*
* @param sender disparador do médoto
* @param dbl o clique é duplo
* @param e Mouse.
*/
public void ReciveClick(Elementar sender, boolean dbl, MouseEvent e) {
//////fazer linha quadrada.
}
/**
* Métdo responsável por lançar o MouseDblClick sem a necessidade de usar o método principal. Padrão próprio: evitar reescrever ou mexer nos métodos principais.
*
* @param dbl o clique é duplo
* @param e Mouse.
*/
protected void ProcessaDblClick(MouseEvent e) {
}
//<editor-fold defaultstate="collapsed" desc="Tratamento da propriedade">
/**
* Carrega as propriedades para o Inspector, veja GenerateFullProperty (FormaElementar)
*
* @return
*/
public ArrayList<InspectorProperty> GenerateProperty() {
ArrayList<InspectorProperty> res = new ArrayList<>();
if (getMaster().getEditor().isMostrarIDs()) {
res.add(InspectorProperty.PropertyFactoryApenasLeituraTexto("id", Integer.toString(ID)));
}
res.add(InspectorProperty.PropertyFactorySeparador("dimensoes", true));
res.add(InspectorProperty.PropertyFactoryNumero("left", "setLeft", getLeft()));
res.add(InspectorProperty.PropertyFactoryNumero("top", "setTop", getTop()));
res.add(InspectorProperty.PropertyFactoryNumero("width", "setWidth", getWidth()));
res.add(InspectorProperty.PropertyFactoryNumero("height", "setHeight", getHeight()));
return res;
}
/**
* Propriedadaes adicionadas em tempo de execução! Não sei se será implementado!
*/
protected ArrayList<InspectorProperty> propriedadesAdicinais = null;
/**
* Método principal para carregar as propriedades de um objeto para o Inspector (FormaElementar)
*
* @return
*/
public ArrayList<InspectorProperty> GenerateFullProperty() {
ArrayList<InspectorProperty> res = GenerateProperty();
if (propriedadesAdicinais != null) {
res.addAll(propriedadesAdicinais);
}
return CompleteGenerateProperty(res);
}
/**
* É executado após o método GenerateProperty, veja em GenerateFullProperty (FormaElementar)
*
* @param GP
* @return
*/
public ArrayList<InspectorProperty> CompleteGenerateProperty(ArrayList<InspectorProperty> GP) {
return GP;
}
//</editor-fold>
@Override
public void DoMuda() {
if (!isRaiseMuda()) {
return;
}
super.DoMuda();
if (getMaster() != null) {
getMaster().DoMuda(this);
} else if (getCriador() != null) {
getCriador().DoMuda();
}
}
/**
* Este objeto pode ser carregdo no InfoDiagrama_LoadFromXML ?
*
* @return
*/
public boolean getIsLoadedFromXML() {
return true;
}
/**
* Variavel de apoio para salvar em XML a condição de isDisablePainted(). Necessária porque, de outra forma, as cores persistidas seriam apenas a cor configurada para a condição de DisablePainted quando true.
*/
private boolean snDisablePainted = false;
/**
* Para que possa ser utilizado por softwares de terceiros e de diferentes linguagens, preferi este modelo ao de persistir o objeto em XLM usando o writer do próprio java.
*
* @param doc
* @param root
*/
public final void ToXlm(Document doc, Element root) {
snDisablePainted = isDisablePainted();
setDisablePainted(false); //# agora as cores serão salvas da meneira correta!
Element me = doc.createElement(Editor.getClassTexto(this));
ToXmlAtributos(doc, me);
ToXmlValores(doc, me);
root.appendChild(me);
setDisablePainted(snDisablePainted);
}
/**
* Serializa o ID dos objetos que estiverem ligados.
*
* @param doc
* @param me
*/
protected void SerializeListener(Document doc, Element me) {
Element lst = doc.createElement("Listener");
if (getListeners() != null) {
for (ElementarListener el : getListeners()) {
if (el instanceof FormaElementar) {
FormaElementar fe = (FormaElementar) el;
lst.appendChild(util.XMLGenerate.ValorRefFormElementar(doc, Editor.getClassTexto(fe), fe));
}
}
}
me.appendChild(lst);
}
/**
* Refaz as ligações. Deve ser chamado no método CommitXML. Quando a ligação entre dois objetos passa por um objeto SuperLinha, não é necessário serializar as ligações. Os métodos
* SerializeListener e UnSerializeListener devem ser usados para persistir as ligações entre dois objetos. Ex: FormaArea e os artefatos capturados.
*
* @param me
* @param mapa
*/
protected void UnSerializeListener(Element me, HashMap<Element, FormaElementar> mapa) {
Element lig = util.XMLGenerate.FindByNodeName(me, "Listener");
NodeList nodeLst = lig.getChildNodes();
for (int s = 0; s < nodeLst.getLength(); s++) {
Node fstNode = nodeLst.item(s);
if (fstNode.getNodeType() == Node.ELEMENT_NODE) {
Element fstElmnt = (Element) fstNode;
String xid = fstElmnt.getAttribute("ID");
FormaElementar resA = util.XMLGenerate.FindWhoHasID(xid, mapa);
if (resA == null) {
continue;
}
PerformLigacao(resA, true);
}
}
}
/**
* Dado um objeto, este método gera XLM para sua propriedades a partir de campos determinados
*
* @param doc
* @param me
*/
protected void ToXmlValores(Document doc, Element me) {
me.appendChild(util.XMLGenerate.ValorRect(doc, "Bounds", getBounds()));
me.appendChild(util.XMLGenerate.ValorBoolean(doc, "DisablePainted", snDisablePainted));
}
/**
* Serializa os atributos do objeto.
*
* @param doc
* @param me
*/
protected void ToXmlAtributos(Document doc, Element me) {
me.setAttribute("ID", Integer.toString(ID));
}
/**
* Carrega um elemento a partir de um código XML.
*
* @param me
* @param colando
* @return
*/
public boolean LoadFromXML(Element me, boolean colando) {
String aID = me.getAttribute("ID");
if (!colando) {
ID = Integer.valueOf(aID);
}
Rectangle bounds = util.XMLGenerate.getValorRectFrom(me, "Bounds");
if (bounds != null) {
/**
* Referencia igual em Ligacao.LoadFromXML
*/
SetBounds(bounds);
}
boolean x = util.XMLGenerate.getValorBooleanFrom(me, "DisablePainted");
SetDisablePainted(x);
return true;
}
/**
* É executado após o carregamento do XML (quer colando, quer carregando de uma arquivo).
*
* @param me
* @param mapa
* @return
*/
public boolean CommitXML(Element me, HashMap<Element, FormaElementar> mapa) {
reSetBounds();
BringToFront();
return true;
}
/**
* Dado um objeto que não pode ser apagado por conta de uma dependência, o método AskToDelete pede para que a dependência seja desfeita (caso em que importará o retorno do método: true = a
* dependência foi desfeita), ou que o objeto providencie a sua auto-exclusão, caso em que o retorno seria irrelevante
*
* @return
*/
public boolean AskToDelete() {
return false;
}
/**
* Para ser executado pelo Inspector.
*
* @param idx: tag ou índice do componente a ser removido.
*/
public void ExcluirSubItem(int idx) {
}
/**
* Para ser executado pelo Inspector.
*
* @param idx: posição onde o subitem será incluído.
*/
public void AdicionarSubItem(int idx) {
}
//<editor-fold defaultstate="collapsed" desc="Ancorador">
// /**
// * Quais botões âncoras (botões que ficam ao lado do artefato selecionado no diagrama) deverão ser mostrados.
// */
// private final ArrayList<Integer> ancorasCode = new ArrayList<>();
/**
* Quais botões âncoras (botões que ficam ao lado do artefato selecionado no diagrama) deverão ser mostrados.
*
* @return
*/
public ArrayList<Integer> getAncorasCode() {
Integer[] ancorasCode = new Integer[] {Ancorador.CODE_ANCORAR, Ancorador.CODE_DEL};
return new ArrayList<>(Arrays.asList(ancorasCode));
}
/**
* *
* É chamado quando clica-se em um dos botões ancorados no artefato selecionado
*
* @param cod
*/
public void runAncorasCode(int cod) {
switch (cod) {
case Ancorador.CODE_ANCORAR:
setAncorado(!isAncorado());
InvalidateArea();
getMaster().PerformInspector();
break;
case Ancorador.CODE_DEL:
getMaster().ClearSelect();
getMaster().setSelecionado(this);
getMaster().deleteSelecao();
break;
}
}
/**
* *
* É chamado quando um artefato é selecionado no diagrama
*
* @param c - diz o que desenhar para cada um dos botões de ancoragem.
* @return o caminho para desenho da imagem: getMaster().getEditor().getControler().ImagemDeDiagrama.get( RETURN ).getImage()
*/
public String WhatDrawOnAcorador(Integer c) {
String res = "diagrama.ancordor.0.img";
switch (c) {
case Ancorador.CODE_ANCORAR:
res = isAncorado() ? "diagrama.ancordor.0.0.img" : "diagrama.ancordor.0.img";
break;
case Ancorador.CODE_DEL:
res = isAncorado() ? "diagrama.ancordor.1.img" : "diagrama.ancordor.1.img";
break;
}
return res;
}
//</editor-fold>
}
