TrakEM2_/src/main/java/ini/trakem2/utils/OptionPanel.java

   1 package ini.trakem2.utils;
   2
   3 import java.awt.Color;
   4 import java.awt.Component;
   5 import java.awt.GridBagConstraints;
   6 import java.awt.GridBagLayout;
   7 import java.awt.event.ActionEvent;
   8 import java.awt.event.ActionListener;
   9 import java.awt.event.KeyAdapter;
  10 import java.awt.event.KeyEvent;
  11 import java.awt.event.KeyListener;
  12 import java.awt.event.MouseWheelEvent;
  13 import java.awt.event.MouseWheelListener;
  14 import java.lang.reflect.Field;
  15 import java.util.ArrayList;
  16 import java.util.HashMap;
  17 import java.util.List;
  18
  19 import javax.swing.JCheckBox;
  20 import javax.swing.JComboBox;
  21 import javax.swing.JLabel;
  22 import javax.swing.JPanel;
  23 import javax.swing.JTextField;
  24 import javax.swing.text.JTextComponent;
  25
  26 public class OptionPanel extends JPanel {
  27
  28         private static final long serialVersionUID = 1L;
  29         private GridBagLayout bl = new GridBagLayout();
  30         private GridBagConstraints c = new GridBagConstraints();
  31
  32         private ActionListener tl = new ActionListener() {
  33                 public void actionPerformed(ActionEvent ae) {
  34                         Component source = (Component) ae.getSource();
  35                         try {
  36                                 Setter s = setters.get(source);
  37                                 if (null != s) s.setFrom(source);
  38                         } catch (Exception e) {
  39                                 Utils.log2("Invalid value!");
  40                         }
  41                 }
  42         };
  43
  44         private KeyListener kl = new KeyAdapter() {
  45                 public void keyReleased(KeyEvent ke) {
  46                         Component source = (Component) ke.getSource();
  47                         try {
  48                                 Setter s = setters.get(source);
  49                                 if (null != s) s.setFrom(source);
  50                         } catch (Throwable t) {
  51                                 Utils.logAll("Invalid value " + ((JTextField)source).getText());
  52                         }
  53                 }
  54         };
  55
  56         private MouseWheelListener mwl = new MouseWheelListener() {
  57                 @Override
  58                 public void mouseWheelMoved(MouseWheelEvent mwe) {
  59                         Component source = (Component) mwe.getSource();
  60                         try {
  61                                 Setter s = setters.get(source);
  62                                 if (s instanceof NumericalSetter) {
  63                                         if (null != s) {
  64                                                 // Update the value of the field and also of the JTextField
  65                                                 ((JTextField)source).setText(((NumericalSetter)s).setFrom(source, mwe.getWheelRotation()).toString());
  66                                         }
  67                                 }
  68                         } catch (Throwable t) {
  69                                 Utils.logAll("Invalid value " + ((JTextField)source).getText());
  70                         }
  71                 }
  72         };
  73
  74         public OptionPanel() {
  75                 super();
  76                 setLayout(bl);
  77                 c.ipady = 10;
  78         }
  79
  80         private List<JTextField> numeric_fields = new ArrayList<JTextField>();
  81         private List<JCheckBox> checkboxes = new ArrayList<JCheckBox>();
  82         private List<JComboBox> choices = new ArrayList<JComboBox>();
  83         private List<Component> all = new ArrayList<Component>();
  84         private HashMap<Component,Setter> setters = new HashMap<Component,Setter>();
  85
  86         private int rows = 0;
  87
  88         public void addMessage(String text) {
  89                 JLabel label = new JLabel(text);
  90                 c.gridy = rows++;
  91                 c.gridx = 0;
  92                 c.anchor = GridBagConstraints.NORTHWEST;
  93                 c.weightx = 1;
  94                 c.weighty = 0;
  95                 c.gridwidth = 2;
  96                 c.fill = GridBagConstraints.NONE;
  97                 bl.setConstraints(label, c);
  98                 add(label);
  99         }
 100
 101         public void bottomPadding() {
 102                 c.gridy = rows++;
 103                 c.gridx = 0;
 104                 c.anchor = GridBagConstraints.NORTHWEST;
 105                 c.fill = GridBagConstraints.BOTH;
 106                 c.weightx = 1;
 107                 c.weighty = 1;
 108                 JPanel space = new JPanel();
 109                 bl.setConstraints(space, c);
 110                 add(space);
 111         }
 112
 113         /** The left-side label of a field. */
 114         private void addLabel(String label) {
 115                 c.gridy = rows++;
 116                 c.gridx = 0;
 117                 JLabel l = new JLabel(label);
 118                 c.anchor = GridBagConstraints.NORTHEAST;
 119                 c.weightx = 1;
 120                 c.weighty = 0;
 121                 c.ipadx = 10;
 122                 c.gridwidth = 1;
 123                 c.fill = GridBagConstraints.NONE;
 124                 bl.setConstraints(l, c);
 125                 add(l);
 126         }
 127
 128         /** The right-side field of a label. */
 129         private void addField(Component comp, Setter setter) {
 130                 c.gridx = 1;
 131                 c.weightx = 0;
 132                 c.anchor = GridBagConstraints.NORTHWEST;
 133                 c.ipadx = 0;
 134                 c.gridwidth = 1;
 135                 c.fill = GridBagConstraints.HORIZONTAL;
 136                 bl.setConstraints(comp, c);
 137                 add(comp);
 138                 setters.put(comp, setter);
 139         }
 140
 141         public JTextField addNumericField(String label, double value, int digits) {
 142                 return addNumericField(label, value, digits, null);
 143         }
 144
 145         public JTextField addNumericField(String label, double value, int digits, Setter setter) {
 146                 return addNumericField(label, Utils.cutNumber(value, digits), setter);
 147         }
 148
 149         public JTextField addNumericField(String label, int value) {
 150                 return addNumericField(label, value, null);
 151         }
 152
 153         public JTextField addNumericField(String label, int value, Setter setter) {
 154                 return addNumericField(label, Integer.toString(value), setter);
 155         }
 156
 157         private JTextField addNumericField(String label, String value, Setter setter) {
 158                 addLabel(label);
 159                 JTextField tval = new JTextField(value, 7);
 160                 numeric_fields.add(tval);
 161                 addField(tval, setter);
 162                 tval.addKeyListener(kl);
 163                 tval.addMouseWheelListener(mwl);
 164                 return tval;
 165         }
 166
 167         public JCheckBox addCheckbox(String label, boolean selected) {
 168                 return addCheckbox(label, selected, null);
 169         }
 170
 171         public JCheckBox addCheckbox(String label, boolean selected, Setter setter) {
 172                 addLabel(label);
 173                 JCheckBox cb = new JCheckBox();
 174                 cb.setSelected(selected);
 175                 checkboxes.add(cb);
 176                 all.add(cb);
 177                 addField(cb, setter);
 178                 cb.addActionListener(tl);
 179                 return cb;
 180         }
 181
 182         public JComboBox addChoice(String label, String[] items, int selected) {
 183                 return addChoice(label, items, selected, null);
 184         }
 185
 186         public JComboBox addChoice(String label, String[] items, int selected, Setter setter) {
 187                 addLabel(label);
 188                 JComboBox choice = new JComboBox(items);
 189                 choice.setBackground(Color.white);
 190                 choice.setSelectedIndex(selected);
 191                 choice.addActionListener(tl);
 192                 all.add(choice);
 193                 addField(choice, setter);
 194                 return choice;
 195         }
 196
 197
 198
 199         public List<JTextField> getNumericFields() {
 200                 return new ArrayList<JTextField>(numeric_fields);
 201         }
 202
 203         /** May throw IllegalArgumentException or NumberFormatException */
 204         public double getNumber(int index) throws Exception {
 205                 check(numeric_fields, index);
 206                 return Double.parseDouble(numeric_fields.get(index).getText());
 207         }
 208
 209         public List<JCheckBox> getCheckBoxes() {
 210                 return new ArrayList<JCheckBox>(checkboxes);
 211         }
 212
 213         /** May throw IllegalArgumentException */
 214         public boolean getCheckbox(int index) throws Exception {
 215                 check(checkboxes, index);
 216                 return checkboxes.get(index).isSelected();
 217         }
 218
 219         public List<JComboBox> getChoices() {
 220                 return new ArrayList<JComboBox>(choices);
 221         }
 222
 223         public int getChoiceIndex(int index) throws Exception {
 224                 check(choices, index);
 225                 return choices.get(index).getSelectedIndex();
 226         }
 227
 228         public String getChoiceString(int index) throws Exception {
 229                 return getChoiceObject(index).toString();
 230         }
 231
 232         public Object getChoiceObject(int index) throws Exception {
 233                 check(choices, index);
 234                 return choices.get(index).getSelectedItem();
 235         }
 236
 237
 238         private void check(List<?> list, int index) throws Exception {
 239                 if (index < 0 || index > list.size() -1) throw new IllegalArgumentException("Index out of bounds: " + index);
 240         }
 241
 242         static abstract public class Setter {
 243                 protected final Object ob;
 244                 protected final String field;
 245                 protected Runnable reaction;
 246                 public Setter(Object ob, String field) {
 247                         this.ob = ob;
 248                         this.field = field;
 249                 }
 250                 public Setter(Object ob, String field, Runnable reaction) {
 251                         this(ob, field);
 252                         this.reaction = reaction;
 253                 }
 254                 /** Will set the field if no exception is thrown when reading it. */
 255                 public void setFrom(Component source) throws Exception {
 256                         Field f = ob.getClass().getDeclaredField(field);
 257                         f.setAccessible(true);
 258                         f.set(ob, getValue(source));
 259
 260                         //Utils.log2("set value of " + field + " to " + f.get(ob));
 261
 262                         if (null != reaction) reaction.run();
 263                 }
 264                 abstract public Object getValue(Component source);
 265         }
 266
 267         static abstract public class NumericalSetter extends Setter {
 268                 protected int min = Integer.MIN_VALUE,
 269                                           max = Integer.MAX_VALUE;
 270                 public NumericalSetter(Object ob, String field) {
 271                         super(ob, field);
 272                 }
 273                 public NumericalSetter(Object ob, String field, Runnable reaction) {
 274                         super(ob, field, reaction);
 275                 }
 276                 public NumericalSetter(Object ob, String field, Runnable reaction, int min, int max) {
 277                         super(ob, field, reaction);
 278                         this.min = min;
 279                         this.max = max;
 280                 }
 281                 public Object setFrom(Component source, int inc) throws Exception {
 282                         Field f = ob.getClass().getDeclaredField(field);
 283                         f.setAccessible(true);
 284                         Object val = getValue(source, inc);
 285                         f.set(ob, val);
 286
 287                         Utils.log2("set value of " + field + " to " + f.get(ob));
 288
 289                         if (null != reaction) reaction.run();
 290
 291                         return val;
 292                 }
 293                 abstract protected Object getValue(Component source, int inc);
 294         }
 295
 296         static public class IntSetter extends NumericalSetter {
 297                 public IntSetter(Object ob, String field) {
 298                         super(ob, field);
 299                 }
 300                 public IntSetter(Object ob, String field, Runnable reaction) {
 301                         super(ob, field, reaction);
 302                 }
 303                 public IntSetter(Object ob, String field, Runnable reaction, int min, int max) {
 304                         super(ob, field, reaction, min, max);
 305                 }
 306                 public Object getValue(Component source) {
 307                         return (int) Double.parseDouble(((JTextField)source).getText());
 308                 }
 309                 protected Object getValue(Component source, int inc) {
 310                         int val = ((int) Double.parseDouble(((JTextField)source).getText())) + inc;
 311                         if (val < this.min) return this.min;
 312                         if (val > this.max) return this.max;
 313                         return val;
 314                 }
 315         }
 316
 317         static public class DoubleSetter extends NumericalSetter {
 318                 public DoubleSetter(Object ob, String field) {
 319                         super(ob, field);
 320                 }
 321                 public DoubleSetter(Object ob, String field, Runnable reaction) {
 322                         super(ob, field, reaction);
 323                 }
 324                 public DoubleSetter(Object ob, String field, Runnable reaction, int min, int max) {
 325                         super(ob, field, reaction, min, max);
 326                 }
 327                 public Object getValue(Component source) {
 328                         return Double.parseDouble(((JTextField)source).getText());
 329                 }
 330                 protected Object getValue(Component source, int inc) {
 331                         double val = Double.parseDouble(((JTextField)source).getText()) + inc;
 332                         if (val < this.min) return (double)this.min;
 333                         if (val > this.max) return (double)this.max;
 334                         return val;
 335                 }
 336         }
 337
 338         static public class FloatSetter extends NumericalSetter {
 339                 public FloatSetter(Object ob, String field) {
 340                         super(ob, field);
 341                 }
 342                 public FloatSetter(Object ob, String field, Runnable reaction) {
 343                         super(ob, field, reaction);
 344                 }
 345                 public FloatSetter(Object ob, String field, Runnable reaction, int min, int max) {
 346                         super(ob, field, reaction, min, max);
 347                 }
 348                 public Object getValue(Component source) {
 349                         return Float.parseFloat(((JTextField)source).getText());
 350                 }
 351                 public Object getValue(Component source, int inc) {
 352                         float val = Float.parseFloat(((JTextField)source).getText()) + inc;
 353                         if (val < this.min) return (float)this.min;
 354                         if (val > this.max) return (float)this.max;
 355                         return val;
 356                 }
 357         }
 358
 359         static public class BooleanSetter extends Setter {
 360                 public BooleanSetter(Object ob, String field) {
 361                         super(ob, field);
 362                 }
 363                 public BooleanSetter(Object ob, String field, Runnable reaction) {
 364                         super(ob, field, reaction);
 365                 }
 366                 public Object getValue(Component source) {
 367                         return ((JCheckBox)source).isSelected();
 368                 }
 369         }
 370
 371         static public class StringSetter extends Setter {
 372                 public StringSetter(Object ob, String field) {
 373                         super(ob, field);
 374                 }
 375                 public StringSetter(Object ob, String field, Runnable reaction) {
 376                         super(ob, field, reaction);
 377                 }
 378                 public Object getValue(Component source) {
 379                         return ((JTextComponent)source).getText();
 380                 }
 381         }
 382
 383         static public class ChoiceIntSetter extends Setter {
 384                 public ChoiceIntSetter(Object ob, String field) {
 385                         super(ob, field);
 386                 }
 387                 public ChoiceIntSetter(Object ob, String field, Runnable reaction) {
 388                         super(ob, field, reaction);
 389                 }
 390                 public Object getValue(Component source) {
 391                         return ((JComboBox)source).getSelectedIndex();
 392                 }
 393         }
 394
 395         static public class ChoiceStringSetter extends Setter {
 396                 public ChoiceStringSetter(Object ob, String field) {
 397                         super(ob, field);
 398                 }
 399                 public ChoiceStringSetter(Object ob, String field, Runnable reaction) {
 400                         super(ob, field, reaction);
 401                 }
 402                 public Object getValue(Component source) {
 403                         return ((JComboBox)source).getSelectedItem().toString();
 404                 }
 405         }
 406
 407         static public class ChoiceObjectSetter extends Setter {
 408                 public ChoiceObjectSetter(Object ob, String field) {
 409                         super(ob, field);
 410                 }
 411                 public ChoiceObjectSetter(Object ob, String field, Runnable reaction) {
 412                         super(ob, field, reaction);
 413                 }
 414                 public Object getValue(Component source) {
 415                         return ((JComboBox)source).getSelectedItem();
 416                 }
 417         }
 418 }