001package jmri.jmrit.logixng.expressions.swing; 002 003import java.awt.GridBagConstraints; 004import java.awt.GridBagLayout; 005import java.util.List; 006 007import javax.annotation.CheckForNull; 008import javax.annotation.Nonnull; 009import javax.swing.*; 010 011import jmri.*; 012import jmri.jmrit.logixng.*; 013import jmri.jmrit.logixng.expressions.ExpressionLocalVariable; 014import jmri.jmrit.logixng.expressions.ExpressionLocalVariable.CompareTo; 015import jmri.jmrit.logixng.expressions.ExpressionLocalVariable.VariableOperation; 016import jmri.jmrit.logixng.swing.SwingConfiguratorInterface; 017import jmri.jmrit.logixng.util.swing.LogixNG_SelectTableSwing; 018import jmri.util.CompareUtil.CompareType; 019import jmri.util.swing.BeanSelectPanel; 020import jmri.util.swing.JComboBoxUtil; 021 022/** 023 * Configures an ExpressionLocalVariable object with a Swing JPanel. 024 * 025 * @author Daniel Bergqvist Copyright 2021 026 */ 027public class ExpressionLocalVariableSwing extends AbstractDigitalExpressionSwing { 028 029 private LogixNG_SelectTableSwing selectTableSwing; 030 private JTextField _localVariableTextField; 031 private JComboBox<VariableOperation> _variableOperationComboBox; 032 private JComboBox<CompareType> _variableCompareTypeComboBox; 033 private JCheckBox _caseInsensitiveCheckBox; 034 035 private JTabbedPane _tabbedPane; 036 037 private JTabbedPane _tabbedPaneCompareTo; 038 private BeanSelectPanel<Memory> _compareToMemoryBeanPanel; 039 private JPanel _compareToConstant; 040 private JPanel _compareToMemory; 041 private JPanel _compareToLocalVariable; 042 private JPanel _compareToTable; 043 private JPanel _compareToRegEx; 044 private JTextField _compareToConstantTextField; 045 private JTextField _compareToLocalVariableTextField; 046 private JTextField _compareToRegExTextField; 047 048 049 private void enableDisableCompareTo() { 050 VariableOperation vo = _variableOperationComboBox.getItemAt( 051 _variableOperationComboBox.getSelectedIndex()); 052 boolean enable = vo.hasExtraValue(); 053 _tabbedPaneCompareTo.setEnabled(enable); 054 ((JPanel)_tabbedPaneCompareTo.getSelectedComponent()) 055 .getComponent(0).setEnabled(enable); 056 057 boolean regEx = (vo == VariableOperation.MatchRegex) 058 || (vo == VariableOperation.NotMatchRegex); 059 _tabbedPane.setEnabledAt(0, !regEx); 060 _tabbedPane.setEnabledAt(1, regEx); 061 _tabbedPane.setSelectedIndex(regEx ? 1 : 0); 062 } 063 064 @Override 065 protected void createPanel(@CheckForNull Base object, @Nonnull JPanel buttonPanel) { 066 067 ExpressionLocalVariable expression = (ExpressionLocalVariable)object; 068 069 selectTableSwing = new LogixNG_SelectTableSwing(getJDialog(), this); 070 071 panel = new JPanel(); 072 073 _localVariableTextField = new JTextField(20); 074 075 JPanel operationAndCasePanel = new JPanel(); 076 operationAndCasePanel.setLayout(new GridBagLayout()); 077 GridBagConstraints constraint = new GridBagConstraints(); 078 constraint.gridwidth = 2; 079 constraint.gridheight = 1; 080 constraint.gridx = 0; 081 constraint.gridy = 0; 082 constraint.anchor = GridBagConstraints.EAST; 083 084 _variableOperationComboBox = new JComboBox<>(); 085 for (VariableOperation e : VariableOperation.values()) { 086 _variableOperationComboBox.addItem(e); 087 } 088 JComboBoxUtil.setupComboBoxMaxRows(_variableOperationComboBox); 089 operationAndCasePanel.add(_variableOperationComboBox, constraint); 090 091 _variableOperationComboBox.addActionListener((e) -> { enableDisableCompareTo(); }); 092 093 constraint.gridy = 1; 094 operationAndCasePanel.add(javax.swing.Box.createVerticalStrut(8), constraint); 095 096 constraint.gridwidth = 1; 097 constraint.gridx = 0; 098 constraint.gridy = 2; 099 constraint.anchor = GridBagConstraints.EAST; 100 operationAndCasePanel.add(new JLabel(Bundle.getMessage("ExpressionLocalVariable_CompareType")+" "), constraint); 101 102 constraint.gridx = 1; 103 constraint.anchor = GridBagConstraints.WEST; 104 _variableCompareTypeComboBox = new JComboBox<>(); 105 for (CompareType e : CompareType.values()) { 106 _variableCompareTypeComboBox.addItem(e); 107 } 108 JComboBoxUtil.setupComboBoxMaxRows(_variableCompareTypeComboBox); 109 operationAndCasePanel.add(_variableCompareTypeComboBox, constraint); 110 111 _variableCompareTypeComboBox.addActionListener((e) -> { 112 CompareType type = _variableCompareTypeComboBox.getItemAt( 113 _variableCompareTypeComboBox.getSelectedIndex()); 114 _caseInsensitiveCheckBox.setEnabled(type != CompareType.Number); 115 }); 116 117 constraint.gridwidth = 2; 118 constraint.gridx = 0; 119 constraint.gridy = 3; 120 constraint.anchor = GridBagConstraints.WEST; 121 _caseInsensitiveCheckBox = new JCheckBox(Bundle.getMessage("ExpressionLocalVariable_CaseInsensitive")); 122 operationAndCasePanel.add(_caseInsensitiveCheckBox, constraint); 123 124 _tabbedPane = new JTabbedPane(); 125 126 _tabbedPaneCompareTo = new JTabbedPane(); 127 _tabbedPane.addTab("", _tabbedPaneCompareTo); 128 129 _compareToConstant = new JPanel(); 130 _compareToMemory = new JPanel(); 131 if (expression != null) { 132 _compareToTable = selectTableSwing.createPanel(expression.getSelectTable()); 133 } else { 134 _compareToTable = selectTableSwing.createPanel(null); 135 } 136 _compareToLocalVariable = new JPanel(); 137 _compareToRegEx = new JPanel(); 138 139 _tabbedPaneCompareTo.addTab(CompareTo.Value.toString(), _compareToConstant); 140 _tabbedPaneCompareTo.addTab(CompareTo.Memory.toString(), _compareToMemory); 141 _tabbedPaneCompareTo.addTab(CompareTo.LocalVariable.toString(), _compareToLocalVariable); 142 _tabbedPaneCompareTo.addTab(CompareTo.Table.toString(), _compareToTable); 143 144 _tabbedPane.addTab(CompareTo.RegEx.toString(), _compareToRegEx); 145 146 _compareToConstantTextField = new JTextField(30); 147 _compareToConstant.add(_compareToConstantTextField); 148 149 _compareToMemoryBeanPanel = new BeanSelectPanel<>(InstanceManager.getDefault(MemoryManager.class), null); 150 _compareToMemory.add(_compareToMemoryBeanPanel); 151 152 _compareToLocalVariableTextField = new JTextField(30); 153 _compareToLocalVariable.add(_compareToLocalVariableTextField); 154 155 _compareToRegExTextField = new JTextField(30); 156 _compareToRegEx.add(_compareToRegExTextField); 157 158 159 if (expression != null) { 160 if (expression.getLocalVariable() != null) { 161 _localVariableTextField.setText(expression.getLocalVariable()); 162 } 163 if (expression.getSelectMemoryNamedBean().getNamedBean() != null) { 164 _compareToMemoryBeanPanel.setDefaultNamedBean(expression.getSelectMemoryNamedBean().getNamedBean().getBean()); 165 } 166 switch (expression.getCompareTo()) { 167 case RegEx: 168 case Value: _tabbedPaneCompareTo.setSelectedComponent(_compareToConstant); break; 169 case Memory: _tabbedPaneCompareTo.setSelectedComponent(_compareToMemory); break; 170 case Table: _tabbedPaneCompareTo.setSelectedComponent(_compareToTable); break; 171 case LocalVariable: _tabbedPaneCompareTo.setSelectedComponent(_compareToLocalVariable); break; 172 default: throw new IllegalArgumentException("invalid _addressing state: " + expression.getCompareTo().name()); 173 } 174 _variableOperationComboBox.setSelectedItem(expression.getVariableOperation()); 175 _variableCompareTypeComboBox.setSelectedItem(expression.getCompareType()); 176 _caseInsensitiveCheckBox.setSelected(expression.getCaseInsensitive()); 177 _compareToConstantTextField.setText(expression.getConstantValue()); 178 _compareToLocalVariableTextField.setText(expression.getOtherLocalVariable()); 179 _compareToRegExTextField.setText(expression.getRegEx()); 180 } 181 182 JComponent[] components = new JComponent[]{ 183 _localVariableTextField, 184 operationAndCasePanel, 185 _tabbedPane 186 }; 187 188 List<JComponent> componentList = SwingConfiguratorInterface.parseMessage( 189 Bundle.getMessage("ExpressionLocalVariable_Components"), components); 190 191 for (JComponent c : componentList) panel.add(c); 192 193 enableDisableCompareTo(); 194 } 195 196 /** {@inheritDoc} */ 197 @Override 198 public boolean validate(@Nonnull List<String> errorMessages) { 199 // Create a temporary action to test formula 200 ExpressionLocalVariable expression = new ExpressionLocalVariable("IQDE1", null); 201 202 return selectTableSwing.validate(expression.getSelectTable(), errorMessages); 203 } 204 205 /** {@inheritDoc} */ 206 @Override 207 public MaleSocket createNewObject(@Nonnull String systemName, @CheckForNull String userName) { 208 ExpressionLocalVariable expression = new ExpressionLocalVariable(systemName, userName); 209 updateObject(expression); 210 return InstanceManager.getDefault(DigitalExpressionManager.class).registerExpression(expression); 211 } 212 213 /** {@inheritDoc} */ 214 @Override 215 public void updateObject(@Nonnull Base object) { 216 if (! (object instanceof ExpressionLocalVariable)) { 217 throw new IllegalArgumentException("object must be an ExpressionLocalVariable but is a: "+object.getClass().getName()); 218 } 219 ExpressionLocalVariable expression = (ExpressionLocalVariable)object; 220 221 expression.setLocalVariable(_localVariableTextField.getText()); 222 expression.setVariableOperation(_variableOperationComboBox.getItemAt(_variableOperationComboBox.getSelectedIndex())); 223 expression.setCompareType(_variableCompareTypeComboBox.getItemAt(_variableCompareTypeComboBox.getSelectedIndex())); 224 expression.setCaseInsensitive(_caseInsensitiveCheckBox.isSelected()); 225 226 227 if (!_compareToMemoryBeanPanel.isEmpty() 228 && (_tabbedPane.getSelectedComponent() == _tabbedPaneCompareTo) 229 && (_tabbedPaneCompareTo.getSelectedComponent() == _compareToMemory)) { 230 Memory otherMemory = _compareToMemoryBeanPanel.getNamedBean(); 231 if (otherMemory != null) { 232 NamedBeanHandle<Memory> handle 233 = InstanceManager.getDefault(NamedBeanHandleManager.class) 234 .getNamedBeanHandle(otherMemory.getDisplayName(), otherMemory); 235 expression.getSelectMemoryNamedBean().setNamedBean(handle); 236 } else { 237 expression.getSelectMemoryNamedBean().removeNamedBean(); 238 } 239 } else { 240 expression.getSelectMemoryNamedBean().removeNamedBean(); 241 } 242 243 if (_tabbedPane.getSelectedComponent() == _tabbedPaneCompareTo) { 244 if (_tabbedPaneCompareTo.getSelectedComponent() == _compareToConstant) { 245 expression.setCompareTo(CompareTo.Value); 246 expression.setConstantValue(_compareToConstantTextField.getText()); 247 } else if (_tabbedPaneCompareTo.getSelectedComponent() == _compareToMemory) { 248 expression.setCompareTo(CompareTo.Memory); 249 } else if (_tabbedPaneCompareTo.getSelectedComponent() == _compareToTable) { 250 expression.setCompareTo(CompareTo.Table); 251 } else if (_tabbedPaneCompareTo.getSelectedComponent() == _compareToLocalVariable) { 252 expression.setCompareTo(CompareTo.LocalVariable); 253 expression.setOtherLocalVariable(_compareToLocalVariableTextField.getText()); 254// } else if (_tabbedPaneCompareTo.getSelectedComponent() == _compareToRegEx) { 255// expression.setCompareTo(CompareTo.RegEx); 256// expression.setRegEx(_compareToRegExTextField.getText()); 257 } else { 258 throw new IllegalArgumentException("_tabbedPaneLight has unknown selection"); 259 } 260 } else { 261 expression.setCompareTo(CompareTo.RegEx); 262 expression.setRegEx(_compareToRegExTextField.getText()); 263 } 264 265 266 selectTableSwing.updateObject(expression.getSelectTable()); 267 } 268 269 /** {@inheritDoc} */ 270 @Override 271 public String toString() { 272 return Bundle.getMessage("LocalVariable_Short"); 273 } 274 275 /** {@inheritDoc} */ 276 @Override 277 public boolean canClose() { 278 return selectTableSwing.canClose(); 279 } 280 281 @Override 282 public void dispose() { 283 selectTableSwing.dispose(); 284 } 285 286 287// private final static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(ExpressionLocalVariableSwing.class); 288 289}