PageRenderTime 32ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 1ms

/code/UDPEditor.java

http://silkin.googlecode.com/
Java | 1011 lines | 946 code | 38 blank | 27 comment | 275 complexity | 02a63b33c196303ee47a59f850cd2c57 MD5 | raw file
    

  1. 

  2. 

  3. import java.util.* ;
    4. 

  4. import java.awt.*;
    5. 

  5. import java.awt.event.*;
    6. 

  6. import javax.swing.*;
    7. 

  7. import javax.swing.event.*;
    8. 

  8. import java.beans.*;
    9. 

  9. 

  10. /** 
    11. 

  11. The UDPEditor is a window that displays a {@link UserDefinedProperty}'s fields for  editing.
    12. 

  12. It is an extension of KSJInternalFrame because I want this to appear in the View menu.
    13. 

    14. 

  14. @author		Gary Morris, Northern Virginia Community College		garymorris2245@verizon.net
    15. 

  15. */
    16. 

  16. 	
    17. 

  17. 	public class UDPEditor extends KSJInternalFrame  {
    18. 

  18. 			
    19. 

  19. 		public Context ctxt;
    20. 

  20. 		public KSJInternalFrame ctxtEd;
    21. 

  21. 		public boolean newUDP, newSingleValue, validValsChanged = false, defaultValExists = false;
    22. 

  22. 		public UserDefinedProperty theUDP;	//  The various newxxx fields are holders for the
    23. 

  23. 		public String newStarName, newType; //  new values entered into this editor.
    24. 

  24. 		public ArrayList<Object> newValidEntries;   //  After validation, they'll be stored on theUDP.
    25. 

  25. 		Number newMinVal, newMaxVal;
    26. 

  26. 		Object newDefaultValue;
    27. 

  27. 		UDPListener listener;
    28. 

  28. 		JComboBox typePick;
    29. 

  29. 		JRadioButton nocertain, yescertain, yesdefault, nodefault, nomulti; 
    30. 

  30. 		JTextField name_1, certainText, defaultText, minText, maxText;
    31. 

  31. 		JLabel certainEditLabel, defeditLabel;
    32. 

  32. 		JButton udpCheckSave;
    33. 

  33. 		JProgressBar progressBar;			//  These 2 elements of the editor GUI are accessed 
    34. 

  34. 		JPanel progBox;						//  by the Listener
    35. 

  35. 		
    36. 

  36. 		public UDPEditor(Context cntxt, KSJInternalFrame ctEd, String title, boolean newUDPee, 
    37. 

  37. 						UserDefinedProperty theUDPee)  {
    38. 

  38. 			super(title);
    39. 

  39. 			ctxt = cntxt;
    40. 

  40. 			ctxtEd = ctEd;
    41. 

  41. 			newUDP = newUDPee;
    42. 

  42. 			theUDP = theUDPee;
    43. 

  43. 			if (newUDP) windowNum = "Add a UDP";
    44. 

  44. 			else windowNum = "UDP Editor: " + theUDP.starName;
    45. 

  45. 			setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    46. 

  46. 			addInternalFrameListener(this);  // allows View Menu to work
    47. 

  47. 			listener = new UDPListener(this);
    48. 

  48. 			
    49. 

  49. 			JPanel editor = new JPanel();
    50. 

  50. 			editor.setLayout(new BoxLayout(editor, BoxLayout.PAGE_AXIS));
    51. 

  51. 			
    52. 

  52. 			//  NAME BOX
    53. 

  53. 			JPanel nameBox = new JPanel();
    54. 

  54. 			nameBox.setLayout(new BoxLayout(nameBox, BoxLayout.LINE_AXIS));
    55. 

  55. 			name_1 = new JTextField("*", 28);
    56. 

  56. 			if (! newUDP) name_1.setText(theUDP.starName);
    57. 

  57. 			name_1.setMaximumSize(new Dimension(225, 22));
    58. 

  58. 			name_1.addActionListener(listener);
    59. 

  59. 			name_1.setActionCommand("name edit");
    60. 

  60. 			JLabel nameLabel = new JLabel("UDP Name: ");
    61. 

  61. 			nameBox.add(nameLabel);
    62. 

  62. 			nameBox.add(name_1);
    63. 

  63. 			JPanel nameEdBox = new JPanel();
    64. 

  64. 			nameEdBox.setLayout(new BoxLayout(nameEdBox, BoxLayout.PAGE_AXIS));
    65. 

  65. 			nameBox.setAlignmentX(0.5f);
    66. 

  66. 			String lab;
    67. 

  67. 			if (newUDP) lab = "Enter name (starting with '*'), hit 'Enter' key.";
    68. 

  68. 			else lab = "Edit name, then press 'Enter' key.";
    69. 

  69. 			JLabel nameEdLabel = new JLabel(lab);
    70. 

  70. 			nameEdLabel.setAlignmentX(0.5f);
    71. 

  71.             nameEdLabel.setMaximumSize(new Dimension(300, 22));
    72. 

  72. 			nameEdBox.add(nameBox);
    73. 

  73. 			nameEdBox.add(nameEdLabel);
    74. 

  74. 			nameEdBox.setAlignmentX(0.5f);
    75. 

  75. 			editor.add(nameEdBox);
    76. 

  76. 			
    77. 

  77. 			//  DATA TYPE
    78. 

  78. 			JPanel dTypeBox = new JPanel();
    79. 

  79. 			dTypeBox.setLayout(new BoxLayout(dTypeBox, BoxLayout.LINE_AXIS));
    80. 

  80. 			JLabel typeLabel = new JLabel("Data Type: ");
    81. 

  81. 			Dimension sizer = new Dimension(150, 50);
    82. 

  82. 			String[] typeMenu = {"String", "Integer", "Real Number", "Boolean", "Person"};
    83. 

  83. 			typePick = new JComboBox(typeMenu);
    84. 

  84. 			if (newUDP) {
    85. 

  85. 				typePick.setSelectedIndex(0);
    86. 

  86. 				newType = "string";
    87. 

  87. 				}
    88. 

  88. 			else {
    89. 

  89. 				if (theUDP.typ.equals("integer")) typePick.setSelectedIndex(1);
    90. 

  90. 				else if (theUDP.typ.equals("float")) typePick.setSelectedIndex(2);
    91. 

  91. 				else if (theUDP.typ.equals("string")) typePick.setSelectedIndex(0);
    92. 

  92. 				else if (theUDP.typ.equals("boolean")) typePick.setSelectedIndex(3);
    93. 

  93. 				else typePick.setSelectedIndex(4);
    94. 

  94. 				newType = theUDP.typ;
    95. 

  95. 				}  //  end of setting the current data type
    96. 

  96. 			typePick.addActionListener(listener); 
    97. 

  97. 			typePick.setActionCommand("data type");
    98. 

  98. 			typePick.setMinimumSize(sizer);
    99. 

  99. 			typePick.setMaximumSize(sizer);
    100. 

  100. 			dTypeBox.add(typeLabel);
    101. 

  101. 			dTypeBox.add(typePick);
    102. 

  102. 			editor.add(Box.createRigidArea(new Dimension(0,4)));
    103. 

  103. 			editor.add(dTypeBox);
    104. 

  104. 			
    105. 

  105. 			//  MULTIPLE VALUES?
    106. 

  106. 			JPanel multiBox = new JPanel();
    107. 

  107. 			multiBox.setLayout(new BoxLayout(multiBox, BoxLayout.LINE_AXIS));
    108. 

  108. 			JLabel multiLabel = new JLabel("Multiple Values?");
    109. 

  109. 			JRadioButton yesmulti = new JRadioButton("Yes");
    110. 

  110. 			yesmulti.setActionCommand("multiVal yes");
    111. 

  111. 			yesmulti.addActionListener(listener);
    112. 

  112. 			nomulti = new JRadioButton("No");
    113. 

  113. 			nomulti.setActionCommand("multiVal no");
    114. 

  114. 			nomulti.addActionListener(listener);
    115. 

  115. 			if (theUDP.singleValue) nomulti.setSelected(true);
    116. 

  116. 			else yesmulti.setSelected(true);
    117. 

  117. 			newSingleValue = theUDP.singleValue;
    118. 

  118. 			ButtonGroup multiBtns = new ButtonGroup();
    119. 

  119. 			multiBtns.add(yesmulti);
    120. 

  120. 			multiBtns.add(nomulti);
    121. 

  121. 			multiBox.add(multiLabel);
    122. 

  122. 			multiBox.add(yesmulti);
    123. 

  123. 			multiBox.add(nomulti);
    124. 

  124. 			editor.add(Box.createRigidArea(new Dimension(0,4)));
    125. 

  125. 			editor.add(multiBox);
    126. 

  126. 			
    127. 

  127. 			//  RESTRICTED TO CERTAIN VALUES?
    128. 

  128. 			JPanel certainBox = new JPanel();
    129. 

  129. 			certainBox.setLayout(new BoxLayout(certainBox, BoxLayout.LINE_AXIS));
    130. 

  130. 			JLabel certainLabel = new JLabel("Restricted to Certain Values?");
    131. 

  131. 			yescertain = new JRadioButton("Yes");
    132. 

  132. 			yescertain.setActionCommand("certainVal yes");
    133. 

  133. 			yescertain.addActionListener(listener);
    134. 

  134. 			nocertain = new JRadioButton("No");
    135. 

  135. 			nocertain.setActionCommand("certainVal no");
    136. 

  136. 			nocertain.addActionListener(listener);
    137. 

  137. 			if (newUDP || (theUDP.validEntries == null) 
    138. 

  138. 				|| (theUDP.validEntries.isEmpty()) || (newType.equals("individual"))) 
    139. 

  139. 				nocertain.setSelected(true);
    140. 

  140. 			else yescertain.setSelected(true);
    141. 

  141. 			newValidEntries = theUDP.validEntries;
    142. 

  142. 			ButtonGroup certainBtns = new ButtonGroup();
    143. 

  143. 			certainBtns.add(yescertain);
    144. 

  144. 			certainBtns.add(nocertain);
    145. 

  145. 			certainBox.add(certainLabel);
    146. 

  146. 			certainBox.add(yescertain);
    147. 

  147. 			certainBox.add(nocertain);
    148. 

  148. 			
    149. 

  149. 			certainText = new JTextField();
    150. 

  150. 			certainText.setMinimumSize(new Dimension(400, 30));
    151. 

  151. 			certainText.setMaximumSize(new Dimension(400, 30));
    152. 

  152. 			certainText.setAlignmentX(0.5f);
    153. 

  153. 			certainEditLabel = new JLabel();
    154. 

  154. 			certainEditLabel.setAlignmentX(0.5f);
    155. 

  155. 			if (newUDP || (theUDP.validEntries == null) || (theUDP.validEntries.isEmpty())) {
    156. 

  156. 				certainText.setText("");
    157. 

  157. 				certainEditLabel.setText("");
    158. 

  158. 				certainText.setEditable(false);
    159. 

  159. 			}else {
    160. 

  160. 				certainText.setEditable(true);
    161. 

  161. 				certainEditLabel.setText("Edit list of values, then hit 'Enter'.");
    162. 

  162. 				newValidEntries = theUDP.validEntries;
    163. 

  163. 				certainText.setText(theUDP.getValidEntriesString());
    164. 

  164. 				certainText.addActionListener(listener);
    165. 

  165. 				certainText.setActionCommand("certainText edit");
    166. 

  166. 				}  //  end of it's restricted
    167. 

  167. 			editor.add(Box.createRigidArea(new Dimension(0,4)));
    168. 

  168. 			editor.add(certainBox);
    169. 

  169. 			editor.add(Box.createRigidArea(new Dimension(0,4)));
    170. 

  170. 			editor.add(certainEditLabel);
    171. 

  171. 			editor.add(certainText);
    172. 

  172. 			
    173. 

  173. 			//  DEFAULT VALUE
    174. 

  174. 			JPanel defaultBox = new JPanel();
    175. 

  175. 			defaultBox.setLayout(new BoxLayout(defaultBox, BoxLayout.LINE_AXIS));
    176. 

  176. 			JLabel defaultLabel = new JLabel("Is There A Default Value?");
    177. 

  177. 			yesdefault = new JRadioButton("Yes");
    178. 

  178. 			yesdefault.setActionCommand("defaultVal yes");
    179. 

  179. 			yesdefault.addActionListener(listener);
    180. 

  180. 			nodefault = new JRadioButton("No");
    181. 

  181. 			nodefault.setActionCommand("defaultVal no");
    182. 

  182. 			nodefault.addActionListener(listener);
    183. 

  183. 			nodefault.setSelected(true);
    184. 

  184. 			ButtonGroup defaultBtns = new ButtonGroup();
    185. 

  185. 			defaultBtns.add(yesdefault);
    186. 

  186. 			defaultBtns.add(nodefault);
    187. 

  187. 			defaultBox.add(defaultLabel);
    188. 

  188. 			defaultBox.add(yesdefault);
    189. 

  189. 			defaultBox.add(nodefault);
    190. 

  190. 			defaultText = new JTextField();
    191. 

  191. 			defaultText.setMinimumSize(new Dimension(400, 30));
    192. 

  192. 			defaultText.setMaximumSize(new Dimension(400, 30));
    193. 

  193. 			defaultText.setAlignmentX(0.5f);
    194. 

  194. 			defeditLabel = new JLabel();
    195. 

  195. 			defeditLabel.setAlignmentX(0.5f);
    196. 

  196. 			if (newUDP || (theUDP.defaultValue == null)) {
    197. 

  197. 				defaultText.setText("");
    198. 

  198. 				defeditLabel.setText("");
    199. 

  199. 				defaultText.setEditable(false);
    200. 

  200.                 defaultValExists = false;
    201. 

  201. 			}else {
    202. 

  202. 				defaultText.setEditable(true);
    203. 

  203. 				defeditLabel.setText("Edit the default value, then hit 'Enter'.");
    204. 

  204. 				newDefaultValue = theUDP.defaultValue;
    205. 

  205. 				yesdefault.setSelected(true);
    206. 

  206. 				defaultText.setText(theUDP.defaultValue.toString());
    207. 

  207. 				defaultText.addActionListener(listener);
    208. 

  208. 				defaultText.setActionCommand("defaultText edit");
    209. 

  209.                 defaultValExists = true;
    210. 

  210. 				}  //  end of there is a default value
    211. 

  211. 			editor.add(Box.createRigidArea(new Dimension(0,4)));
    212. 

  212. 			editor.add(defaultBox);
    213. 

  213. 			editor.add(Box.createRigidArea(new Dimension(0,4)));
    214. 

  214. 			editor.add(defeditLabel);
    215. 

  215. 			editor.add(defaultText);
    216. 

  216. 			
    217. 

  217. 			//  MIN AND MAX VALUES
    218. 

  218. 			JPanel minMaxBox = new JPanel();
    219. 

  219. 			minMaxBox.setLayout(new BoxLayout(minMaxBox, BoxLayout.LINE_AXIS));
    220. 

  220. 			JLabel minLabel = new JLabel("Minimum Value: ");
    221. 

  221. 			minText = new JTextField();
    222. 

  222. 			minText.setMinimumSize(new Dimension(50, 30));
    223. 

  223. 			minText.setMaximumSize(new Dimension(50, 30));
    224. 

  224. 			if (theUDP.minVal == null) minText.setText("");
    225. 

  225. 				else minText.setText(theUDP.minVal.toString());
    226. 

  226. 			minText.addActionListener(listener);
    227. 

  227. 			minText.setActionCommand("minText edit");
    228. 

  228. 			minMaxBox.add(minLabel);
    229. 

  229. 			minMaxBox.add(minText);
    230. 

  230. 			JPanel maxBox = new JPanel();
    231. 

  231. 			maxBox.setLayout(new BoxLayout(maxBox, BoxLayout.PAGE_AXIS));
    232. 

  232. 			JLabel maxLabel = new JLabel("Maximum Value: ");
    233. 

  233. 			maxText = new JTextField();
    234. 

  234. 			maxText.setMinimumSize(new Dimension(50, 30));
    235. 

  235. 			maxText.setMaximumSize(new Dimension(50, 30));
    236. 

  236. 			if (theUDP.maxVal == null) maxText.setText("");
    237. 

  237. 				else maxText.setText(theUDP.maxVal.toString());
    238. 

  238. 			maxText.addActionListener(listener);
    239. 

  239. 			maxText.setActionCommand("maxText edit");
    240. 

  240. 			if (((String)typePick.getSelectedItem()).equals("Integer") || ((String)typePick.getSelectedItem()).equals("Real Number"))	{
    241. 

  241. 				minText.setEditable(true);
    242. 

  242. 				maxText.setEditable(true);
    243. 

  243. 			}else {
    244. 

  244. 				minText.setEditable(false);
    245. 

  245. 				maxText.setEditable(false);
    246. 

  246. 				}
    247. 

  247. 			minMaxBox.add(Box.createRigidArea(new Dimension(50, 0)));
    248. 

  248. 			minMaxBox.add(maxLabel);
    249. 

  249. 			minMaxBox.add(maxText);
    250. 

  250. 			editor.add(Box.createRigidArea(new Dimension(0,4)));
    251. 

  251. 			editor.add(minMaxBox);
    252. 

  252. 			
    253. 

  253. 			//  BUTTONS AT THE BOTTOM
    254. 

  254. 			JPanel bottomBtns = new JPanel();
    255. 

  255. 			bottomBtns.setLayout(new BoxLayout(bottomBtns, BoxLayout.LINE_AXIS));
    256. 

  256. 			JButton udpCancel = new JButton("Cancel");
    257. 

  257. 			udpCancel.setActionCommand("cancel");
    258. 

  258. 			udpCancel.addActionListener(listener);
    259. 

  259. 			bottomBtns.add(udpCancel);
    260. 

  260. 			if (! newUDP) {  //  no need to delete a UDP being created -- just cancel
    261. 

  261. 				JButton udpDelete = new JButton("Delete UDP");
    262. 

  262. 				udpDelete.setActionCommand("delete");
    263. 

  263. 				udpDelete.addActionListener(listener);
    264. 

  264. 				bottomBtns.add(udpDelete);
    265. 

  265. 				}
    266. 

  266. 			udpCheckSave = new JButton("Check for Errors");
    267. 

  267. 			udpCheckSave.setActionCommand("check");
    268. 

  268. 			udpCheckSave.addActionListener(listener);
    269. 

  269. 			bottomBtns.add(udpCheckSave);
    270. 

  270. 			editor.add(Box.createRigidArea(new Dimension(0,6)));
    271. 

  271. 			editor.add(bottomBtns);
    272. 

  272. 			
    273. 

  273. 			progBox = new JPanel();
    274. 

  274. 			progBox.setLayout(new BoxLayout(progBox, BoxLayout.PAGE_AXIS));
    275. 

  275. 			String progMod = " revised UDP.";
    276. 

  276. 			if (newUDP) progMod = " new UDP.";
    277. 

  277. 			JLabel progLabel = new JLabel("Updating " + ctxt.indSerNumGen + " persons with the" + progMod);
    278. 

  278. 			progressBar = new JProgressBar(0, ctxt.indSerNumGen);
    279. 

  279. 			progressBar.setValue(0);
    280. 

  280. 			progressBar.setStringPainted(true);
    281. 

  281. 			progBox.add(progLabel);
    282. 

  282. 			progBox.add(progressBar);
    283. 

  283. 			//  progBox.setVisible(false);
    284. 

  284. 			editor.add(Box.createRigidArea(new Dimension(0,6)));
    285. 

  285. 			editor.add(progBox);
    286. 

  286. 			
    287. 

  287. 			JPanel sideFrame = new JPanel();
    288. 

  288. 			sideFrame.setLayout(new BoxLayout(sideFrame, BoxLayout.LINE_AXIS));
    289. 

  289. 			sideFrame.add(Box.createRigidArea(new Dimension(10,0)));
    290. 

  290. 			sideFrame.add(editor);
    291. 

  291. 			sideFrame.add(Box.createRigidArea(new Dimension(10,0)));
    292. 

  292. 			getContentPane().add(sideFrame);
    293. 

  293. 			addInternalFrameListener(this);
    294. 

  294. 			setSize(420, 400);
    295. 

  295. 			setVisible(true);
    296. 

  296. 			}  //  end of UDPEditor constructor
    297. 

  297. 		
    298. 

  298. 	public class UDPListener implements ActionListener  {
    299. 

  299. 	
    300. 

  300. 		KSJInternalFrame ed;
    301. 

  301. 		boolean reName = false;
    302. 

  302. 		
    303. 

  303. 		public UDPListener(KSJInternalFrame uded)  {
    304. 

  304. 			ed = uded;
    305. 

  305. 			}  //  end of constructor
    306. 

  306. 		
    307. 

  307. 		public void actionPerformed(ActionEvent e) {
    308. 

  308. 			 if (e.getActionCommand().equals("name edit"))  {
    309. 

  309. 				String newName = name_1.getText(), msg;
    310. 

  310. 				if (! Library.validateFileName(newName, true)) {
    311. 

  311. 					msg = "The name '" + newName + "' violates the rules for names:\n"
    312. 

  312. 						+ "The name MUST start with a star ('*') and a letter.\n" +
    313. 

  313. 						"Use up to 28 LETTERS, NUMBERS, or DASHES (-) but NO SPACES.";
    314. 

  314. 					JOptionPane.showMessageDialog(ed, msg, "Violation of Naming Rules", 
    315. 

  315. 						JOptionPane.WARNING_MESSAGE);
    316. 

  316. 					flipFinalBtn("check");
    317. 

  317. 					return; 
    318. 

  318. 					}
    319. 

  319. 				//  Once past activity-check, we can safely record the new starName
    320. 

  320. 				newStarName = newName;
    321. 

  321. 				if ((! newUDP) && (! newStarName.equals(theUDP.starName)))  {  //  name change
    322. 

  322. 					int numWithProp = 0, numWithVals = 0;
    323. 

  323. 					Iterator indIter = ctxt.individualCensus.iterator();
    324. 

  324. 					UserDefinedProperty udp;
    325. 

  325. 					while (indIter.hasNext()) {
    326. 

  326. 						udp = (UserDefinedProperty)((Individual)indIter.next()).userDefinedProperties.get(theUDP.starName);
    327. 

  327. 						if (udp != null) {
    328. 

  328. 							numWithProp++;
    329. 

  329. 							if (udp.value.size() > 0) numWithVals++;
    330. 

  330. 							}
    331. 

  331. 						}  //  end of loop thru persons on this context
    332. 

  332. 					int choice = JOptionPane.YES_OPTION;
    333. 

  333. 					if (numWithProp > 0) {
    334. 

  334. 						msg = "There are " + numWithProp + " persons with this property defined.\n" + 
    335. 

  335. 								"There are " + numWithVals + " with a value for this property.\n" + 
    336. 

  336. 								"Do you want to change the name of this UDP for every person?";
    337. 

  337. 						choice = JOptionPane.showConfirmDialog(ed, msg, "Confirm", JOptionPane.YES_NO_OPTION);
    338. 

  338. 						}  //  end of confirmed-delete-of-the UDPs-from-individuals
    339. 

  339. 					if (choice == JOptionPane.YES_OPTION) reName = true;
    340. 

  340. 					  //  end of User-chose-to-delete-UDP-from-all-persons
    341. 

  341. 					}  //  end of name-change
    342. 

  342. 				flipFinalBtn("check");
    343. 

  343. 				return;
    344. 

  344. 				}  //  end of "name edit"
    345. 

  345. 			if (e.getActionCommand().equals("data type"))  {
    346. 

  346. 				String priorType = newType;  //  prior value
    347. 

  347. 				String typ = (String)typePick.getSelectedItem();
    348. 

  348. 				if (typ.equals("String"))  {
    349. 

  349. 					newType = "string";
    350. 

  350. 					if (priorType.equals(newType)) return;  //  Nothing changed
    351. 

  351. 					minText.setText("");
    352. 

  352. 					minText.setEditable(false);
    353. 

  353. 					maxText.setText("");
    354. 

  354. 					maxText.setEditable(false);
    355. 

  355. 					if (yescertain.isSelected()) {
    356. 

  356. 						certainEditLabel.setText("Edit list of values, then hit 'Enter'.");
    357. 

  357. 						certainText.setEditable(true);
    358. 

  358. 					}else {
    359. 

  359. 						certainEditLabel.setText("");
    360. 

  360. 						certainText.setEditable(false);
    361. 

  361. 						}
    362. 

  362. 					if (yesdefault.isSelected()) {
    363. 

  363. 						defaultText.setEditable(true);
    364. 

  364. 						defeditLabel.setText("Edit the default value, then hit 'Enter'.");
    365. 

  365. 					}else {
    366. 

  366. 						defaultText.setEditable(false);
    367. 

  367. 						defeditLabel.setText("");
    368. 

  368. 						}
    369. 

  369. 					}
    370. 

  370. 				else if (typ.equals("Integer")) {
    371. 

  371. 					newType = "integer";
    372. 

  372. 					if (priorType.equals(newType)) return;  //  Nothing changed
    373. 

  373. 					minText.setEditable(true);
    374. 

  374. 					maxText.setEditable(true);
    375. 

  375. 					if (yescertain.isSelected()) {
    376. 

  376. 						certainEditLabel.setText("Edit list of values, then hit 'Enter'.");
    377. 

  377. 						certainText.setEditable(true);
    378. 

  378. 					}else {
    379. 

  379. 						certainEditLabel.setText("");
    380. 

  380. 						certainText.setEditable(false);
    381. 

  381. 						}
    382. 

  382. 					if (yesdefault.isSelected()) {
    383. 

  383. 						defaultText.setEditable(true);
    384. 

  384. 						defeditLabel.setText("Edit the default value, then hit 'Enter'.");
    385. 

  385. 					}else {
    386. 

  386. 						defaultText.setEditable(false);
    387. 

  387. 						defeditLabel.setText("");
    388. 

  388. 						}
    389. 

  389. 					}
    390. 

  390. 				else if (typ.equals("Real Number")) {
    391. 

  391. 					newType = "float";
    392. 

  392. 					if (priorType.equals(newType)) return;  //  Nothing changed
    393. 

  393. 					minText.setEditable(true);
    394. 

  394. 					maxText.setEditable(true);
    395. 

  395. 					if (yescertain.isSelected()) {
    396. 

  396. 						certainEditLabel.setText("Edit list of values, then hit 'Enter'.");
    397. 

  397. 						certainText.setEditable(true);
    398. 

  398. 					}else {
    399. 

  399. 						certainEditLabel.setText("");
    400. 

  400. 						certainText.setEditable(false);
    401. 

  401. 						}
    402. 

  402. 					if (yesdefault.isSelected()) {
    403. 

  403. 						defaultText.setEditable(true);
    404. 

  404. 						defeditLabel.setText("Edit the default value, then hit 'Enter'.");
    405. 

  405. 					}else {
    406. 

  406. 						defaultText.setEditable(false);
    407. 

  407. 						defeditLabel.setText("");
    408. 

  408. 						}
    409. 

  409. 					}
    410. 

  410. 				else if (typ.equals("Boolean"))  {
    411. 

  411. 					newType = "boolean";
    412. 

  412. 					if (priorType.equals(newType)) return;  //  Nothing changed
    413. 

  413. 					minText.setText("");
    414. 

  414. 					minText.setEditable(false);
    415. 

  415. 					maxText.setText("");
    416. 

  416. 					maxText.setEditable(false);
    417. 

  417. 					nomulti.setSelected(true);
    418. 

  418. 					newSingleValue = true;
    419. 

  419. 					nocertain.setSelected(true);
    420. 

  420. 					certainText.setText("");
    421. 

  421. 					certainEditLabel.setText("");
    422. 

  422. 					certainText.setEditable(false);
    423. 

  423. 					newValidEntries = null;
    424. 

  424. 					}
    425. 

  425. 				else if (typ.equals("Person")) {
    426. 

  426. 					newType = "individual";
    427. 

  427. 					if (priorType.equals(newType)) return;  //  Nothing changed
    428. 

  428. 					minText.setText("");
    429. 

  429. 					minText.setEditable(false);
    430. 

  430. 					maxText.setText("");
    431. 

  431. 					maxText.setEditable(false);
    432. 

  432. 					nocertain.setSelected(true);
    433. 

  433. 					certainText.setText("");
    434. 

  434. 					certainEditLabel.setText("");
    435. 

  435. 					certainText.setEditable(false);
    436. 

  436. 					newValidEntries = null;
    437. 

  437. 					nodefault.setSelected(true);
    438. 

  438. 					defaultText.setEditable(false);
    439. 

  439. 					defeditLabel.setText("");
    440. 

  440. 					}
    441. 

  441. 				if ((newValidEntries != null) && (newValidEntries.size() > 0)) {
    442. 

  442. 					//  Changed type after specifying valid entries
    443. 

  443. 					newValidEntries = null;
    444. 

  444. 					certainText.setText("");
    445. 

  445. 					certainEditLabel.setText("");
    446. 

  446. 					nocertain.setSelected(true);
    447. 

  447. 					}
    448. 

  448. 				
    449. 

  449. 				flipFinalBtn("check");
    450. 

  450. 				return;
    451. 

  451. 				}
    452. 

  452. 			if (e.getActionCommand().equals("multiVal yes")) {
    453. 

  453. 				if (newType.equals("boolean"))  {
    454. 

  454. 					newSingleValue = true;
    455. 

  455. 					nomulti.setSelected(true);
    456. 

  456. 					JOptionPane.showMessageDialog(ed, "Sorry.  When Data Type is 'Boolean'\n" +
    457. 

  457. 														"you cannot allow Multiple Values.",
    458. 

  458. 						"Illegal Combination", 
    459. 

  459. 						JOptionPane.INFORMATION_MESSAGE);
    460. 

  460. 					}
    461. 

  461. 				else newSingleValue = false;
    462. 

  462. 				return;
    463. 

  463. 				}
    464. 

  464. 			if (e.getActionCommand().equals("multiVal no")) {
    465. 

  465. 				newSingleValue = true;
    466. 

  466. 				return;
    467. 

  467. 				}
    468. 

  468. 			if (e.getActionCommand().equals("certainVal yes"))  {
    469. 

  469. 				if (newType.equals("individual")) {
    470. 

  470. 					JOptionPane.showMessageDialog(ed, "Sorry.  When Data Type is 'Person' you\n" +
    471. 

  471. 														"cannot Restrict to Certain Values",
    472. 

  472. 						"Illegal Combination", 
    473. 

  473. 						JOptionPane.INFORMATION_MESSAGE);
    474. 

  474. 					nocertain.setSelected(true);
    475. 

  475. 					return;
    476. 

  476. 					}  //  end of type = indiv
    477. 

  477. 				else if (newType.equals("boolean")) {
    478. 

  478. 					JOptionPane.showMessageDialog(ed, "Sorry.  When Data Type is 'Boolean' you\n" +
    479. 

  479. 														"cannot Restrict to Certain Values",
    480. 

  480. 						"Illegal Combination", 
    481. 

  481. 						JOptionPane.INFORMATION_MESSAGE);
    482. 

  482. 					nocertain.setSelected(true);
    483. 

  483. 					return;
    484. 

  484. 					}  //  end of type = boolean
    485. 

  485. 				else if ((newUDP) || (theUDP.validEntries == null)) {
    486. 

  486. 					newValidEntries = new ArrayList<Object>();
    487. 

  487. 					certainText.setText("");
    488. 

  488. 					certainEditLabel.setText("Enter values separated by commas, then hit 'Enter'.");
    489. 

  489. 				}else {
    490. 

  490. 					newValidEntries = theUDP.validEntries;
    491. 

  491. 					certainText.setText(theUDP.getValidEntriesString());
    492. 

  492. 					certainEditLabel.setText("Edit list of values, separated by commas, then hit 'Enter'.");
    493. 

  493. 					}
    494. 

  494. 				certainText.setEditable(true);
    495. 

  495. 				certainText.addActionListener(listener);
    496. 

  496. 				certainText.setActionCommand("certainText edit");
    497. 

  497. 				flipFinalBtn("check");
    498. 

  498. 				return;
    499. 

  499. 				}
    500. 

  500. 			if (e.getActionCommand().equals("certainVal no"))  {
    501. 

  501. 				newValidEntries = null;
    502. 

  502. 				certainText.setText("");
    503. 

  503. 				certainEditLabel.setText("");
    504. 

  504. 				certainText.setEditable(false);
    505. 

  505. 				flipFinalBtn("check");
    506. 

  506. 				return;
    507. 

  507. 				}
    508. 

  508. 			if (e.getActionCommand().equals("certainText edit"))  {
    509. 

  509. 				validateCertainVals();
    510. 

  510. 				return;
    511. 

  511. 				}
    512. 

  512. 			if (e.getActionCommand().equals("defaultVal yes"))  {
    513. 

  513. 				if (newType.equals("individual")) {
    514. 

  514. 					JOptionPane.showMessageDialog(ed, "Sorry.  When Data Type is 'Person' you\n" +
    515. 

  515. 														"cannot have a Default Value",
    516. 

  516. 						"Illegal Combination", 
    517. 

  517. 						JOptionPane.INFORMATION_MESSAGE);
    518. 

  518. 					nodefault.setSelected(true);
    519. 

  519. 					return;
    520. 

  520. 					}  //  end of type = indiv
    521. 

  521. 				if (theUDP.defaultValue != null) {
    522. 

  522. 					newDefaultValue = theUDP.defaultValue;
    523. 

  523. 					defaultText.setText(theUDP.defaultValue.toString());
    524. 

  524. 					}
    525. 

  525. 				defaultText.setEditable(true);
    526. 

  526. 				defaultText.addActionListener(listener);
    527. 

  527. 				defaultText.setActionCommand("defaultText edit");
    528. 

  528. 				defeditLabel.setText("Edit the default value, then hit 'Enter'.");
    529. 

  529.                 defaultValExists = true;
    530. 

  530. 				flipFinalBtn("check");
    531. 

  531. 				return;
    532. 

  532. 				}
    533. 

  533. 			if (e.getActionCommand().equals("defaultVal no"))  {
    534. 

  534. 				newDefaultValue = null;
    535. 

  535. 				defaultText.setText("");
    536. 

  536. 				defeditLabel.setText("");
    537. 

  537. 				defaultText.setEditable(false);
    538. 

  538.                 defaultValExists = false;
    539. 

  539. 				flipFinalBtn("check");
    540. 

  540. 				return;
    541. 

  541. 				}
    542. 

  542. 			if (e.getActionCommand().equals("defaultText edit"))  {
    543. 

  543. 				validateDefaultVal();
    544. 

  544. 				return;
    545. 

  545. 				}
    546. 

  546. 			if (e.getActionCommand().equals("minText edit")) {
    547. 

  547. 				validateMinText();
    548. 

  548. 				return;
    549. 

  549. 				}
    550. 

  550. 			if (e.getActionCommand().equals("maxText edit"))  {
    551. 

  551. 				validateMaxText();
    552. 

  552. 				return;
    553. 

  553. 				}
    554. 

  554. 			if (e.getActionCommand().equals("cancel"))  {
    555. 

  555. 				theUDP = null;
    556. 

  556. 				try {  ed.setClosed(true);  //  by not writing & saving, we cancel
    557. 

  557. 				}catch(PropertyVetoException pve) {
    558. 

  558. 					if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    559. 

  559. 					MainPane.activity.log.append("In UDPEditor:\n" + pve);
    560. 

  560. 					System.out.println("In UDPEditor:\n" + pve); }
    561. 

  561. 				return;
    562. 

  562. 				}
    563. 

  563. 			if (e.getActionCommand().equals("delete"))  {
    564. 

  564. 				int choice = JOptionPane.showConfirmDialog(ed,
    565. 

  565. 					"Are you sure you want to delete this UDP?",
    566. 

  566. 					"Confirm", JOptionPane.YES_NO_OPTION);
    567. 

  567. 				if (choice == JOptionPane.YES_OPTION) {
    568. 

  568. 					ctxt.userDefinedProperties.remove(theUDP.starName);
    569. 

  569. 					int numWithProp = 0, numWithVals = 0;
    570. 

  570. 					Iterator indIter = ctxt.individualCensus.iterator();
    571. 

  571. 					UserDefinedProperty udp;
    572. 

  572. 					while (indIter.hasNext()) {
    573. 

  573. 						udp = (UserDefinedProperty)((Individual)indIter.next()).userDefinedProperties.get(theUDP.starName);
    574. 

  574. 						if (udp != null) {
    575. 

  575. 							numWithProp++;
    576. 

  576. 							if (udp.value.size() > 0) numWithVals++;
    577. 

  577. 							}
    578. 

  578. 						}  //  end of loop thru persons on this context
    579. 

  579. 					choice = JOptionPane.YES_OPTION;
    580. 

  580. 					if (numWithVals > 0) {
    581. 

  581. 						String msg = "There are " + numWithProp + " persons with this property defined.\n" + 
    582. 

  582. 									 "There are " + numWithVals + " with a value for this property.\n" + 
    583. 

  583. 									 "Do you want to delete this UDP from every person?";
    584. 

  584. 						choice = JOptionPane.showConfirmDialog(ed, msg, "Confirm", JOptionPane.YES_NO_OPTION);
    585. 

  585. 						}  //  end of confirmed-delete-of-the UDPs-from-individuals
    586. 

  586. 					if (choice == JOptionPane.YES_OPTION) {
    587. 

  587. 						indIter = ctxt.individualCensus.iterator();
    588. 

  588. 						while (indIter.hasNext()) 
    589. 

  589. 							((Individual)indIter.next()).userDefinedProperties.remove(theUDP.starName);
    590. 

  590. 						}  //  end of User-chose-to-delete-UDP-from-all-persons
    591. 

  591. 					}  //  end of confirmed-delete-request
    592. 

  592. 				try {  ed.setClosed(true);  
    593. 

  593. 					ContextEditor newCtxtEd = new ContextEditor(ctxt);
    594. 

  594. 					newCtxtEd.setLocation(ctxtEd.getLocation());  //  put new one where old was
    595. 

  595. 					ctxtEd.setClosed(true);
    596. 

  596. 					newCtxtEd.desktop = desktop;
    597. 

  597. 					desktop.add(newCtxtEd);
    598. 

  598. 					newCtxtEd.show();
    599. 

  599. 					newCtxtEd.moveToFront();
    600. 

  600. 					newCtxtEd.setSelected(true);
    601. 

  601. 					newCtxtEd.miViewMe = menuView.add(newCtxtEd.windowNum);
    602. 

  602. 					newCtxtEd.miViewMe.addActionListener(newCtxtEd);
    603. 

  603. 					newCtxtEd.menuView = menuView;
    604. 

  604. 				}catch(PropertyVetoException pve) {
    605. 

  605. 					if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    606. 

  606. 					MainPane.activity.log.append("In UDPEditor:\n" + pve);
    607. 

  607. 					System.out.println("In UDPEditor:\n" + pve); }
    608. 

  608. 				return;
    609. 

  609. 				}
    610. 

  610. 			if (e.getActionCommand().equals("check"))  {
    611. 

  611. 				//  Run consistency checks again, just to be sure.
    612. 

  612. 				boolean errorFlag = false;
    613. 

  613. 				
    614. 

  614. 				String newName = name_1.getText(), msg;
    615. 

  615. 				if (! Library.validateFileName(newName, true)) {
    616. 

  616. 					msg = "The name '" + newName + "' violates the rules for names:\n"
    617. 

  617. 						+ "The name MUST start with a star ('*') and a letter.\n" +
    618. 

  618. 						"Use up to 28 LETTERS, NUMBERS, or DASHES (-) but NO SPACES.";
    619. 

  619. 					JOptionPane.showMessageDialog(ed, msg, "Violation of Naming Rules", 
    620. 

  620. 						JOptionPane.WARNING_MESSAGE);
    621. 

  621. 					flipFinalBtn("check");
    622. 

  622. 					return; 
    623. 

  623. 					}
    624. 

  624. 				//  Once past activity-check, we can safely record the new starName
    625. 

  625. 				newStarName = newName;
    626. 

  626. 				if ((! newUDP) && (! reName) && (! newStarName.equals(theUDP.starName)))  {  //  name change
    627. 

  627. 					int numWithProp = 0, numWithVals = 0;
    628. 

  628. 					Iterator indIter = ctxt.individualCensus.iterator();
    629. 

  629. 					UserDefinedProperty udp;
    630. 

  630. 					while (indIter.hasNext()) {
    631. 

  631. 						udp = (UserDefinedProperty)((Individual)indIter.next()).userDefinedProperties.get(theUDP.starName);
    632. 

  632. 						if (udp != null) {
    633. 

  633. 							numWithProp++;
    634. 

  634. 							if (udp.value.size() > 0) numWithVals++;
    635. 

  635. 							}
    636. 

  636. 						}  //  end of loop thru persons on this context
    637. 

  637. 					int choice = JOptionPane.YES_OPTION;
    638. 

  638. 					if (numWithProp > 0) {
    639. 

  639. 						msg = "There are " + numWithProp + " persons with this property defined.\n" + 
    640. 

  640. 								"There are " + numWithVals + " with a value for this property.\n" + 
    641. 

  641. 								"Do you want to change the name of this UDP for every person?";
    642. 

  642. 						choice = JOptionPane.showConfirmDialog(ed, msg, "Confirm", JOptionPane.YES_NO_OPTION);
    643. 

  643. 						}  //  end of confirmed-delete-of-the UDPs-from-individuals
    644. 

  644. 					if (choice == JOptionPane.YES_OPTION) reName = true;
    645. 

  645. 					  //  end of User-chose-to-delete-UDP-from-all-persons
    646. 

  646. 					}  //  end of name-change
    647. 

  647. 				
    648. 

  648. 				if (((newType.equals("boolean")) || (newType.equals("individual"))) && (newValidEntries != null)) {
    649. 

  649. 					JOptionPane.showMessageDialog(ed, "Sorry.  When Data Type is '" + newType + "' you\n" +
    650. 

  650. 														"cannot Restrict to Certain Values",
    651. 

  651. 						"Illegal Combination", 
    652. 

  652. 						JOptionPane.INFORMATION_MESSAGE);
    653. 

  653. 					nocertain.setSelected(true);
    654. 

  654. 					newValidEntries = null;
    655. 

  655. 					errorFlag = true;
    656. 

  656. 					}  //  re-checked consistency
    657. 

  657. 				if ((newValidEntries != null) && (newValidEntries.size() < 1)) {
    658. 

  658. 					JOptionPane.showMessageDialog(ed, "Error -- You chose to Restrict to Certain Values\n" +
    659. 

  659. 														"but did not provide a valid list of allowable values.\n" +
    660. 

  660. 														"Either provide a list or remove the restriction.",
    661. 

  661. 						"Inconsistent Information", 
    662. 

  662. 						JOptionPane.WARNING_MESSAGE);
    663. 

  663. 					errorFlag = true;
    664. 

  664. 					}  //  end of check for Value Restriction with no list of legal values
    665. 

  665. 				if ((newType.equals("individual")) && (newDefaultValue != null))  {
    666. 

  666. 					JOptionPane.showMessageDialog(ed, "Error -- You may not have a Default Value\n" +
    667. 

  667. 														"when the data type is 'Person'.",
    668. 

  668. 						"Inconsistent Information", 
    669. 

  669. 						JOptionPane.WARNING_MESSAGE);
    670. 

  670. 					errorFlag = true;
    671. 

  671. 					}  //  end of check for a default individual
    672. 

  672. 				if (((newType.equals("individual")) || (newType.equals("boolean")) || (newType.equals("string")))
    673. 

  673. 					&& ((newMaxVal != null) || (newMinVal != null)))  {
    674. 

  674. 					JOptionPane.showMessageDialog(ed, "Error -- You may not have a Maximum or Minimum Value\n" +
    675. 

  675. 														"when the data type is 'Person' 'Boolean' or 'String'.",
    676. 

  676. 						"Inconsistent Information", 
    677. 

  677. 						JOptionPane.WARNING_MESSAGE);
    678. 

  678. 					errorFlag = true;
    679. 

  679. 					}  //  end of check for min/max val of non-numeric data
    680. 

  680. 				if (! validateDefaultVal())   errorFlag = true; //  re-check consistency: default value & data type
    681. 

  681. 				if (! validateMinText())   errorFlag = true; 
    682. 

  682. 				if (! validateMaxText())   errorFlag = true; 
    683. 

  683. 				if (! errorFlag) flipFinalBtn("save");
    684. 

  684. 				return;
    685. 

  685. 				}
    686. 

  686. 			if (e.getActionCommand().equals("save"))  {
    687. 

  687. 				ctxt.saveState = true;
    688. 

  688. 				String oldName = theUDP.starName, oldType = theUDP.typ;
    689. 

  689. 				theUDP.starName = newStarName;
    690. 

  690. 				theUDP.typ = newType;
    691. 

  691. 				theUDP.validEntries = newValidEntries;
    692. 

  692. 				theUDP.singleValue = newSingleValue;
    693. 

  693. 				theUDP.defaultValue = newDefaultValue;
    694. 

  694. 				theUDP.minVal = newMinVal;
    695. 

  695. 				theUDP.maxVal = newMaxVal;
    696. 

  696. 				if (newUDP || reName) {
    697. 

  697. 					if (ctxt.userDefinedProperties == null) ctxt.userDefinedProperties = new TreeMap();
    698. 

  698. 					ctxt.userDefinedProperties.put(newStarName, theUDP);
    699. 

  699. 					}
    700. 

  700. 				if ((reName) && (oldName != null)) ctxt.userDefinedProperties.remove(oldName);
    701. 

  701. 				
    702. 

  702. 				progBox.setVisible(true);
    703. 

  703. 				progressBar.setStringPainted(true);
    704. 

  704. 				UserDefinedProperty oldudp, newInstance;
    705. 

  705. 				Individual ind;
    706. 

  706. 				Iterator indIter = ctxt.individualCensus.iterator();
    707. 

  707. 				
    708. 

  708. 				if (newUDP)  {  //  no possible clashes: just make one for each person
    709. 

  709. 					while (indIter.hasNext()) {
    710. 

  710. 						ind = (Individual)indIter.next();
    711. 

  711. 						newInstance = new UserDefinedProperty(theUDP, true);  //  clone the new template
    712. 

  712. 						if (ind.userDefinedProperties == null) 
    713. 

  713. 							ind.userDefinedProperties = new TreeMap();
    714. 

  714. 						ind.userDefinedProperties.put(newStarName, newInstance);
    715. 

  715. 						progressBar.setValue(ind.serialNmbr);
    716. 

  716. 						}  //  end of loop thru individuals
    717. 

  717. 				}else  {  //  revised UDP could be inconsistent with some existing instances of old definition
    718. 

  718. 					if (! oldType.equals(newType))  {  // type clash, instance 'value' fields must be empty
    719. 

  719. 						while (indIter.hasNext()) {
    720. 

  720. 							ind = (Individual)indIter.next();
    721. 

  721. 							if (reName) ind.userDefinedProperties.remove(oldName);
    722. 

  722. 							newInstance = new UserDefinedProperty(theUDP, false);  //  clone the new template
    723. 

  723. 							ind.userDefinedProperties.put(newStarName, newInstance);
    724. 

  724. 							progressBar.setValue(ind.serialNmbr);
    725. 

  725. 							}  //  end of loop thru individuals
    726. 

  726. 					}else if (newSingleValue && (! theUDP.singleValue))  {  // no type clash but arity clash
    727. 

  727. 						while (indIter.hasNext()) {
    728. 

  728. 							ind = (Individual)indIter.next();
    729. 

  729. 							oldudp = (UserDefinedProperty)ind.userDefinedProperties.get(oldName);
    730. 

  730. 							if (reName) ind.userDefinedProperties.remove(oldName);
    731. 

  731. 							newInstance = new UserDefinedProperty(theUDP, false);  //  clone the new template
    732. 

  732. 							if (validValsChanged) {  //  check for change in valid entries
    733. 

  733. 								for (int i=0; i < oldudp.value.size(); i++)  
    734. 

  734. 									if (newValidEntries.contains(oldudp.value.get(i)))  {
    735. 

  735. 										newInstance.value.add(oldudp.value.get(i));
    736. 

  736. 										i = 10000000;  // only add first conforming value
    737. 

  737. 										}
    738. 

  738. 							}else if (oldudp.value.size() > 0) 
    739. 

  739. 								newInstance.value.add(oldudp.value.get(0));  //  add first value from old value list
    740. 

  740. 							ind.userDefinedProperties.put(newStarName, newInstance);
    741. 

  741. 							progressBar.setValue(ind.serialNmbr);
    742. 

  742. 							}  //  end of loop thru individuals
    743. 

  743. 					}else  {  // no type clash, no arity clash 
    744. 

  744. 						while (indIter.hasNext()) {
    745. 

  745. 							ind = (Individual)indIter.next();
    746. 

  746. 							oldudp = (UserDefinedProperty)ind.userDefinedProperties.get(oldName);
    747. 

  747. 							if (reName) ind.userDefinedProperties.remove(oldName);
    748. 

  748. 							newInstance = new UserDefinedProperty(theUDP, false);  //  clone the new template
    749. 

  749. 							if (validValsChanged) {  //  check for change in valid entries
    750. 

  750. 								for (int i=0; i < oldudp.value.size(); i++)  
    751. 

  751. 									if (newValidEntries.contains(oldudp.value.get(i)))  
    752. 

  752. 										newInstance.value.add(oldudp.value.get(i));
    753. 

  753. 							}else newInstance.value = oldudp.value;  //  copy the entire old value list
    754. 

  754. 							if ((newInstance.value.size() < 1) && (newDefaultValue != null))  
    755. 

  755. 							// there was no prior value, but now there's a default
    756. 

  756. 								newInstance.value.add(newDefaultValue);
    757. 

  757. 							ind.userDefinedProperties.put(newStarName, newInstance);
    758. 

  758. 							progressBar.setValue(ind.serialNmbr);
    759. 

  759. 							}  //  end of loop thru individuals
    760. 

  760. 						}
    761. 

  761. 					}
    762. 

  762. 				try {  ed.setClosed(true);  
    763. 

  763. 					ContextEditor newCtxtEd = new ContextEditor(ctxt);
    764. 

  764. 					newCtxtEd.setLocation(ctxtEd.getLocation());  //  put new one where old was
    765. 

  765. 					ctxtEd.setClosed(true);
    766. 

  766. 					newCtxtEd.desktop = desktop;
    767. 

  767. 					desktop.add(newCtxtEd);
    768. 

  768. 					newCtxtEd.show();
    769. 

  769. 					newCtxtEd.moveToFront();
    770. 

  770. 					newCtxtEd.setSelected(true);
    771. 

  771. 					newCtxtEd.miViewMe = menuView.add(newCtxtEd.windowNum);
    772. 

  772. 					newCtxtEd.miViewMe.addActionListener(newCtxtEd);
    773. 

  773. 					newCtxtEd.menuView = menuView;
    774. 

  774. 				}catch (Exception ex)  {
    775. 

  775. 					if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    776. 

  776. 					MainPane.activity.log.append("While closing UDP editor & re-building a context editor, " + ex + "\n\n");  }
    777. 

  777. 				}  //  end of action = save
    778. 

  778. 			if (e.getActionCommand().equals("delete"))  {
    779. 

  779. 				String msg = "Are you sure you want to DELETE this UDP?";
    780. 

  780. 				int choice = JOptionPane.showConfirmDialog(ed, msg, "Confirm", JOptionPane.YES_NO_OPTION);
    781. 

  781. 				if (choice == JOptionPane.YES_OPTION)  {
    782. 

  782. 					ctxt.saveState = true;
    783. 

  783. 					ctxt.userDefinedProperties.remove(theUDP.starName);
    784. 

  784. 					try {  ed.setClosed(true);  
    785. 

  785. 						ContextEditor newCtxtEd = new ContextEditor(ctxt);
    786. 

  786. 						newCtxtEd.setLocation(ctxtEd.getLocation());  //  put new one where old was
    787. 

  787. 						ctxtEd.setClosed(true);
    788. 

  788. 						newCtxtEd.desktop = desktop;
    789. 

  789. 						desktop.add(newCtxtEd);
    790. 

  790. 						newCtxtEd.show();
    791. 

  791. 						newCtxtEd.moveToFront();
    792. 

  792. 						newCtxtEd.setSelected(true);
    793. 

  793. 						newCtxtEd.miViewMe = menuView.add(newCtxtEd.windowNum);
    794. 

  794. 						newCtxtEd.miViewMe.addActionListener(newCtxtEd);
    795. 

  795. 						newCtxtEd.menuView = menuView;
    796. 

  796. 					}catch (Exception ex)  {
    797. 

  797. 						if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    798. 

  798. 						MainPane.activity.log.append("While closing UDP editor & re-building a context editor, " + ex + "\n\n");  }
    799. 

  799. 					}  //  end of confirmed deletion
    800. 

  800. 				}  //  end of action = delete
    801. 

  801. 			}  //  end of ActionListerner method actionPerformed
    802. 

  802. 			
    803. 

  803. 		}  //  end of inner class UDPListener
    804. 

  804. 			
    805. 

  805. 	public void flipFinalBtn(String saveORnot)  {
    806. 

  806. 		if (saveORnot.equals("save"))  {
    807. 

  807. 			udpCheckSave.setActionCommand("save");
    808. 

  808. 			udpCheckSave.setText("Save");
    809. 

  809. 			}  //  end of flip to SAVE
    810. 

  810. 		else {
    811. 

  811. 			udpCheckSave.setActionCommand("check");
    812. 

  812. 			udpCheckSave.setText("Check for Errors");
    813. 

  813. 			}  //  end of flip to CHECK
    814. 

  814. 		}  //  end of method flipFinalBtn
    815. 

  815. 

  816. 

  817. 

  818. 	public void validateCertainVals()  {
    819. 

  819. 		//  Can't get here if typ = indiv or boolean
    820. 

  820. 		validValsChanged = true;
    821. 

  821. 		String theVals = certainText.getText();
    822. 

  822. 		ArrayList<Object> safetyNet = new ArrayList<Object>(newValidEntries);  // in case the edits were bad
    823. 

  823. 		newValidEntries.clear();
    824. 

  824. 		int start = 0, nextComma = 0, length = theVals.length();
    825. 

  825. 		//  In effect, we reverse the logic of getValidEntriesString
    826. 

  826. 		try {
    827. 

  827. 			if (newType.equals("string")) 
    828. 

  828. 				while (nextComma < length) {
    829. 

  829. 					nextComma = theVals.substring(start).indexOf(",");
    830. 

  830. 					if (nextComma == -1) nextComma = length;
    831. 

  831. 					else nextComma += start;
    832. 

  832. 					newValidEntries.add(theVals.substring(start, nextComma).trim());
    833. 

  833. 					start = nextComma + 1;
    834. 

  834. 					}  //  end of typ = string
    835. 

  835. 			else if (newType.equals("integer")) {
    836. 

  836. 				while (nextComma < length) {
    837. 

  837. 					nextComma = theVals.substring(start).indexOf(",");
    838. 

  838. 					if (nextComma == -1) nextComma = length;
    839. 

  839. 					else nextComma += start;
    840. 

  840. 					newValidEntries.add(new Integer(theVals.substring(start, nextComma).trim()));
    841. 

  841. 					start = nextComma + 1;
    842. 

  842. 					}  
    843. 

  843. 				}  //  //  end of typ = int
    844. 

  844. 			else if (newType.equals("float")) {
    845. 

  845. 				while (nextComma < length) {
    846. 

  846. 					nextComma = theVals.substring(start).indexOf(",");
    847. 

  847. 					if (nextComma == -1) nextComma = length;
    848. 

  848. 					else nextComma += start;
    849. 

  849. 					newValidEntries.add(new Float(theVals.substring(start, nextComma).trim()));
    850. 

  850. 					start = nextComma + 1;
    851. 

  851. 					}  
    852. 

  852. 				}  //  end of typ = float
    853. 

  853. 			}catch(NumberFormatException nfe) { 
    854. 

  854. 				if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    855. 

  855. 				String eMsg = "The Data Type you chose is '" + newType + ".'\n" +
    856. 

  856. 								"Your entries can't be accepted as that type.\nPlease try again.";
    857. 

  857. 				MainPane.activity.log.append("While parsing 'int' Valid Entries:\n" + nfe + "\n" + eMsg);
    858. 

  858. 				JOptionPane.showMessageDialog(this, eMsg, "Type Violation", JOptionPane.INFORMATION_MESSAGE);
    859. 

  859. 				return;
    860. 

  860. 			}catch(Exception exc)  {
    861. 

  861. 				if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    862. 

  862. 				String eMsg = "Error while parsing " + newType + "s in the UDP Editor.\n" + exc + "\n"
    863. 

  863. 							+ "Your entries can't be accepted as that type.\nPlease try again.";
    864. 

  864. 				MainPane.activity.log.append(eMsg + "\n" + exc);
    865. 

  865. 				JOptionPane.showMessageDialog(this, eMsg, "Type Violation", JOptionPane.INFORMATION_MESSAGE);
    866. 

  866. 				return;
    867. 

  867. 				}  //  end of catch blocks
    868. 

  868. 		flipFinalBtn("check");
    869. 

  869. 		return;
    870. 

  870. 	}  //  end of method validateCertainVals()
    871. 

  871. 

  872. 

  873. 		public boolean validateDefaultVal()  {
    874. 

  874. 		//  Can't get here if typ = indiv
    875. 

  875. 		if (! defaultValExists) return true;  //  Nothing to validate
    876. 

  876.         String defVal = defaultText.getText();
    877. 

  877. 		Object safetyNet = newDefaultValue;
    878. 

  878.         if (defVal.length() > 0) {
    879. 

  879.             try {
    880. 

  880. 			if (newType.equals("string")) newDefaultValue = defVal;
    881. 

  881. 			else if (newType.equals("integer")) newDefaultValue = new Integer(defVal);
    882. 

  882. 			else if (newType.equals("float")) newDefaultValue = new Float(defVal);
    883. 

  883. 			else if (newType.equals("boolean")) {
    884. 

  884. 				if (! ((defVal.equals("true")) || (defVal.equals("false"))))
    885. 

  885. 					throw new KinshipSystemException("Did not enter 'true' or 'false'.");
    886. 

  886. 				else newDefaultValue = new Boolean(defVal);
    887. 

  887. 				}  //  end of type=boolean
    888. 

  888. 		}catch(Exception exc)  {
    889. 

  889. 			if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    890. 

  890. 			String eMsg = "Error while parsing " + newType + "s in the UDP Editor.\n" + exc + "\n"
    891. 

  891. 						+ "Your 'Default Value' can't be accepted as that type.\nPlease try again.";
    892. 

  892. 			MainPane.activity.log.append(eMsg + "\n" + exc);
    893. 

  893. 			JOptionPane.showMessageDialog(this, eMsg, "Type Violation", JOptionPane.INFORMATION_MESSAGE);
    894. 

  894. 			newDefaultValue = safetyNet;
    895. 

  895. 			return false;
    896. 

  896. 			}  //  end of catch block
    897. 

  897. 		//  Check for consistency with Restricted Values
    898. 

  898. 		if ((newValidEntries != null) && (newValidEntries.size() > 0) && (! newValidEntries.contains(newDefaultValue)))  {
    899. 

  899. 			if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    900. 

  900. 			String eMsg = "Sorry.  Your default value of " + defVal + " is not valid.\n"
    901. 

  901. 						+ "You have Restricted Values for this UDP.\nPlease try again.";
    902. 

  902. 			MainPane.activity.log.append(eMsg);
    903. 

  903. 			JOptionPane.showMessageDialog(this, eMsg, "Restricted Value Violation", JOptionPane.INFORMATION_MESSAGE);
    904. 

  904. 			newDefaultValue = safetyNet;
    905. 

  905. 			return false;
    906. 

  906. 			}  //  end of inconsistent-with-Valid-Entries
    907. 

  907. 		flipFinalBtn("check");
    908. 

  908. 		return true;
    909. 

  909. 		}else {  //  default required but none entered
    910. 

  910.             JOptionPane.showMessageDialog(this, "You have not entered a Default Value.\n" +
    911. 

  911.                     "Either enter one or click 'No' default.",
    912. 

  912.                     "None Entered", JOptionPane.INFORMATION_MESSAGE);
    913. 

  913.             return false;
    914. 

  914. 		}  //  end of none entered
    915. 

  915.        }  //  end of method validateDefaultVal()
    916. 

  916. 		
    917. 

  917. 	public boolean validateMinText()  {
    918. 

  918. 		//  The Min field is only valid for data types of integer and float (Real Number)
    919. 

  919. 		Number newVal;
    920. 

  920. 		if (minText.getText().equals("")) return true;
    921. 

  921. 		try {
    922. 

  922. 			if (newType.equals("float")) newVal = new Float(minText.getText());
    923. 

  923. 			else newVal = new Integer(minText.getText());
    924. 

  924. 		}catch(NumberFormatException nfe)  {
    925. 

  925. 			if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    926. 

  926. 			String eMsg = "Sorry.  Your Minimum Value of '" + minText.getText() + "' is not a valid "
    927. 

  927. 						+ newType + ".\nPlease try again.";
    928. 

  928. 			MainPane.activity.log.append(eMsg);
    929. 

  929. 			JOptionPane.showMessageDialog(this, eMsg, "Invalid Minimum Value", JOptionPane.INFORMATION_MESSAGE);
    930. 

  930. 			return false;
    931. 

  931. 			}  //  end of catch block
    932. 

  932. 		if ((newValidEntries != null) && (newValidEntries.size() > 0) && (newValidEntries.get(0) instanceof Number))
    933. 

  933. 			for (int i=0; i < newValidEntries.size(); i++)
    934. 

  934. 				if (((Number)newValidEntries.get(i)).floatValue() < newVal.floatValue())  {
    935. 

  935. 					if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    936. 

  936. 					String eMsg = "Sorry.  Your Minimum Value of '" + newVal + "' is greater than "
    937. 

  937. 								+ newValidEntries.get(i) + ", one of your 'Certain Values.'\nPlease try again.";
    938. 

  938. 					MainPane.activity.log.append(eMsg);
    939. 

  939. 					JOptionPane.showMessageDialog(this, eMsg, "Invalid Minimum Value", JOptionPane.INFORMATION_MESSAGE);
    940. 

  940. 					return false;
    941. 

  941. 					}  //  end of activity-found
    942. 

  942. 		if ((newDefaultValue != null) && (newDefaultValue instanceof Number) 
    943. 

  943. 					&& (((Number)newDefaultValue).floatValue() < newVal.floatValue()))  {
    944. 

  944. 			if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    945. 

  945. 			String eMsg = "Sorry.  Your Minimum Value of '" + newVal + "' is greater than "
    946. 

  946. 						+ newDefaultValue + ", your Default Value.\nPlease try again.";
    947. 

  947. 			MainPane.activity.log.append(eMsg);
    948. 

  948. 			JOptionPane.showMessageDialog(this, eMsg, "Invalid Minimum Value", JOptionPane.INFORMATION_MESSAGE);
    949. 

  949. 			return false;
    950. 

  950. 			}
    951. 

  951. 		if ((newMaxVal != null) && (newMaxVal.floatValue() < newVal.floatValue()))  {
    952. 

  952. 			if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    953. 

  953. 			String eMsg = "Sorry.  Your Minimum Value of '" + newVal + "' is greater than "
    954. 

  954. 						+ newMaxVal + ", your Maximum Value.\nPlease try again.";
    955. 

  955. 			MainPane.activity.log.append(eMsg);
    956. 

  956. 			JOptionPane.showMessageDialog(this, eMsg, "Invalid Minimum Value", JOptionPane.INFORMATION_MESSAGE);
    957. 

  957. 			return false;
    958. 

  958. 			}
    959. 

  959. 		newMinVal = newVal;
    960. 

  960. 		return true;
    961. 

  961. 		}  //  end of method validateMinText
    962. 

  962. 

  963. 

  964. 	public boolean validateMaxText()  {
    965. 

  965. 		//  The Max field is only valid for data types of integer and float (Real Number)
    966. 

  966. 		Number newVal;
    967. 

  967. 		if (maxText.getText().equals("")) return true;
    968. 

  968. 		try {
    969. 

  969. 			if (newType.equals("float")) newVal = new Float(maxText.getText());
    970. 

  970. 			else newVal = new Integer(maxText.getText());
    971. 

  971. 		}catch(NumberFormatException nfe)  {
    972. 

  972. 			if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    973. 

  973. 			String eMsg = "Sorry.  Your Maximum Value of '" + maxText.getText() + "' is not a valid "
    974. 

  974. 						+ newType + ".\nPlease try again.";
    975. 

  975. 			MainPane.activity.log.append(eMsg);
    976. 

  976. 			JOptionPane.showMessageDialog(this, eMsg, "Invalid Maximum Value", JOptionPane.INFORMATION_MESSAGE);
    977. 

  977. 			return false;
    978. 

  978. 			}  //  end of catch block
    979. 

  979. 		if ((newValidEntries != null) && (newValidEntries.size() > 0) && (newValidEntries.get(0) instanceof Number))
    980. 

  980. 			for (int i=0; i < newValidEntries.size(); i++)
    981. 

  981. 				if (((Number)newValidEntries.get(i)).floatValue() > newVal.floatValue())  {
    982. 

  982. 					if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    983. 

  983. 					String eMsg = "Sorry.  Your Maximum Value of '" + newVal + "' is less than "
    984. 

  984. 								+ newValidEntries.get(i) + ", one of your 'Certain Values.'\nPlease try again.";
    985. 

  985. 					MainPane.activity.log.append(eMsg);
    986. 

  986. 					JOptionPane.showMessageDialog(this, eMsg, "Invalid Maximum Value", JOptionPane.INFORMATION_MESSAGE);
    987. 

  987. 					return false;
    988. 

  988. 					}  //  end of activity-found
    989. 

  989. 		if ((newDefaultValue != null) && (newDefaultValue instanceof Number) 
    990. 

  990. 					&& (((Number)newDefaultValue).floatValue() > newVal.floatValue()))  {
    991. 

  991. 			if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    992. 

  992. 			String eMsg = "Sorry.  Your Maximum Value of '" + newVal + "' is less than "
    993. 

  993. 						+ newDefaultValue + ", your Default Value.\nPlease try again.";
    994. 

  994. 			MainPane.activity.log.append(eMsg);
    995. 

  995. 			JOptionPane.showMessageDialog(this, eMsg, "Invalid Maximum Value", JOptionPane.INFORMATION_MESSAGE);
    996. 

  996. 			return false;
    997. 

  997. 			}
    998. 

  998. 		if ((newMinVal != null) && (newMinVal.floatValue() > newVal.floatValue()))  {
    999. 

  999. 			if (MainPane.activity == null) MainPane.createActivityLog(desktop, menuView);
    1000. 

  1000. 			String eMsg = "Sorry.  Your Maximum Value of '" + newVal + "' is less than "
    1001. 

  1001. 						+ newMinVal + ", your Minimum Value.\nPlease try again.";
    1002. 

  1002. 			MainPane.activity.log.append(eMsg);
    1003. 

  1003. 			JOptionPane.showMessageDialog(this, eMsg, "Invalid Maximum Value", JOptionPane.INFORMATION_MESSAGE);
    1004. 

  1004. 			return false;
    1005. 

  1005. 			}
    1006. 

  1006. 		newMaxVal = newVal;
    1007. 

  1007. 		return true;
    1008. 

  1008. 		}  //  end of method validateMinText
    1009. 

  1009. 		
    1010. 

  1010. 	}  //  end of class UDPEditor
    1011. 

  1011. 	
    1012. 

  1012.