1304 lines
45 KiB
Java
1304 lines
45 KiB
Java
//This file is part of SECONDO.
|
|
|
|
//Copyright (C) 2004, University in Hagen, Department of Computer Science,
|
|
//Database Systems for New Applications.
|
|
|
|
//SECONDO is free software; you can redistribute it and/or modify
|
|
//it under the terms of the GNU General Public License as published by
|
|
//the Free Software Foundation; either version 2 of the License, or
|
|
//(at your option) any later version.
|
|
|
|
//SECONDO is distributed in the hope that it will be useful,
|
|
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
//GNU General Public License for more details.
|
|
|
|
//You should have received a copy of the GNU General Public License
|
|
//along with SECONDO; if not, write to the Free Software
|
|
//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
package viewer.hoese;
|
|
|
|
import java.util.*;
|
|
import javax.swing.*;
|
|
import sj.lang.ListExpr;
|
|
import java.awt.*;
|
|
import javax.swing.border.*;
|
|
import java.awt.geom.*;
|
|
import java.io.*;
|
|
import java.awt.image.*;
|
|
import java.awt.event.*;
|
|
import javax.swing.event.*;
|
|
import viewer.HoeseViewer;
|
|
import tools.Reporter;
|
|
|
|
/**
|
|
* The objects in a query result had no category in the beginning. This dialog offers the
|
|
* ability to associate single graphical objects or whole quries. A label attribute can be
|
|
* selected. An attribute can be chosen for attribute dependant rendering.The top is made
|
|
* up by the InfoPanel, followed by the Ref or NavPanel (reference depending mode or single
|
|
* tupel mode.The buttonPanel is the bottommost region in this dialog.
|
|
* @author hoese
|
|
* @version
|
|
*/
|
|
public class ViewConfig extends javax.swing.JDialog {
|
|
/** Application's main window */
|
|
HoeseViewer mw;
|
|
/** Two lists storing possible reference-attr. and label-attr. */
|
|
Vector RefAList, RefMList, LabelAList;
|
|
/** The actual query result */
|
|
QueryResult Query;
|
|
/** The no. of attributes in a tupel */
|
|
int AttrCount = 0;
|
|
/** The no. of tupel in the query */
|
|
int TupelCount = 1;
|
|
/** The actual tupel in single tupel modus */
|
|
int AktTupNr = 1;
|
|
/** The four JPanels the dialog is devided in.*/
|
|
JPanel InfoPanel, NavPanel, RefPanel, ButPanel;
|
|
/** actual graph. attribute-name */
|
|
String AttrName;
|
|
/** /** The actual graph. object in single tupel modus */
|
|
DsplGraph AktGO;
|
|
|
|
ListExpr AttrValues;
|
|
static LinkAttrCat LAC=null;
|
|
|
|
static String RENDER_WHITE_BLACK="white -> black";
|
|
static String RENDER_WHITE_RED ="white -> red";
|
|
static String RENDER_WHITE_BLUE ="white -> blue";
|
|
static String RENDER_WHITE_GREEN="white -> green";
|
|
static String RENDER_GREEN_RED ="green -> red";
|
|
static String RENDER_RED_GREEN ="red -> green";
|
|
static String RENDER_GREEN_BROWN ="green -> brown";
|
|
static String RENDER_BLUE_RED ="blue -> red";
|
|
static String RENDER_BLUE_GREEN ="blue -> green";
|
|
static String RENDER_RANDOM_COLOR = "random color";
|
|
|
|
|
|
static String RENDER_LINE_WHITE_BLACK="white -> black (border)";
|
|
static String RENDER_LINE_WHITE_RED ="white -> red (border)";
|
|
static String RENDER_LINE_WHITE_BLUE ="white -> blue (border)";
|
|
static String RENDER_LINE_WHITE_GREEN="white -> green (border)";
|
|
static String RENDER_LINE_GREEN_RED ="green -> red (border)";
|
|
static String RENDER_LINE_RED_GREEN ="red -> green (border)";
|
|
static String RENDER_LINE_BLUE_RED ="blue -> red (border)";
|
|
static String RENDER_LINE_BLUE_GREEN ="blue -> green (border)";
|
|
|
|
static String RENDER_POINTSIZE ="pointsize";
|
|
static String RENDER_LINEWIDTH ="linewidth";
|
|
|
|
/** Creates new JDialog ViewConfig with the attribute-name an
|
|
*/
|
|
public ViewConfig (HoeseViewer parent, String an) {
|
|
super(parent.getMainFrame(), true);
|
|
|
|
try{
|
|
RenderAttributeClass = Class.forName("viewer.hoese.RenderAttribute");
|
|
}catch(Exception e){
|
|
Reporter.writeError("fatal error : class RenderAttribute not found ");
|
|
}
|
|
|
|
|
|
setTitle("Set Representation of GraphObjects");
|
|
mw = parent;
|
|
if(LAC==null)
|
|
LAC = new LinkAttrCat(mw);
|
|
AttrName = an;
|
|
JComboBox cb = mw.TextDisplay.getQueryCombo();
|
|
Query = (QueryResult)cb.getSelectedItem();
|
|
RefAList=new Vector();
|
|
RefMList = new Vector();
|
|
LabelAList = new Vector();
|
|
getRefAttrList(RefAList, RefMList, LabelAList);
|
|
initComponents();
|
|
pack();
|
|
setSize(500,500);
|
|
setResizable(true);
|
|
}
|
|
|
|
/** Check for equality with another object **/
|
|
public boolean equals(Object o){
|
|
if(!(o instanceof ViewConfig))
|
|
return false;
|
|
ViewConfig vc = (ViewConfig)o;
|
|
return AttrName.equals(vc.AttrName) &&
|
|
Query == vc.Query;
|
|
}
|
|
|
|
|
|
/**
|
|
* Fills the arguments with elements.
|
|
* @param RefAList: Attribute names implementing the RenderAttribute interface
|
|
* @param RefMList: all attribute names
|
|
* @param LabelAList: all LabelAttributes
|
|
*/
|
|
private void getRefAttrList (Vector RefAList, Vector RefMList, Vector LabelAList) {
|
|
RefAList.clear();
|
|
RefMList.clear();
|
|
LabelAList.clear();
|
|
|
|
ListExpr TypeList = Query.LEResult;
|
|
while(TypeList.atomType()==ListExpr.NO_ATOM && !TypeList.isEmpty())
|
|
TypeList = TypeList.first();
|
|
|
|
String MainType = TypeList.symbolValue();
|
|
// process relations
|
|
if(MainType.equals("rel") || MainType.equals("trel") || MainType.equals("mrel")){
|
|
// standard
|
|
RefAList.add("Tuple-No.");
|
|
RefMList.add("Tuple-No.");
|
|
LabelAList.add("no Label");
|
|
|
|
TupelCount = Query.LEResult.second().listLength();
|
|
ListExpr attrlist = Query.LEResult.first().second().second();
|
|
|
|
while (!attrlist.isEmpty()) {
|
|
String type = attrlist.first().second().symbolValue();
|
|
String attrName = attrlist.first().first().symbolValue();
|
|
LabelAList.add(attrName);
|
|
if(isRenderAttribute(type)){
|
|
RefAList.add(new RenderAttr(attrName,AttrCount));
|
|
}
|
|
RefMList.add(attrName);
|
|
AttrCount++;
|
|
attrlist = attrlist.rest();
|
|
}
|
|
} else if(MainType.equals("nmap")){
|
|
//v.add("Tupel-No.");
|
|
TupelCount = 0;
|
|
LabelAList.add("no Label");
|
|
/*
|
|
A nautical map consist of a name a scale and a maximum of three relations.
|
|
The realations contains a name and a graphica object describing a point, a line
|
|
or a region value. For this reason, the Reference-Attribute as well as the
|
|
possible Label is 'name'.
|
|
*/
|
|
LabelAList.add("name");
|
|
RefAList.add("name");
|
|
RefMList.add("name");
|
|
} else{ // no relation, no nmap
|
|
if(isRenderAttribute(MainType)){
|
|
RefAList.add(new RenderAttr(AttrName,0));
|
|
}
|
|
RefMList.add(MainType);
|
|
LabelAList.add("no Label");
|
|
LabelAList.add(MainType);
|
|
}
|
|
}
|
|
|
|
/** This method is called from within the constructor to
|
|
* initialize the dialog.
|
|
*/
|
|
private void initComponents () { //GEN-BEGIN:initComponents
|
|
GALabel = new javax.swing.JLabel();
|
|
VCLabel = new javax.swing.JLabel();
|
|
CatCB = new javax.swing.JComboBox(mw.Cats);
|
|
RefDepCBo = new javax.swing.JCheckBox();
|
|
RALabel = new javax.swing.JLabel();
|
|
RTLabel = new javax.swing.JLabel();
|
|
RefAttrCB = new javax.swing.JComboBox(RefAList);
|
|
RendTypeCB = new javax.swing.JComboBox();
|
|
SingleTupelCBo = new javax.swing.JCheckBox();
|
|
NeTuB = new javax.swing.JButton();
|
|
PrTuB = new javax.swing.JButton();
|
|
GATuB = new javax.swing.JButton();
|
|
ApplyTuB = new javax.swing.JButton();
|
|
OKB = new javax.swing.JButton();
|
|
CancelB = new javax.swing.JButton();
|
|
DefaultB = new javax.swing.JButton();
|
|
LALabel = new javax.swing.JLabel();
|
|
LTLabel = new javax.swing.JLabel();
|
|
LabelText = new JTextField();
|
|
LabXOffText = new JTextField(6);
|
|
LabYOffText = new JTextField(6);
|
|
LabelAttrCB = new javax.swing.JComboBox(LabelAList);
|
|
LabelAttrCB.setSelectedIndex(-1);
|
|
// RendPosCB = new javax.swing.JComboBox();
|
|
getContentPane().setLayout(new BoxLayout(getContentPane(), BoxLayout.Y_AXIS));
|
|
InfoPanel = new JPanel();
|
|
InfoPanel.setBorder(LineBorder.createGrayLineBorder());
|
|
InfoPanel.setPreferredSize(new Dimension(400, 130));
|
|
NavPanel = new JPanel();
|
|
NavPanel.setBorder(LineBorder.createGrayLineBorder());
|
|
NavPanel.setPreferredSize(new Dimension(300, 100));
|
|
RefPanel = new JPanel();
|
|
//RefPanel.setBorder(LineBorder.createGrayLineBorder());
|
|
RefPanel.setVisible(false);
|
|
//RefPanel.setPreferredSize(new Dimension(300, 100));
|
|
GALabel.setText("Attribute: ");
|
|
InfoPanel.setLayout(new GridLayout(4,1));
|
|
JPanel FirstRow = new JPanel();
|
|
FirstRow.add(GALabel);
|
|
GAAttrName = new JLabel(AttrName);
|
|
FirstRow.add(GAAttrName);
|
|
FirstRow.add(Box.createHorizontalStrut(30));
|
|
VCLabel.setText("View Category:");
|
|
FirstRow.add(VCLabel);
|
|
JButton ShowCEB = new JButton("..");
|
|
ShowCEB.setPreferredSize(new Dimension(15, 20));
|
|
ShowCEB.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed (java.awt.event.ActionEvent evt) {
|
|
new CategoryEditor(mw, true).show();
|
|
mw.GraphDisplay.repaint();
|
|
CatCB.setSelectedIndex(CatCB.getItemCount() - 1);
|
|
// ((DsplBase)o).getFrame().select(o);
|
|
}
|
|
});
|
|
FirstRow.add(CatCB);
|
|
FirstRow.add(ShowCEB);
|
|
InfoPanel.add(FirstRow);
|
|
|
|
JPanel SecondRow = new JPanel();
|
|
LTLabel.setText("Label Text:");
|
|
SecondRow.add(LTLabel);
|
|
LabelText.setColumns(10);
|
|
SecondRow.add(LabelText);
|
|
LALabel.setText("Labelattribute");
|
|
SecondRow.add(LALabel);
|
|
SecondRow.add(LabelAttrCB);
|
|
InfoPanel.add(SecondRow);
|
|
|
|
JPanel ThirdRow = new JPanel();
|
|
ThirdRow.add(new JLabel("Label Offset X Y"));
|
|
ThirdRow.add(LabXOffText);
|
|
ThirdRow.add(LabYOffText);
|
|
InfoPanel.add(ThirdRow);
|
|
|
|
JPanel FourthRow = new JPanel();
|
|
RefDepCBo.setText("Reference dependent Rendering");
|
|
RefDepCBo.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed (java.awt.event.ActionEvent evt) {
|
|
RefDepCBoActionPerformed(evt);
|
|
}
|
|
});
|
|
FourthRow.add(RefDepCBo);
|
|
|
|
|
|
|
|
// we need a Panel to Select, change,add and remove manual links
|
|
LinkComboBox = new JComboBox();
|
|
|
|
JPanel MLPanel2 = new JPanel();
|
|
MLChangeBtn = new JButton("Change");
|
|
MLNewBtn = new JButton("New");
|
|
MLRemoveBtn = new JButton("Remove");
|
|
MLPanel2.add(MLChangeBtn);
|
|
MLPanel2.add(MLNewBtn);
|
|
MLPanel2.add(MLRemoveBtn);
|
|
|
|
|
|
MLNewBtn.addActionListener(new ActionListener(){
|
|
public void actionPerformed(ActionEvent evt){
|
|
// create a new AttrCatList from given values
|
|
Category SelectedCat = (Category) CatCB.getSelectedItem();
|
|
if (SelectedCat==null){
|
|
Reporter.showError("no Category selected");
|
|
return;
|
|
}
|
|
String CatName = SelectedCat.getName();
|
|
String as = RefAttrCB.getSelectedItem().toString();
|
|
int index = LabelAList.indexOf(as);
|
|
AttrValues = getAttrValues(index);
|
|
if(AttrValues==null){
|
|
Reporter.showError("no reference attribute selected");
|
|
return;
|
|
}
|
|
LAC.setLinks(new AttrCatList());
|
|
LAC.setDefaultCat(SelectedCat);
|
|
LAC.setAttributes(AttrValues);
|
|
LAC.setCategories(mw.Cats);
|
|
LAC.setName("");
|
|
LAC.setVisible(true);
|
|
if(true) { // later depending from result from LAC
|
|
String Name = LAC.getName();
|
|
LinkComboBox.addItem(Name);
|
|
LinkComboBox.setSelectedItem(Name);
|
|
AttrCatList ACL = LAC.getLinks();
|
|
if(!ManualLinkPool.add(ACL)){
|
|
// should never be reached
|
|
Reporter.showError("i can't insert this new references to reference pool");
|
|
}
|
|
}
|
|
}});
|
|
|
|
|
|
MLChangeBtn.addActionListener(new ActionListener(){ // changing links
|
|
public void actionPerformed(ActionEvent evt){
|
|
// create a new AttrCatList from given values
|
|
Category SelectedCat = (Category) CatCB.getSelectedItem();
|
|
if (SelectedCat==null){
|
|
Reporter.showError("no Category selected");
|
|
return;
|
|
}
|
|
String CatName = SelectedCat.getName();
|
|
String as = RefAttrCB.getSelectedItem().toString();
|
|
int index = LabelAList.indexOf(as);
|
|
AttrValues = getAttrValues(index);
|
|
if(AttrValues==null){
|
|
Reporter.showError("no reference attribute selected");
|
|
return;
|
|
}
|
|
String RefName = (String) LinkComboBox.getSelectedItem();
|
|
if(RefName==null){
|
|
Reporter.showError("no Referenceclass selected");
|
|
return;
|
|
}
|
|
|
|
AttrCatList ACL = ManualLinkPool.getLinkWithName(RefName);
|
|
if(ACL==null){
|
|
Reporter.showError("i can't find the selected Referenceclass");
|
|
return;
|
|
}
|
|
|
|
AttrCatList ACLClone = (AttrCatList) ACL.clone();
|
|
LAC.setLinks(ACLClone);
|
|
LAC.addAttributes(AttrValues,SelectedCat);
|
|
LAC.setCategories(mw.Cats);
|
|
LAC.setUpdateMode(true,RefName);
|
|
LAC.setVisible(true);
|
|
LAC.setUpdateMode(false,"");
|
|
if(LAC.getRetValue()==LinkAttrCat.OK) {
|
|
String Name = LAC.getName();
|
|
LinkComboBox.removeItem(RefName);
|
|
LinkComboBox.addItem(Name);
|
|
LinkComboBox.setSelectedItem(Name);
|
|
ACL = LAC.getLinks();
|
|
if(!ManualLinkPool.update(RefName,ACL)){
|
|
// should never be reached
|
|
Reporter.showError("i can't update the references in reference pool");
|
|
}
|
|
}
|
|
}});
|
|
|
|
|
|
MLRemoveBtn.addActionListener(new ActionListener(){
|
|
public void actionPerformed(ActionEvent e){
|
|
String Name = (String) LinkComboBox.getSelectedItem();
|
|
if(Name==null){
|
|
Reporter.showError("no reference selected ");
|
|
return;
|
|
}
|
|
LinkComboBox.removeItem(Name);
|
|
ManualLinkPool.removeLinkWithName(Name);
|
|
}});
|
|
|
|
InfoPanel.add(FourthRow);
|
|
|
|
|
|
SingleTupelCBo.setText("Single Tuple");
|
|
SingleTupelCBo.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed (java.awt.event.ActionEvent evt) {
|
|
NeTuB.setEnabled(SingleTupelCBo.isSelected());
|
|
PrTuB.setEnabled(SingleTupelCBo.isSelected());
|
|
ApplyTuB.setEnabled(SingleTupelCBo.isSelected());
|
|
GATuB.setEnabled(SingleTupelCBo.isSelected());
|
|
RefDepCBo.setEnabled(!SingleTupelCBo.isSelected());
|
|
if (SingleTupelCBo.isSelected()) {
|
|
updateFields();
|
|
}
|
|
else {
|
|
TupNrLabel.setText("Tuples: " + TupelCount);
|
|
LabelText.setText(null);
|
|
LabXOffText.setText("0");
|
|
LabYOffText.setText("0");
|
|
}
|
|
}
|
|
});
|
|
|
|
JPanel NavRow1 = new JPanel();
|
|
NavRow1.add(SingleTupelCBo);
|
|
NeTuB.setText("Next Tuple");
|
|
NeTuB.setEnabled(false);
|
|
NeTuB.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed (java.awt.event.ActionEvent evt) {
|
|
NeTuBActionPerformed(evt);
|
|
}
|
|
});
|
|
PrTuB.setText("Prev Tuple");
|
|
PrTuB.setEnabled(false);
|
|
PrTuB.addActionListener(new java.awt.event.ActionListener() {
|
|
|
|
public void actionPerformed (java.awt.event.ActionEvent evt) {
|
|
PrTuBActionPerformed(evt);
|
|
}
|
|
});
|
|
NavRow1.add(PrTuB);
|
|
NavPanel.setLayout(new GridLayout(4,1));
|
|
NavRow1.add(NeTuB);
|
|
|
|
NavPanel.add(NavRow1);
|
|
|
|
JPanel NavRow2 = new JPanel();
|
|
NavRow2.add(Box.createHorizontalStrut(60));
|
|
TupNrLabel = new JLabel("Tuples: " + TupelCount);
|
|
NavRow2.add(TupNrLabel);
|
|
ApplyTuB.setText("Apply Tuple");
|
|
ApplyTuB.setEnabled(false);
|
|
ApplyTuB.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed (java.awt.event.ActionEvent evt) {
|
|
Category cat = (Category)CatCB.getSelectedItem();
|
|
int LabIndex = LabelAttrCB.getSelectedIndex();
|
|
AktGO.setCategory(cat);
|
|
if ((LabXOffText.getText().equals("")) || (LabYOffText.getText().equals("")))
|
|
;
|
|
else
|
|
AktGO.getLabPosOffset().setLocation(Double.parseDouble(LabXOffText.getText()),
|
|
Double.parseDouble(LabYOffText.getText()));
|
|
if (LabelText.getText().equals(""))
|
|
AktGO.setLabelAttribute(null);
|
|
else
|
|
AktGO.setLabelAttribute(new DefaultLabelAttribute(LabelText.getText()));
|
|
}
|
|
});
|
|
NavRow2.add(ApplyTuB);
|
|
NavPanel.add(NavRow2);
|
|
GATuB.setText("Get Attribute");
|
|
GATuB.setEnabled(false);
|
|
GATuB.addActionListener(new java.awt.event.ActionListener() {
|
|
|
|
public void actionPerformed (java.awt.event.ActionEvent evt) {
|
|
int LabIndex = LabelAttrCB.getSelectedIndex();
|
|
if (LabIndex >= 0) {
|
|
String text = Query.getModel().getElementAt((AktTupNr - 1)*(AttrCount
|
|
+ 1) + LabIndex).toString();
|
|
LabelText.setText(text.substring(text.indexOf(":") + 1));
|
|
}
|
|
}
|
|
});
|
|
JPanel NavRow3 = new JPanel();
|
|
NavRow3.add(GATuB);
|
|
NavPanel.add(NavRow3);
|
|
// RefDepCBo.setText ("jCheckBox1");
|
|
RALabel.setText("Reference attribute");
|
|
|
|
|
|
|
|
JPanel P = new JPanel();
|
|
P.setLayout(new GridLayout(5,2));
|
|
|
|
//P.add(Box.createHorizontalStrut(40));
|
|
RTLabel.setText("Rendering Type");
|
|
RendTypeCB.addItem(RENDER_WHITE_RED);
|
|
RendTypeCB.addItem(RENDER_WHITE_GREEN);
|
|
RendTypeCB.addItem(RENDER_WHITE_BLUE);
|
|
RendTypeCB.addItem(RENDER_GREEN_RED);
|
|
RendTypeCB.addItem(RENDER_RED_GREEN);
|
|
RendTypeCB.addItem(RENDER_GREEN_BROWN);
|
|
RendTypeCB.addItem(RENDER_BLUE_RED);
|
|
RendTypeCB.addItem(RENDER_BLUE_GREEN);
|
|
RendTypeCB.addItem(RENDER_RANDOM_COLOR);
|
|
RendTypeCB.addItem(RENDER_POINTSIZE);
|
|
RendTypeCB.addItem(RENDER_LINEWIDTH);
|
|
RendTypeCB.addItem(RENDER_LINE_WHITE_RED);
|
|
RendTypeCB.addItem(RENDER_LINE_WHITE_GREEN);
|
|
RendTypeCB.addItem(RENDER_LINE_WHITE_BLUE);
|
|
RendTypeCB.addItem(RENDER_LINE_GREEN_RED);
|
|
RendTypeCB.addItem(RENDER_LINE_RED_GREEN);
|
|
RendTypeCB.addItem(RENDER_LINE_BLUE_RED);
|
|
RendTypeCB.addItem(RENDER_LINE_BLUE_GREEN);
|
|
searchForImageDirs();
|
|
LinkCheckBox = new JCheckBox("manual link");
|
|
LinkCheckBox.addActionListener(new ActionListener(){
|
|
public void actionPerformed(ActionEvent evt){
|
|
boolean s = LinkCheckBox.isSelected();
|
|
if(s){
|
|
RefAttrCB.removeAllItems();
|
|
for(int i=0;i<RefMList.size();i++){
|
|
RefAttrCB.addItem(RefMList.get(i));
|
|
}
|
|
LinkComboBox.setEnabled(true);
|
|
MLChangeBtn.setEnabled(true);
|
|
MLNewBtn.setEnabled(true);
|
|
MLRemoveBtn.setEnabled(true);
|
|
RendTypeCB.setEnabled(false);
|
|
} else{
|
|
RefAttrCB.removeAllItems();
|
|
for(int i=0;i<RefAList.size();i++){
|
|
RefAttrCB.addItem(RefAList.get(i));
|
|
}
|
|
LinkComboBox.setEnabled(false);
|
|
MLChangeBtn.setEnabled(false);
|
|
MLNewBtn.setEnabled(false);
|
|
MLRemoveBtn.setEnabled(false);
|
|
RendTypeCB.setEnabled(true);
|
|
}
|
|
}
|
|
});
|
|
|
|
LinkCheckBox.setSelected(false);
|
|
LinkComboBox.setEnabled(false);
|
|
MLChangeBtn.setEnabled(false);
|
|
MLNewBtn.setEnabled(false);
|
|
MLRemoveBtn.setEnabled(false);
|
|
|
|
|
|
|
|
P.add(RALabel);
|
|
P.add(RefAttrCB);
|
|
|
|
P.add(RTLabel);
|
|
P.add(RendTypeCB);
|
|
|
|
|
|
P.add(LinkCheckBox);
|
|
P.add(LinkComboBox);
|
|
P.add(new JLabel("")); // a dummy
|
|
P.add(MLPanel2);
|
|
|
|
KeyListener RKL = new KeyAdapter(){
|
|
public void keyPressed(KeyEvent evt){
|
|
if(evt.getKeyCode()==KeyEvent.VK_ENTER){
|
|
if(evt.getSource().equals(CancelB)){
|
|
setVisible(false);
|
|
dispose();
|
|
}
|
|
else
|
|
OKBActionPerformed();
|
|
}
|
|
if(evt.getKeyCode()==KeyEvent.VK_ESCAPE){
|
|
setVisible(false);
|
|
dispose();
|
|
}
|
|
}
|
|
};
|
|
CatCB.addKeyListener(RKL);
|
|
RefDepCBo.addKeyListener(RKL);
|
|
RefAttrCB.addKeyListener(RKL);
|
|
RendTypeCB.addKeyListener(RKL);
|
|
LabelAttrCB.addKeyListener(RKL);
|
|
SingleTupelCBo.addKeyListener(RKL);
|
|
NeTuB.addKeyListener(RKL);
|
|
PrTuB.addKeyListener(RKL);
|
|
GATuB.addKeyListener(RKL);
|
|
ApplyTuB.addKeyListener(RKL);
|
|
OKB.addKeyListener(RKL);
|
|
CancelB.addKeyListener(RKL);
|
|
DefaultB.addKeyListener(RKL);
|
|
LabelText.addKeyListener(RKL);
|
|
LabXOffText.addKeyListener(RKL);
|
|
LabYOffText.addKeyListener(RKL);
|
|
|
|
|
|
OKB.setText("OK");
|
|
OKB.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed (java.awt.event.ActionEvent evt) {
|
|
OKBActionPerformed();
|
|
}
|
|
});
|
|
RefPanel.add(P);
|
|
|
|
ButPanel = new JPanel();
|
|
ButPanel.add(OKB);
|
|
CancelB.setText("Cancel");
|
|
CancelB.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed (java.awt.event.ActionEvent evt) {
|
|
setVisible(false);
|
|
dispose();
|
|
}
|
|
});
|
|
ButPanel.add(CancelB);
|
|
getContentPane().add(InfoPanel);
|
|
getContentPane().add(NavPanel);
|
|
getContentPane().add(RefPanel);
|
|
getContentPane().add(ButPanel);
|
|
} //GEN-END:initComponents
|
|
|
|
/**
|
|
* In single-tuple mode some fields need to be refreshed, when stepping through tuples
|
|
*/
|
|
private void updateFields () {
|
|
TupNrLabel.setText("Tuple " + AktTupNr + "/" + TupelCount);
|
|
//int LabIndex=LabelAttrCB.getSelectedIndex();
|
|
ListIterator li = Query.getGraphObjects().listIterator();
|
|
int cnt = 0;
|
|
DsplGraph dg = null;
|
|
while (cnt < AktTupNr) {
|
|
dg = (DsplGraph)li.next();
|
|
if (dg.getAttrName().equals(AttrName))
|
|
cnt++;
|
|
}
|
|
AktGO = dg;
|
|
CatCB.setSelectedItem(AktGO.getCategory());
|
|
LabXOffText.setText(Double.toString(AktGO.getLabPosOffset().getX()));
|
|
LabYOffText.setText(Double.toString(AktGO.getLabPosOffset().getY()));
|
|
LabelText.setText(AktGO.getLabelText(CurrentState.ActualTime));
|
|
}
|
|
|
|
|
|
/** read a AttrCatLinks from pool and insert it in
|
|
* the appropriate ComboBox
|
|
*/
|
|
public void readPool(){
|
|
LinkComboBox.removeAllItems();
|
|
for(int i=0;i<ManualLinkPool.numberOfLinks();i++){
|
|
LinkComboBox.addItem(ManualLinkPool.get(i).getName());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* When 'OK' is pressed this method checks
|
|
* 1. Not in single tuple mode:
|
|
* labeltext, labelpos, category is associated to all tupels of the graphic attribute
|
|
* 2. Reference dependant rendering?
|
|
* calculates a category for each value of the ref. attr. ,based upon the selected
|
|
* category and rendering type.
|
|
* @param evt
|
|
*/
|
|
private void OKBActionPerformed () {
|
|
if (!SingleTupelCBo.isSelected()) {
|
|
Category cat = (Category)CatCB.getSelectedItem();
|
|
int LabIndex = LabelAttrCB.getSelectedIndex();
|
|
ListIterator li = Query.getGraphObjects().listIterator();
|
|
int cnt = 0;
|
|
// set labels to the objects
|
|
while (li.hasNext()) {
|
|
DsplGraph dg = (DsplGraph)li.next();
|
|
if (dg.getAttrName().equals(AttrName)) {
|
|
dg.setCategory(cat);
|
|
double laboffx=0;
|
|
boolean offx = false;
|
|
double laboffy=0;
|
|
boolean offy = false;
|
|
try{
|
|
laboffx = Double.parseDouble(LabXOffText.getText());
|
|
offx=true;
|
|
}catch(NumberFormatException e){
|
|
offx=false;
|
|
}
|
|
try{
|
|
laboffy = Double.parseDouble(LabYOffText.getText());
|
|
offy=true;
|
|
}catch(NumberFormatException e){
|
|
offy=false;
|
|
}
|
|
Point oldLabelPos = dg.getLabPosOffset();
|
|
if(!offx){ // use old value
|
|
laboffx = oldLabelPos.getX();
|
|
}
|
|
if(!offy){
|
|
laboffy = oldLabelPos.getY();
|
|
}
|
|
dg.getLabPosOffset().setLocation(laboffx,laboffy);
|
|
if ((LabIndex >= 0) && (LabelText.getText().equals(""))) {
|
|
LabelAttribute label;
|
|
if(LabIndex==0) // no Label
|
|
label=null;
|
|
else {
|
|
Object labobj = Query.getModel().getElementAt(cnt*(AttrCount + 1)+ LabIndex-1);
|
|
if(! (labobj instanceof LabelAttribute)){
|
|
String labeltext =labobj.toString();
|
|
labeltext = labeltext.substring(labeltext.indexOf(":")+1);
|
|
label = new DefaultLabelAttribute(labeltext);
|
|
} else{
|
|
label = (LabelAttribute) labobj;
|
|
}
|
|
}
|
|
dg.setLabelAttribute(label);
|
|
}
|
|
else if (LabelText.getText().equals("")){
|
|
dg.setLabelAttribute(null);
|
|
}
|
|
else{
|
|
dg.setLabelAttribute(new DefaultLabelAttribute(LabelText.getText()));
|
|
}
|
|
cnt++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
String as ="";
|
|
if(RefAttrCB.getSelectedIndex()>=0){
|
|
as = RefAttrCB.getSelectedItem().toString();
|
|
}
|
|
if (RefDepCBo.isSelected()) {
|
|
if(!LinkCheckBox.isSelected()){
|
|
// handling of reference attributes
|
|
Category cat = calcCategory((Category)CatCB.getSelectedItem());
|
|
if(mw.Cats.indexOf(cat)<0){
|
|
mw.Cats.add(cat);
|
|
CatCB.contentsChanged(new ListDataEvent(this,
|
|
ListDataEvent.CONTENTS_CHANGED,
|
|
0,
|
|
mw.Cats.size()));
|
|
}
|
|
ListIterator li = Query.getGraphObjects().listIterator();
|
|
int attrno=-1;//indicating tuple number
|
|
Object refobject = RefAttrCB.getSelectedItem();
|
|
if(refobject instanceof RenderAttr){
|
|
attrno = ((RenderAttr)RefAttrCB.getSelectedItem()).pos;
|
|
}
|
|
|
|
boolean first = true;
|
|
double min=0;
|
|
double max=0;
|
|
int cnt=0;
|
|
while (li.hasNext()) {
|
|
DsplGraph dg = (DsplGraph)li.next();
|
|
if (dg.getAttrName().equals(AttrName)) {
|
|
dg.setCategory(cat);
|
|
// get the attribute for using in rendering
|
|
if(attrno<0){
|
|
dg.setRenderAttribute(new DefaultRenderAttribute(cnt));
|
|
max = cnt;
|
|
} else{
|
|
int rendobjpos = cnt*(AttrCount + 1)+ attrno;
|
|
int size = Query.getModel().getSize();
|
|
if(rendobjpos>=size){
|
|
Reporter.writeError("Too less elements in QueryResult."+
|
|
"Please check the involved Display classes");
|
|
dg.setRenderAttribute(null);
|
|
} else {
|
|
Object rendobj = Query.getModel().getElementAt(rendobjpos);
|
|
if(!(rendobj instanceof RenderAttribute)){
|
|
Reporter.writeError("Fatal error, no renderattribute found .");
|
|
Reporter.writeError("found "+ rendobj+" instead on pos"+rendobjpos);
|
|
dg.setRenderAttribute(null);
|
|
} else{
|
|
RenderAttribute curAttr = (RenderAttribute) rendobj;
|
|
dg.setRenderAttribute(curAttr);
|
|
if(curAttr.mayBeDefined()){
|
|
double cmin = curAttr.getMinRenderValue();
|
|
double cmax = curAttr.getMaxRenderValue();
|
|
if(!Double.isInfinite(cmin) && !Double.isInfinite(cmax)){
|
|
if(first){
|
|
first=false;
|
|
min = cmin;
|
|
max = cmax;
|
|
} else{
|
|
min = cmin<min?cmin:min;
|
|
max = cmax>max?cmax:max;
|
|
}
|
|
} else{
|
|
Reporter.debug("infinite range given from "+dg.getClass());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cnt++;
|
|
}
|
|
}
|
|
cat.setValueRange(min,max);
|
|
} else{
|
|
// take the categories for the object from LinkAttrCat LAC
|
|
if(LinkComboBox.getSelectedIndex()<0){ // no references selected
|
|
Reporter.showError("you have selected to use a manual link \n"+
|
|
" but the choice for this link is empty !!");
|
|
return;
|
|
}
|
|
int RefAttrIndex = LabelAList.indexOf(as);
|
|
ListExpr attrValueList = getAttrValues(RefAttrIndex);
|
|
if(attrValueList==null){
|
|
Reporter.showError("no reference attribute selected");
|
|
return;
|
|
}
|
|
// get the Manual Link from MLPool
|
|
String LinkName = (String) LinkComboBox.getSelectedItem();
|
|
AttrCatList ACL = ManualLinkPool.getLinkWithName(LinkName);
|
|
if(ACL==null){
|
|
Reporter.showError("internal error: selected reference name not found");
|
|
return;
|
|
}
|
|
boolean found =false;
|
|
int number = ACL.numberOfLinksFor(attrValueList);
|
|
if(number<1){
|
|
Reporter.showError("the selected reference contains no links for selected attribute");
|
|
return;
|
|
}
|
|
if(number < attrValueList.listLength()){
|
|
if(Reporter.showQuestion("not all attribute values have a refered category \n "+
|
|
"you want to use the default category ?")==Reporter.NO)
|
|
return;
|
|
}
|
|
// check for categories in selected references
|
|
int numberNames=0;
|
|
int failed =0;
|
|
Vector failedNames=new Vector();
|
|
|
|
// check whether all required categories are available
|
|
Iterator it = ACL.getCatNames(attrValueList);
|
|
while(it.hasNext()){
|
|
String CN = (String) it.next();
|
|
if(CN!=null){ // a selection is found
|
|
numberNames++;
|
|
found = false;
|
|
for (int i=0;i<mw.Cats.size() & ! found ;i++){
|
|
Category cat = (Category)mw.Cats.get(i);
|
|
if(cat.hasName(CN)){
|
|
found = true;
|
|
}
|
|
}
|
|
if(!found){ // name corresponds to no known category
|
|
failed++;
|
|
failedNames.add(CN);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(numberNames==failed && numberNames>0){
|
|
Reporter.showError("no categorie in the selected references is loaded \n abort");
|
|
return;
|
|
}
|
|
|
|
if(failed>0){
|
|
String msg = "not all categories in the seleced references are loaded \n"+
|
|
"you want to use the default category ?\n\n" +
|
|
"not known are \n" ;
|
|
int size = failedNames.size();
|
|
int max = Math.max(size,10); // report a maximum of 10 categories
|
|
for(int i=0;i<failedNames.size();i++){
|
|
msg += failedNames.get(i)+"\n";
|
|
}
|
|
if(size>max){
|
|
msg += " .... ";
|
|
}
|
|
if(Reporter.showQuestion(msg)==Reporter.NO){
|
|
return;
|
|
}
|
|
}
|
|
// all categories found or standard category confirmed
|
|
String CatName;
|
|
Category Cat=null;
|
|
ListExpr res = extractRelation();
|
|
ListIterator li = Query.getGraphObjects().listIterator();
|
|
while(li.hasNext()){ // for all graphical objects
|
|
DsplGraph dg = (DsplGraph)li.next();
|
|
if(dg.getAttrName().equals(AttrName)){ // with corresponding attrname
|
|
ListExpr le = res.first();
|
|
for(int i=1;i<RefAttrIndex;i++){ // read over non interesting attribute values
|
|
le = le.rest();
|
|
}
|
|
CatName = ACL.getCatName(le.first());
|
|
for(int i=0;i<mw.Cats.size();i++){ // search for the category
|
|
Category tmpCat =(Category) mw.Cats.get(i);
|
|
if(tmpCat.hasName(CatName)){
|
|
Cat = (Category) mw.Cats.get(i);
|
|
}
|
|
}
|
|
if(Cat!=null){
|
|
dg.setCategory(Cat);
|
|
} else {
|
|
Object o = CatCB.getSelectedItem();
|
|
if(o!=null){
|
|
dg.setCategory((Category)o);
|
|
}
|
|
}
|
|
|
|
res = res.rest();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
setVisible(false);
|
|
dispose();
|
|
} //GEN-LAST:event_OKBActionPerformed
|
|
|
|
/**create new Cat for every GO with Attribute AttrName according to its ref. Tupel-Value
|
|
*/
|
|
private Category calcCategory (Category templCat) {
|
|
Category NewCat = null;
|
|
try {
|
|
NewCat = (Category)templCat.clone();
|
|
} catch (Exception e) {
|
|
if(tools.Environment.DEBUG_MODE){
|
|
Reporter.writeError("Error in cloning of category");
|
|
}
|
|
return null;
|
|
}
|
|
NewCat.setName(NewCat.getName() + "V" + VariantNr);
|
|
VariantNr++;
|
|
Object o = RendTypeCB.getSelectedItem();
|
|
String RendType = (String)o;
|
|
NewCat.setRenderMethod(Category.RENDER_COLOR);
|
|
if (RendType.equals(RENDER_WHITE_BLACK)) {
|
|
NewCat.setColorRange(Color.WHITE,Color.BLACK);
|
|
}
|
|
if (RendType.equals(RENDER_WHITE_BLUE)) {
|
|
NewCat.setColorRange(Color.WHITE,Color.BLUE);
|
|
}
|
|
if (RendType.equals(RENDER_WHITE_RED)) {
|
|
NewCat.setColorRange(Color.WHITE,Color.RED);
|
|
}
|
|
if (RendType.equals(RENDER_WHITE_GREEN)) {
|
|
NewCat.setColorRange(Color.WHITE,Color.GREEN);
|
|
}
|
|
if (RendType.equals(RENDER_GREEN_RED)) {
|
|
NewCat.setColorRange(Color.GREEN,Color.RED);
|
|
}
|
|
if (RendType.equals(RENDER_RED_GREEN)) {
|
|
NewCat.setColorRange(Color.RED,Color.GREEN);
|
|
}
|
|
if (RendType.equals(RENDER_GREEN_BROWN)) {
|
|
NewCat.setColorRange(Color.GREEN,new Color(139,69,19));
|
|
}
|
|
if (RendType.equals(RENDER_BLUE_RED)) {
|
|
NewCat.setColorRange(Color.BLUE,Color.RED);
|
|
}
|
|
if (RendType.equals(RENDER_BLUE_GREEN)) {
|
|
NewCat.setColorRange(Color.BLUE,Color.GREEN);
|
|
}
|
|
if (RendType.equals(RENDER_RANDOM_COLOR)) {
|
|
NewCat.setRenderMethod(Category.RENDER_RANDOM_COLOR);
|
|
}
|
|
if (RendType.equals(RENDER_POINTSIZE)) {
|
|
NewCat.setRenderMethod(Category.RENDER_POINTSIZE);
|
|
}
|
|
if(RendType.equals(RENDER_LINEWIDTH)){
|
|
NewCat.setRenderMethod(Category.RENDER_LINEWIDTH);
|
|
}
|
|
if (RendType.equals(RENDER_LINE_WHITE_BLACK)) {
|
|
NewCat.setColorRange(Color.WHITE,Color.BLACK);
|
|
NewCat.setRenderMethod(Category.RENDER_LINE_COLOR);
|
|
}
|
|
if (RendType.equals(RENDER_LINE_WHITE_BLUE)) {
|
|
NewCat.setColorRange(Color.WHITE,Color.BLUE);
|
|
NewCat.setRenderMethod(Category.RENDER_LINE_COLOR);
|
|
}
|
|
if (RendType.equals(RENDER_LINE_WHITE_RED)) {
|
|
NewCat.setColorRange(Color.WHITE,Color.RED);
|
|
NewCat.setRenderMethod(Category.RENDER_LINE_COLOR);
|
|
}
|
|
if (RendType.equals(RENDER_LINE_WHITE_GREEN)) {
|
|
NewCat.setColorRange(Color.WHITE,Color.GREEN);
|
|
NewCat.setRenderMethod(Category.RENDER_LINE_COLOR);
|
|
}
|
|
if (RendType.equals(RENDER_LINE_GREEN_RED)) {
|
|
NewCat.setColorRange(Color.GREEN,Color.RED);
|
|
NewCat.setRenderMethod(Category.RENDER_LINE_COLOR);
|
|
}
|
|
if (RendType.equals(RENDER_LINE_RED_GREEN)) {
|
|
NewCat.setColorRange(Color.RED,Color.GREEN);
|
|
NewCat.setRenderMethod(Category.RENDER_LINE_COLOR);
|
|
}
|
|
if (RendType.equals(RENDER_LINE_BLUE_RED)) {
|
|
NewCat.setColorRange(Color.BLUE,Color.RED);
|
|
NewCat.setRenderMethod(Category.RENDER_LINE_COLOR);
|
|
}
|
|
if (RendType.equals(RENDER_LINE_BLUE_GREEN)) {
|
|
NewCat.setColorRange(Color.BLUE,Color.GREEN);
|
|
NewCat.setRenderMethod(Category.RENDER_LINE_COLOR);
|
|
}
|
|
return NewCat;
|
|
}
|
|
|
|
|
|
/**
|
|
* Searches the images/ directory for subdirectories with images. They are listed as
|
|
* rendering type 'Images in <directory>'
|
|
* @see <a href="ViewConfigsrc.html#searchForImagedirs">Source</a>
|
|
*/
|
|
private void searchForImageDirs () {
|
|
FileFilter DirFilter = new FileFilter() {
|
|
|
|
public boolean accept (File f) {
|
|
return f.isDirectory();
|
|
}
|
|
public String getDescription () {
|
|
return "Directories";
|
|
} //end getDescription
|
|
}; // end newFileFilter
|
|
File f = new File("images/");
|
|
File[] fileList = f.listFiles(DirFilter);
|
|
if(fileList!=null)
|
|
for (int i = 0; i < fileList.length; i++)
|
|
RendTypeCB.addItem(new String("Images in " + fileList[i].getName()));
|
|
}
|
|
|
|
/**
|
|
* extracts the relation from a nautical map or from a relation
|
|
*/
|
|
private ListExpr extractRelation(){
|
|
ListExpr TypeList = Query.LEResult.first();
|
|
while(TypeList.atomType()==ListExpr.NO_ATOM && !TypeList.isEmpty())
|
|
TypeList=TypeList.first();
|
|
if(TypeList.atomType()!=ListExpr.SYMBOL_ATOM)
|
|
return Query.LEResult.second();
|
|
|
|
String TypeName = TypeList.symbolValue();
|
|
|
|
if(TypeName.equals("nmap")){
|
|
ListExpr Relations=Query.LEResult.second().rest().rest(); // take the value and read over name and scale
|
|
ListExpr value;
|
|
if(AttrName.equals("object"))
|
|
value=Relations.first();
|
|
else if(AttrName.equals("sline"))
|
|
value=Relations.second();
|
|
else if(AttrName.equals("area"))
|
|
value=Relations.third();
|
|
else{
|
|
value = new ListExpr();
|
|
Reporter.writeError("Unknow AttrName for nmap detected");
|
|
}
|
|
TupelCount = value.listLength();
|
|
return value;
|
|
} else{
|
|
return Query.LEResult.second();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Makes a double-value out of a special atom-type
|
|
* @param le
|
|
* @return double value
|
|
*/
|
|
private double convertLEtoDouble (ListExpr le) {
|
|
if (le.atomType() == ListExpr.STRING_ATOM){
|
|
return le.stringValue().hashCode();
|
|
}
|
|
if (le.atomType() == ListExpr.BOOL_ATOM)
|
|
if (le.boolValue())
|
|
return 1;
|
|
else
|
|
return 0;
|
|
if (le.atomType() == ListExpr.INT_ATOM)
|
|
return (double)le.intValue();
|
|
if (le.atomType() == ListExpr.REAL_ATOM)
|
|
return (double)le.realValue();
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* returns a clone of a ListExpr */
|
|
private static ListExpr CloneListExpr(ListExpr Original){
|
|
|
|
int AtomType = Original.atomType();
|
|
if(Original.isEmpty())
|
|
return ListExpr.theEmptyList();
|
|
|
|
switch(AtomType){
|
|
case ListExpr.INT_ATOM : return ListExpr.intAtom(Original.intValue());
|
|
case ListExpr.REAL_ATOM : return ListExpr.realAtom(Original.realValue());
|
|
case ListExpr.BOOL_ATOM : return ListExpr.boolAtom(Original.boolValue());
|
|
case ListExpr.STRING_ATOM : return ListExpr.stringAtom(Original.stringValue());
|
|
case ListExpr.SYMBOL_ATOM : return ListExpr.symbolAtom(Original.symbolValue());
|
|
case ListExpr.TEXT_ATOM : return ListExpr.textAtom(Original.textValue());
|
|
case ListExpr.NO_ATOM : { if(Original.listLength()<1){
|
|
Reporter.writeError("viewer.hoese.ViewConfig.CloneListExpr :: error in ListExpr");
|
|
return null;
|
|
}
|
|
ListExpr First,Last;
|
|
First = CloneListExpr(Original.first());
|
|
Last = First;
|
|
ListExpr Next;
|
|
ListExpr Orig2 = Original.rest();
|
|
while(!Orig2.isEmpty()){
|
|
Next = CloneListExpr(Orig2.first());
|
|
Last = ListExpr.append(Last,Next);
|
|
Orig2 = Orig2.rest();
|
|
}
|
|
|
|
return First;
|
|
|
|
}
|
|
}
|
|
|
|
Reporter.writeError("viewer.hoese.ViewConfig.ClonListExpr : unknow AtomType");
|
|
return null;
|
|
}
|
|
|
|
private ListExpr getAttrValues(int index){
|
|
if(index < 0)
|
|
return null;
|
|
return getAttrValues(index,extractRelation());
|
|
}
|
|
|
|
/* get a List of Values for specific index */
|
|
private ListExpr getAttrValues(int index,ListExpr relation){
|
|
if(index < 0)
|
|
return null;
|
|
ListExpr AllValues = relation;
|
|
ListExpr Values=null;
|
|
ListExpr CurrentTuple;
|
|
ListExpr CurrentAttr;
|
|
ListExpr Last=null,Next;
|
|
while(!AllValues.isEmpty()){
|
|
CurrentTuple = AllValues.first();
|
|
if(index>CurrentTuple.listLength()){
|
|
Reporter.writeError("The selected Reference is outside the tuple");
|
|
return null;
|
|
}
|
|
// search the attribute
|
|
for(int i=1; i<index;i++)
|
|
CurrentTuple = CurrentTuple.rest();
|
|
CurrentAttr = CurrentTuple.first();
|
|
if(Values==null){
|
|
Values = ListExpr.oneElemList(CloneListExpr(CurrentAttr));
|
|
Last = Values;
|
|
}else{
|
|
Next = CloneListExpr(CurrentAttr);
|
|
Last = ListExpr.append(Last,Next);
|
|
}
|
|
AllValues = AllValues.rest();
|
|
}
|
|
if(Values==null)
|
|
Values = ListExpr.theEmptyList();
|
|
return Values;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Moves to the previous or the last tuple
|
|
* @param evt
|
|
*/
|
|
private void PrTuBActionPerformed (java.awt.event.ActionEvent evt) {
|
|
AktTupNr = (AktTupNr > 1) ? AktTupNr - 1 : TupelCount;
|
|
updateFields();
|
|
}
|
|
|
|
|
|
/**
|
|
* Moves to the next or first tuple.
|
|
* @param evt
|
|
*/
|
|
private void NeTuBActionPerformed (java.awt.event.ActionEvent evt) { //GEN-FIRST:event_NeTuBActionPerformed
|
|
AktTupNr = (AktTupNr < TupelCount) ? AktTupNr + 1 : 1;
|
|
updateFields();
|
|
} //GEN-LAST:event_NeTuBActionPerformed
|
|
|
|
/**
|
|
* This method is called after selecting ref. dep. rend.
|
|
* @param evt
|
|
* @see <a href="ViewConfigsrc.html#RefDepCBoActionPerformed">Source</a>
|
|
*/
|
|
private void RefDepCBoActionPerformed (java.awt.event.ActionEvent evt) { //GEN-FIRST:event_RefDepCBoActionPerformed
|
|
// Add your handling code here:
|
|
RefPanel.setVisible(RefDepCBo.isSelected());
|
|
NavPanel.setVisible(!RefDepCBo.isSelected());
|
|
} //GEN-LAST:event_RefDepCBoActionPerformed
|
|
|
|
|
|
|
|
/** check for new categories in HoeseViewer an show them */
|
|
public void setVisible(boolean on){
|
|
if(on){ // check for new Categorys
|
|
if(CatCB.getItemCount()!=mw.Cats.size()){ // there are new Categories
|
|
int index = CatCB.getSelectedIndex();
|
|
CatCB.removeAllItems();
|
|
for(int i=0;i<mw.Cats.size();i++)
|
|
CatCB.addItem( (Category) mw.Cats.get(i));
|
|
if(index<mw.Cats.size())
|
|
CatCB.setSelectedIndex(index);
|
|
}
|
|
|
|
}
|
|
super.setVisible(on);
|
|
}
|
|
|
|
|
|
/** checks if the given string decribes a type of RenderAttribute
|
|
**/
|
|
private boolean isRenderAttribute(String type){
|
|
// search within the vector
|
|
for(int i=0;i<storedRenderAttributes.size();i++){
|
|
RenderType rt = (RenderType)storedRenderAttributes.get(i);
|
|
if( rt.type.equals(type)){
|
|
return rt.isRenderAttribute;
|
|
}
|
|
}
|
|
Class theClass=null;
|
|
// nothing known about this type
|
|
String className = "viewer.hoese.algebras.Dspl"+type;
|
|
try{
|
|
theClass = Class.forName(className);
|
|
} catch(ClassNotFoundException e){
|
|
// my be implemented while runtime -> store nothing
|
|
return false;
|
|
}
|
|
boolean isRender = RenderAttributeClass.isAssignableFrom(theClass);
|
|
RenderType rt = new RenderType(type,isRender);
|
|
storedRenderAttributes.add(rt);
|
|
return isRender;
|
|
}
|
|
|
|
/** should be called whenever the categories were changed **/
|
|
public void CatsChanged(Object source){
|
|
CatCB.contentsChanged(new ListDataEvent( source,
|
|
ListDataEvent.CONTENTS_CHANGED,
|
|
0,mw.Cats.size()));
|
|
}
|
|
|
|
|
|
/** Closes the dialog
|
|
*/
|
|
private void closeDialog (java.awt.event.WindowEvent evt) { //GEN-FIRST:event_closeDialog
|
|
setVisible(false);
|
|
dispose();
|
|
} //GEN-LAST:event_closeDialog
|
|
// }
|
|
// Variables declaration - do not modify//GEN-BEGIN:variables
|
|
private JLabel GALabel;
|
|
private JLabel VCLabel;
|
|
private JComboBox CatCB;
|
|
private JCheckBox RefDepCBo;
|
|
private JLabel RALabel;
|
|
private JLabel RTLabel;
|
|
private JComboBox RefAttrCB;
|
|
private JComboBox RendTypeCB;
|
|
private JTextField LabelText;
|
|
private JTextField LabXOffText;
|
|
private JTextField LabYOffText;
|
|
private JCheckBox SingleTupelCBo;
|
|
private JButton NeTuB;
|
|
private JButton PrTuB;
|
|
private JButton GATuB;
|
|
private JButton ApplyTuB;
|
|
private JButton OKB;
|
|
private JButton CancelB;
|
|
private JButton DefaultB;
|
|
private JLabel LALabel;
|
|
private JLabel LTLabel;
|
|
private JComboBox LabelAttrCB;
|
|
private JLabel GAAttrName, TupNrLabel;
|
|
private JButton MLChangeBtn;
|
|
private JButton MLNewBtn;
|
|
private JButton MLRemoveBtn;
|
|
private JCheckBox LinkCheckBox;
|
|
private JComboBox LinkComboBox;
|
|
|
|
private static int VariantNr = 0;
|
|
|
|
private Vector storedRenderAttributes = new Vector(20);
|
|
private Class RenderAttributeClass;
|
|
|
|
/** This class represents a connection between a type name
|
|
* and a flag indicating if this type can be used as
|
|
* an ReferenceAttribute.
|
|
**/
|
|
private class RenderType {
|
|
public RenderType(String type, boolean isRenderAttribute){
|
|
this.type = type;
|
|
this.isRenderAttribute=isRenderAttribute;
|
|
}
|
|
private String type;
|
|
private boolean isRenderAttribute;
|
|
}
|
|
|
|
/** this class connects an attribute name with an
|
|
* attribute index. It is used to get the index od a
|
|
* attribute used for rendering
|
|
*/
|
|
private class RenderAttr {
|
|
public RenderAttr(String name, int pos){
|
|
this.name = name;
|
|
this.pos = pos;
|
|
}
|
|
public String toString(){
|
|
return name;
|
|
}
|
|
private String name;
|
|
private int pos;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|