001 package data.stdforms; 002 003 import sale.*; 004 import data.*; 005 import data.stdforms.singletableformsheet.*; 006 import data.swing.*; 007 import util.swing.*; 008 009 import java.util.Comparator; 010 import javax.swing.*; 011 import javax.swing.table.TableModel; //for Javadoc 012 013 /** 014 * A FormSheet displaying the contents of a {@link Catalog}, {@link Stock} or {@link DataBasket}. 015 * 016 * <p>The FormSheet will comprise one table that renders the contents of the container to be displayed. 017 * Additionally, there can be to extra buttons in the FormSheet's button bar that can be used to add or 018 * remove records to/from the container. The actions linked to these buttons will be represented as 019 * sub-processes to the process which displayed the FormSheet. The actual sub-process will be created by a 020 * {@link EditButtonStrategy strategy object}.</p> 021 * 022 * <p>SingleTableFormSheets assume to be displayed at a {@link UIGate user interface gate}. However, if you 023 * do not want to add editing capabilities, you may set this parameter to <code>null</code> and use the 024 * FormSheet as you would any other FormSheet. If you need editing capabilities, you must set the FormSheet at 025 * a UIGate.</p> 026 * 027 * <p>Various <code>create()</code> methods are offered that cover the entire spectrum of possible 028 * SingleTableFormSheets. All you need to do is select the <code>create()</code> method that fits your purpose 029 * and use it in your application.</p> 030 * 031 * @author Steffen Zschaler 032 * @version 2.0 20/08/1999 033 * @since v2.0 034 */ 035 public class SingleTableFormSheet extends FormSheet { 036 037 /** 038 * ID for serialization. 039 */ 040 private static final long serialVersionUID = -7384199228823885354L; 041 042 /** 043 * The button id that is used for the "Add" button. 044 */ 045 public static final int BTNID_ADD = -100; 046 047 /** 048 * The button id that is used for the "Remove" button. 049 */ 050 public static final int BTNID_REMOVE = -101; 051 052 /** 053 * Reference to the currently selected index. 054 * 055 * @serial 056 */ 057 private int[] m_anSelection = new int[] { 058 -1}; 059 060 /** 061 * The displayed table. 062 */ 063 private JTable m_table; 064 065 /** 066 * The source of the displayed table, can be Catalog, CountingStock, StoringStock, Databasket... 067 */ 068 private Object m_source; 069 070 /** 071 * The DataBasket assigned to the table. 072 */ 073 private DataBasket m_db; 074 075 /** 076 * The {@link TableModel} of the table displayed. 077 */ 078 private transient util.swing.AbstractTableModel m_atmModel; 079 080 /** 081 * The {@link Gate} at which the FormSheet is being displayed. 082 * 083 * @serial 084 */ 085 private UIGate m_uigGate; 086 087 /** 088 * Create a new SingleTableFormSheet. The "{@link FormSheet#waitResponse}" property will default 089 * to true. 090 * 091 * <p>Instead of calling this method, call one of the <code>create()</code> methods provided. 092 * 093 * @param sCaption the FormSheet's caption. 094 * @param uigGate the Gate at which the FormSheet is displayed. 095 * @param fscc the content creator to be used to create the FormSheet's contents. 096 */ 097 protected SingleTableFormSheet(String sCaption, UIGate uigGate, FormSheetContentCreator fscc) { 098 super(sCaption, (JComponent)null, true); 099 100 setGate(uigGate); 101 102 // we call addContentCreator here to allow for m_anSelection to be initialized before. 103 // We cannot give fscc as a parameter to the superclass constructor, as m_anSelection would then not 104 // be initialized when the content creator is called to create the FormSheet's contents. 105 addContentCreator(fscc); 106 } 107 108 /** 109 * Set the gate at which to display the FormSheet. This will also move the FormSheet to that gate, i.e. make 110 * the FormSheet the FormSheet of the given gate. 111 * 112 * @param uigGate the new Gate. 113 * 114 * @override Never 115 * 116 * @see UIGate#setFormSheet 117 */ 118 public void setGate(UIGate uigGate) { 119 if (m_uigGate != null) { 120 m_uigGate.setFormSheet(null); 121 } 122 123 m_uigGate = uigGate; 124 125 if (m_uigGate != null) { 126 m_uigGate.setFormSheet(this); 127 } 128 } 129 130 /** 131 * Get the Gate this FormSheet is currently being displayed at. 132 * 133 * @override Never 134 */ 135 public UIGate getGate() { 136 return m_uigGate; 137 } 138 139 /** 140 * Get the record currently selected. 141 * 142 * <p>The actual class of the record depends on the concrete type of 143 * TableModel used. See the TableModel's <code>getRecord()</code> method for 144 * details. To find out, which TableModel is used by your specific instance 145 * of <code>SingleTableFormSheet</code> refer to the documentation of the 146 * <code>create()</code> method you used to instantiate it.</p> 147 */ 148 public Object getSelectedRecord() { 149 return m_atmModel.getRecord(m_anSelection[0]); 150 } 151 152 /** 153 * Get the currently attached DataBasket. 154 * 155 * @override Never 156 */ 157 public DataBasket getDataBasket() { 158 return m_db; 159 } 160 161 /** 162 * Get the table's source. 163 * 164 * @override Never 165 */ 166 public Object getTableSource() { 167 return m_source; 168 } 169 170 /** 171 * Get the table. 172 * 173 * @override Never 174 */ 175 public JTable getTable() { 176 return m_table; 177 } 178 179 /** 180 * Changes the {@link TableModel} of a table. 181 * @param tm the new TableModel 182 */ 183 public void setTableModel(AbstractTableModel tm) { 184 m_atmModel.fireTableDataChanged(); //unselect a possibly selected record 185 if (tm instanceof TableSorter) { 186 m_atmModel = tm; 187 } else { 188 m_atmModel = new TableSorter(tm); 189 } 190 m_table.setModel(m_atmModel); 191 192 ((JAbstractTable)m_table).initialize(); 193 } 194 195 /** 196 * Convenience method. Equivalent to: 197 * 198 * <pre> 199 * {@link #addAddButton addAddButton} (ebsAdd); 200 * {@link #addRemoveButton addRemoveButton} (ebsRemove); 201 * </pre> 202 * 203 * <p>This method must be called from within a content creator if you need serializability.</p> 204 * 205 * @override Never 206 */ 207 public void addEditingButtons(EditButtonStrategy ebsAdd, EditButtonStrategy ebsRemove) { 208 addAddButton(ebsAdd); 209 addRemoveButton(ebsRemove); 210 } 211 212 /** 213 * Add to the FormSheet a button that will allow the user to add records to the container being displayed. 214 * 215 * <p>The button will by default have a caption of "Add" and a button id of {@link #BTNID_ADD}. 216 * The button's action will trigger the sub-process defined by <code>ebsAdd</code>.</p> 217 * 218 * <p>This method must be called from within a content creator if you need serializability.</p> 219 * 220 * @param ebsAdd a strategy defining the sub-process to be used for adding a record. For a 221 * SingleTableFormSheet displaying a Catalog, {@link AbstractAddCatalogItemStrategy} is already part of the 222 * Framework. 223 * 224 * @override Never 225 */ 226 public void addAddButton(final EditButtonStrategy ebsAdd) { 227 removeButton(BTNID_ADD); 228 229 addButton("Add", BTNID_ADD, new sale.Action() { 230 private static final long serialVersionUID = 170542126570025997L; 231 232 public void doAction(SaleProcess p, SalesPoint sp) { 233 getGate().setNextTransition(ebsAdd.getEditProcess(SingleTableFormSheet.this, p, sp)); 234 } 235 }); 236 } 237 238 /** 239 * Add to the FormSheet a button that will allow the user to remove the currently selected record from the 240 * container being displayed. 241 * 242 * <p>The button will by default have a caption of "Remove" and a button id of 243 * {@link #BTNID_REMOVE}. The button's action will trigger the sub-process defined by 244 * <code>ebsRemove</code>.</p> 245 * 246 * <p>This method must be called from within a content creator if you need serializability.</p> 247 * 248 * @param ebsRemove a strategy defining the sub-process to be used for removing a record. For a 249 * SingleTableFormSheet displaying a Catalog, {@link DefaultRemoveCatalogItemStrategy} is already part of 250 * the Framework. 251 * 252 * @override Never 253 */ 254 public void addRemoveButton(final EditButtonStrategy ebsRemove) { 255 removeButton(BTNID_REMOVE); 256 257 addButton("Remove", BTNID_REMOVE, new sale.Action() { 258 private static final long serialVersionUID = 5594880584595305771L; 259 260 public void doAction(SaleProcess p, SalesPoint sp) { 261 getGate().setNextTransition(ebsRemove.getEditProcess(SingleTableFormSheet.this, p, sp)); 262 } 263 }); 264 } 265 266 /** 267 * Convenience method for removing the "Add" and the "Remove" button. 268 * 269 * @override Never 270 */ 271 public void removeEditButtons() { 272 removeButton(BTNID_REMOVE); 273 removeButton(BTNID_ADD); 274 } 275 276 /** 277 * Helper class forming the foundation of all SingleTableFormSheet content creators. 278 * 279 * @author Steffen Zschaler 280 * @version 2.0 20/08/1999 281 * @since v2.0 282 */ 283 private static abstract class STFSContentCreator extends FormSheetContentCreator { 284 285 /** 286 * Set the given table to be the component of the given FormSheet. Also, link the FormSheet's selection 287 * observer accordingly. 288 * 289 * @override Never 290 */ 291 protected void setFormSheetComponent(SingleTableFormSheet stfs, JAbstractTable jat) { 292 stfs.setComponent(new JScrollPane(jat)); 293 294 stfs.m_atmModel = (util.swing.AbstractTableModel)jat.getModel(); 295 stfs.m_table = jat; 296 297 jat.setSelectionObserver(stfs.m_anSelection); 298 } 299 } 300 301 // JCatalogTable FormSheet creators 302 303 /** 304 * Create and return a new SingleTableFormSheet that will display the contents of a Catalog. 305 * 306 * <p>The FormSheet will contain a {@link JCatalogTable}, the individual records are 307 * {@link CatalogItem CatalogItems}.</p> 308 * 309 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>, the sorting 310 * order defaults to the natural ordering of the CatalogItems. If <code>c</code> is a {@link Currency}, 311 * the {@link TableEntryDescriptor} defaults to a {@link DefaultCurrencyItemTED} using <code>c</code> to 312 * format values. Otherwise, it defaults to a {@link DefaultCatalogItemTED}.</p> 313 * 314 * @param sCaption the caption of the new FormSheet. 315 * @param c the Catalog whose contents are to be displayed. 316 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 317 * performed through the FormSheet. 318 */ 319 public static SingleTableFormSheet create(String sCaption, Catalog c, UIGate uigGate) { 320 return create(sCaption, c, uigGate, null, null, 321 ((c instanceof data.Currency) ? (new DefaultCurrencyItemTED((data.Currency)c)) : 322 (new DefaultCatalogItemTED()))); 323 } 324 325 /** 326 * Create and return a new SingleTableFormSheet that will display the contents of a Catalog. 327 * 328 * <p>The FormSheet will contain a {@link JCatalogTable}, the individual records are 329 * {@link CatalogItem CatalogItems}.</p> 330 * 331 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>, the sorting 332 * order defaults to the natural ordering of the CatalogItems.</p> 333 * 334 * @param sCaption the caption of the new FormSheet. 335 * @param c the Catalog whose contents are to be displayed. 336 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 337 * performed through the FormSheet. 338 * @param ted a TableEntryDescriptor that can split individual CatalogItems into a table's cells. Must not 339 * be <code>null</code>. 340 */ 341 public static SingleTableFormSheet create(String sCaption, Catalog c, UIGate uigGate, 342 TableEntryDescriptor ted) { 343 return create(sCaption, c, uigGate, null, null, ted); 344 } 345 346 /** 347 * Create and return a new SingleTableFormSheet that will display the contents of a Catalog. 348 * 349 * <p>The FormSheet will contain a {@link JCatalogTable}, the individual records are 350 * {@link CatalogItem CatalogItems}.</p> 351 * 352 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>. If 353 * <code>c</code> is a {@link Currency}, the {@link TableEntryDescriptor} defaults to a 354 * {@link DefaultCurrencyItemTED} using <code>c</code> to format values. Otherwise, it defaults to a 355 * {@link DefaultCatalogItemTED}.</p> 356 * 357 * @param sCaption the caption of the new FormSheet. 358 * @param c the Catalog whose contents are to be displayed. 359 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 360 * performed through the FormSheet. 361 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 362 * the natural ordering of the CatalogItems will be followed. 363 */ 364 public static SingleTableFormSheet create(String sCaption, Catalog c, UIGate uigGate, Comparator<CatalogItem> cmp) { 365 return create(sCaption, c, uigGate, null, cmp, 366 ((c instanceof data.Currency) ? (new DefaultCurrencyItemTED((data.Currency)c)) : 367 (new DefaultCatalogItemTED()))); 368 } 369 370 /** 371 * Create and return a new SingleTableFormSheet that will display the contents of a Catalog. 372 * 373 * <p>The FormSheet will contain a {@link JCatalogTable}, the individual records are 374 * {@link CatalogItem CatalogItems}.</p> 375 * 376 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>.</p> 377 * 378 * @param sCaption the caption of the new FormSheet. 379 * @param c the Catalog whose contents are to be displayed. 380 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 381 * performed through the FormSheet. 382 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 383 * the natural ordering of the CatalogItems will be followed. 384 * @param ted a TableEntryDescriptor that can split individual CatalogItems into a table's cells. Must not 385 * be <code>null</code>. 386 */ 387 public static SingleTableFormSheet create(String sCaption, Catalog c, UIGate uigGate, Comparator<CatalogItem> cmp, 388 TableEntryDescriptor ted) { 389 return create(sCaption, c, uigGate, null, cmp, ted); 390 } 391 392 /** 393 * Create and return a new SingleTableFormSheet that will display the contents of a Catalog. 394 * 395 * <p>The FormSheet will contain a {@link JCatalogTable}, the individual records are 396 * {@link CatalogItem CatalogItems}.</p> 397 * 398 * <p>The sorting order defaults to the natural ordering of the CatalogItems. If <code>c</code> is a 399 * {@link Currency}, the {@link TableEntryDescriptor} defaults to a {@link DefaultCurrencyItemTED} using 400 * <code>c</code> to format values. Otherwise, it defaults to a {@link DefaultCatalogItemTED}.</p> 401 * 402 * @param sCaption the caption of the new FormSheet. 403 * @param c the Catalog whose contents are to be displayed. 404 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 405 * performed through the FormSheet. 406 * @param db the DataBasket that is used to determine visibility of items. 407 */ 408 public static SingleTableFormSheet create(String sCaption, Catalog c, UIGate uigGate, DataBasket db) { 409 return create(sCaption, c, uigGate, db, null, 410 ((c instanceof data.Currency) ? (new DefaultCurrencyItemTED((data.Currency)c)) : 411 (new DefaultCatalogItemTED()))); 412 } 413 414 /** 415 * Create and return a new SingleTableFormSheet that will display the contents of a Catalog. 416 * 417 * <p>The FormSheet will contain a {@link JCatalogTable}, the individual records are 418 * {@link CatalogItem CatalogItems}.</p> 419 * 420 * <p>The sorting order defaults to the natural ordering of the CatalogItems.</p> 421 * 422 * @param sCaption the caption of the new FormSheet. 423 * @param c the Catalog whose contents are to be displayed. 424 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 425 * performed through the FormSheet. 426 * @param db the DataBasket that is used to determine visibility of items. 427 * @param ted a TableEntryDescriptor that can split individual CatalogItems into a table's cells. Must not 428 * be <code>null</code>. 429 */ 430 public static SingleTableFormSheet create(String sCaption, Catalog c, UIGate uigGate, DataBasket db, 431 TableEntryDescriptor ted) { 432 return create(sCaption, c, uigGate, db, null, ted); 433 } 434 435 /** 436 * Create and return a new SingleTableFormSheet that will display the contents of a Catalog. 437 * 438 * <p>The FormSheet will contain a {@link JCatalogTable}, the individual records are 439 * {@link CatalogItem CatalogItems}.</p> 440 * 441 * <p>If <code>c</code> is a {@link Currency}, the {@link TableEntryDescriptor} defaults to a 442 * {@link DefaultCurrencyItemTED} using <code>c</code> to format values. Otherwise, it defaults to a 443 * {@link DefaultCatalogItemTED}.</p> 444 * 445 * @param sCaption the caption of the new FormSheet. 446 * @param c the Catalog whose contents are to be displayed. 447 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 448 * performed through the FormSheet. 449 * @param db the DataBasket that is used to determine visibility of items. 450 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 451 * the natural ordering of the CatalogItems will be followed. 452 */ 453 public static SingleTableFormSheet create(String sCaption, Catalog c, UIGate uigGate, DataBasket db, 454 Comparator<CatalogItem> cmp) { 455 return create(sCaption, c, uigGate, db, cmp, 456 ((c instanceof data.Currency) ? (new DefaultCurrencyItemTED((data.Currency)c)) : 457 (new DefaultCatalogItemTED()))); 458 } 459 460 /** 461 * Create and return a new SingleTableFormSheet that will display the contents of a Catalog. 462 * 463 * <p>The FormSheet will contain a {@link JCatalogTable}, the individual records are 464 * {@link CatalogItem CatalogItems}.</p> 465 * 466 * @param sCaption the caption of the new FormSheet. 467 * @param c the Catalog whose contents are to be displayed. 468 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 469 * performed through the FormSheet. 470 * @param db the DataBasket that is used to determine visibility of items. 471 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 472 * the natural ordering of the CatalogItems will be followed. 473 * @param ted a TableEntryDescriptor that can split individual CatalogItems into a table's cells. Must not 474 * be <code>null</code>. 475 */ 476 public static SingleTableFormSheet create(String sCaption, final Catalog c, UIGate uigGate, 477 final DataBasket db, final Comparator<CatalogItem> cmp, final TableEntryDescriptor ted) { 478 return new SingleTableFormSheet(sCaption, uigGate, new STFSContentCreator() { 479 private static final long serialVersionUID = 2315488565898437009L; 480 481 protected void createFormSheetContent(FormSheet fs) { 482 final SingleTableFormSheet stfs = (SingleTableFormSheet)fs; 483 JCatalogTable jct = new JCatalogTable(c, db, cmp, ted); 484 485 setFormSheetComponent((SingleTableFormSheet)fs, jct); 486 stfs.m_source = c; 487 stfs.m_db = db; 488 } 489 }); 490 } 491 492 // JCountingStockTable FormSheet creators 493 494 /** 495 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 496 * 497 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 498 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 499 * 500 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>, the sorting 501 * order defaults to the natural ordering of the keys. Lines containing '0' in the "Count" column 502 * will by default be hidden. If <code>cs</code> is a {@link MoneyBag}, the {@link TableEntryDescriptor} 503 * defaults to a {@link DefaultMoneyBagItemTED} using <code>cs.getCatalog()</code> to format values. 504 * Otherwise, it defaults to a {@link DefaultCountingStockItemTED}.</p> 505 * 506 * @param sCaption the caption of the new FormSheet. 507 * @param cs the CountingStock whose contents are to be displayed. 508 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 509 * performed through the FormSheet. 510 */ 511 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate) { 512 return create(sCaption, cs, uigGate, null, null, false, 513 ((cs instanceof MoneyBag) ? (new DefaultMoneyBagItemTED((data.Currency)cs.getCatalog(null))) : 514 (new DefaultCountingStockItemTED()))); 515 } 516 517 /** 518 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 519 * 520 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 521 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 522 * 523 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>, the sorting 524 * order defaults to the natural ordering of the keys. Lines containing '0' in the "Count" column 525 * will by default be hidden.</p> 526 * 527 * @param sCaption the caption of the new FormSheet. 528 * @param cs the CountingStock whose contents are to be displayed. 529 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 530 * performed through the FormSheet. 531 * @param ted a TableEntryDescriptor that can split individual 532 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records} into a table's cells. Must not be 533 * <code>null</code>. 534 */ 535 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 536 TableEntryDescriptor ted) { 537 return create(sCaption, cs, uigGate, null, null, false, ted); 538 } 539 540 /** 541 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 542 * 543 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 544 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 545 * 546 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>, the sorting 547 * order defaults to the natural ordering of the keys. If <code>cs</code> is a {@link MoneyBag}, the 548 * {@link TableEntryDescriptor} defaults to a {@link DefaultMoneyBagItemTED} using 549 * <code>cs.getCatalog()</code> to format values. Otherwise, it defaults to a 550 * {@link DefaultCountingStockItemTED}.</p> 551 * 552 * @param sCaption the caption of the new FormSheet. 553 * @param cs the CountingStock whose contents are to be displayed. 554 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 555 * performed through the FormSheet. 556 * @param fShowZeros if false, lines containing a '0' in the "Count" field will be hidden. 557 */ 558 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 559 boolean fShowZeros) { 560 return create(sCaption, cs, uigGate, null, null, fShowZeros, 561 ((cs instanceof MoneyBag) ? (new DefaultMoneyBagItemTED((data.Currency)cs.getCatalog(null))) : 562 (new DefaultCountingStockItemTED()))); 563 } 564 565 /** 566 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 567 * 568 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 569 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 570 * 571 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>, the sorting 572 * order defaults to the natural ordering of the keys.</p> 573 * 574 * @param sCaption the caption of the new FormSheet. 575 * @param cs the CountingStock whose contents are to be displayed. 576 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 577 * performed through the FormSheet. 578 * @param fShowZeros if false, lines containing a '0' in the "Count" field will be hidden. 579 * @param ted a TableEntryDescriptor that can split individual 580 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records} into a table's cells. Must not be 581 * <code>null</code>. 582 */ 583 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 584 boolean fShowZeros, TableEntryDescriptor ted) { 585 return create(sCaption, cs, uigGate, null, null, fShowZeros, ted); 586 } 587 588 /** 589 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 590 * 591 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 592 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 593 * 594 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>. Lines 595 * containing '0' in the "Count" column will by default be hidden. If <code>cs</code> is a 596 * {@link MoneyBag}, the {@link TableEntryDescriptor} defaults to a {@link DefaultMoneyBagItemTED} using 597 * <code>cs.getCatalog()</code> to format values. Otherwise, it defaults to a 598 * {@link DefaultCountingStockItemTED}.</p> 599 * 600 * @param sCaption the caption of the new FormSheet. 601 * @param cs the CountingStock whose contents are to be displayed. 602 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 603 * performed through the FormSheet. 604 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 605 * the records will be ordered by their keys. 606 */ 607 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 608 Comparator<CatalogItem> cmp) { 609 return create(sCaption, cs, uigGate, null, cmp, false, 610 ((cs instanceof MoneyBag) ? (new DefaultMoneyBagItemTED((data.Currency)cs.getCatalog(null))) : 611 (new DefaultCountingStockItemTED()))); 612 } 613 614 /** 615 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 616 * 617 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 618 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 619 * 620 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>. Lines 621 * containing '0' in the "Count" column will by default be hidden.</p> 622 * 623 * @param sCaption the caption of the new FormSheet. 624 * @param cs the CountingStock whose contents are to be displayed. 625 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 626 * performed through the FormSheet. 627 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 628 * the records will be ordered by their keys. 629 * @param ted a TableEntryDescriptor that can split individual 630 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records} into a table's cells. Must not be 631 * <code>null</code>. 632 */ 633 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 634 Comparator<CatalogItem> cmp, TableEntryDescriptor ted) { 635 return create(sCaption, cs, uigGate, null, cmp, false, ted); 636 } 637 638 /** 639 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 640 * 641 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 642 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 643 * 644 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>. If 645 * <code>cs</code> is a {@link MoneyBag}, the {@link TableEntryDescriptor} defaults to a 646 * {@link DefaultMoneyBagItemTED} using <code>cs.getCatalog()</code> to format values. Otherwise, it 647 * defaults to a {@link DefaultCountingStockItemTED}.</p> 648 * 649 * @param sCaption the caption of the new FormSheet. 650 * @param cs the CountingStock whose contents are to be displayed. 651 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 652 * performed through the FormSheet. 653 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 654 * the records will be ordered by their keys. 655 * @param fShowZeros if false, lines containing a '0' in the "Count" field will be hidden. 656 */ 657 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 658 Comparator<CatalogItem> cmp, boolean fShowZeros) { 659 return create(sCaption, cs, uigGate, null, cmp, fShowZeros, 660 ((cs instanceof MoneyBag) ? (new DefaultMoneyBagItemTED((data.Currency)cs.getCatalog(null))) : 661 (new DefaultCountingStockItemTED()))); 662 } 663 664 /** 665 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 666 * 667 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 668 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 669 * 670 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>.</p> 671 * 672 * @param sCaption the caption of the new FormSheet. 673 * @param cs the CountingStock whose contents are to be displayed. 674 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 675 * performed through the FormSheet. 676 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 677 * the records will be ordered by their keys. 678 * @param fShowZeros if false, lines containing a '0' in the "Count" field will be hidden. 679 * @param ted a TableEntryDescriptor that can split individual 680 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records} into a table's cells. Must not be 681 * <code>null</code>. 682 */ 683 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 684 Comparator<CatalogItem> cmp, boolean fShowZeros, TableEntryDescriptor ted) { 685 return create(sCaption, cs, uigGate, null, cmp, fShowZeros, ted); 686 } 687 688 /** 689 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 690 * 691 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 692 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 693 * 694 * <p>The sorting order defaults to the natural ordering of the keys. Lines containing '0' in the 695 * "Count" column will by default be hidden. If <code>cs</code> is a {@link MoneyBag}, the 696 * {@link TableEntryDescriptor} defaults to a {@link DefaultMoneyBagItemTED} using 697 * <code>cs.getCatalog()</code> to format values. Otherwise, it defaults to a 698 * {@link DefaultCountingStockItemTED}.</p> 699 * 700 * @param sCaption the caption of the new FormSheet. 701 * @param cs the CountingStock whose contents are to be displayed. 702 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 703 * performed through the FormSheet. 704 * @param db the DataBasket that is used to determine visibility of items. 705 */ 706 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 707 DataBasket db) { 708 return create(sCaption, cs, uigGate, db, null, false, 709 ((cs instanceof MoneyBag) ? (new DefaultMoneyBagItemTED((data.Currency)cs.getCatalog(db))) : 710 (new DefaultCountingStockItemTED()))); 711 } 712 713 /** 714 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 715 * 716 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 717 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 718 * 719 * <p>The sorting order defaults to the natural ordering of the keys. Lines containing '0' in the 720 * "Count" column will by default be hidden.</p> 721 * 722 * @param sCaption the caption of the new FormSheet. 723 * @param cs the CountingStock whose contents are to be displayed. 724 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 725 * performed through the FormSheet. 726 * @param db the DataBasket that is used to determine visibility of items. 727 * @param ted a TableEntryDescriptor that can split individual 728 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records} into a table's cells. Must not be 729 * <code>null</code>. 730 */ 731 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 732 DataBasket db, TableEntryDescriptor ted) { 733 return create(sCaption, cs, uigGate, db, null, false, ted); 734 } 735 736 /** 737 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 738 * 739 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 740 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 741 * 742 * <p>The sorting order defaults to the natural ordering of the keys. If <code>cs</code> is a 743 * {@link MoneyBag}, the {@link TableEntryDescriptor} defaults to a {@link DefaultMoneyBagItemTED} using 744 * <code>cs.getCatalog()</code> to format values. Otherwise, it defaults to a 745 * {@link DefaultCountingStockItemTED}.</p> 746 * 747 * @param sCaption the caption of the new FormSheet. 748 * @param cs the CountingStock whose contents are to be displayed. 749 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 750 * performed through the FormSheet. 751 * @param db the DataBasket that is used to determine visibility of items. 752 * @param fShowZeros if false, lines containing a '0' in the "Count" field will be hidden. 753 */ 754 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 755 DataBasket db, boolean fShowZeros) { 756 return create(sCaption, cs, uigGate, db, null, fShowZeros, 757 ((cs instanceof MoneyBag) ? (new DefaultMoneyBagItemTED((data.Currency)cs.getCatalog(db))) : 758 (new DefaultCountingStockItemTED()))); 759 } 760 761 /** 762 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 763 * 764 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 765 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 766 * 767 * <p>The sorting order defaults to the natural ordering of the keys.</p> 768 * 769 * @param sCaption the caption of the new FormSheet. 770 * @param cs the CountingStock whose contents are to be displayed. 771 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 772 * performed through the FormSheet. 773 * @param db the DataBasket that is used to determine visibility of items. 774 * @param fShowZeros if false, lines containing a '0' in the "Count" field will be hidden. 775 * @param ted a TableEntryDescriptor that can split individual 776 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records} into a table's cells. Must not be 777 * <code>null</code>. 778 */ 779 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 780 DataBasket db, boolean fShowZeros, TableEntryDescriptor ted) { 781 return create(sCaption, cs, uigGate, db, null, fShowZeros, ted); 782 } 783 784 /** 785 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 786 * 787 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 788 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 789 * 790 * <p>Lines containing '0' in the "Count" column will by default be hidden. If <code>cs</code> is 791 * a {@link MoneyBag}, the {@link TableEntryDescriptor} defaults to a {@link DefaultMoneyBagItemTED} using 792 * <code>cs.getCatalog()</code> to format values. Otherwise, it defaults to a 793 * {@link DefaultCountingStockItemTED}.</p> 794 * 795 * @param sCaption the caption of the new FormSheet. 796 * @param cs the CountingStock whose contents are to be displayed. 797 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 798 * performed through the FormSheet. 799 * @param db the DataBasket that is used to determine visibility of items. 800 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 801 * the records will be ordered by their keys. 802 */ 803 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 804 DataBasket db, Comparator<CatalogItem> cmp) { 805 return create(sCaption, cs, uigGate, db, cmp, false, 806 ((cs instanceof MoneyBag) ? (new DefaultMoneyBagItemTED((data.Currency)cs.getCatalog(db))) : 807 (new DefaultCountingStockItemTED()))); 808 } 809 810 /** 811 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 812 * 813 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 814 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 815 * 816 * <p>Lines containing '0' in the "Count" column will by default be hidden.</p> 817 * 818 * @param sCaption the caption of the new FormSheet. 819 * @param cs the CountingStock whose contents are to be displayed. 820 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 821 * performed through the FormSheet. 822 * @param db the DataBasket that is used to determine visibility of items. 823 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 824 * the records will be ordered by their keys. 825 * @param ted a TableEntryDescriptor that can split individual 826 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records} into a table's cells. Must not be 827 * <code>null</code>. 828 */ 829 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 830 DataBasket db, Comparator<CatalogItem> cmp, TableEntryDescriptor ted) { 831 return create(sCaption, cs, uigGate, db, cmp, false, ted); 832 } 833 834 /** 835 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 836 * 837 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 838 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 839 * 840 * <p>If <code>cs</code> is a {@link MoneyBag}, the {@link TableEntryDescriptor} defaults to a 841 * {@link DefaultMoneyBagItemTED} using <code>cs.getCatalog()</code> to format values. Otherwise, it 842 * defaults to a {@link DefaultCountingStockItemTED}.</p> 843 * 844 * @param sCaption the caption of the new FormSheet. 845 * @param cs the CountingStock whose contents are to be displayed. 846 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 847 * performed through the FormSheet. 848 * @param db the DataBasket that is used to determine visibility of items. 849 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 850 * the records will be ordered by their keys. 851 * @param fShowZeros if false, lines containing a '0' in the "Count" field will be hidden. 852 */ 853 public static SingleTableFormSheet create(String sCaption, CountingStock cs, UIGate uigGate, 854 DataBasket db, Comparator<CatalogItem> cmp, boolean fShowZeros) { 855 return create(sCaption, cs, uigGate, db, cmp, fShowZeros, 856 ((cs instanceof MoneyBag) ? (new DefaultMoneyBagItemTED((data.Currency)cs.getCatalog(db))) : 857 (new DefaultCountingStockItemTED()))); 858 } 859 860 /** 861 * Create and return a new SingleTableFormSheet that will display the contents of a CountingStock. 862 * 863 * <p>The FormSheet will contain a {@link JCountingStockTable}, the individual records are 864 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records}.</p> 865 * 866 * @param sCaption the caption of the new FormSheet. 867 * @param cs the CountingStock whose contents are to be displayed. 868 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 869 * performed through the FormSheet. 870 * @param db the DataBasket that is used to determine visibility of items. 871 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 872 * the records will be ordered by their keys. 873 * @param fShowZeros if false, lines containing a '0' in the "Count" field will be hidden. 874 * @param ted a TableEntryDescriptor that can split individual 875 * {@link data.swing.CountingStockTableModel.Record CountingStockTableModel records} into a table's cells. Must not be 876 * <code>null</code>. 877 */ 878 public static SingleTableFormSheet create(String sCaption, final CountingStock cs, UIGate uigGate, 879 final DataBasket db, final Comparator<CatalogItem> cmp, final boolean fShowZeros, 880 final TableEntryDescriptor ted) { 881 return new SingleTableFormSheet(sCaption, uigGate, new STFSContentCreator() { 882 private static final long serialVersionUID = 4972958646893917497L; 883 884 protected void createFormSheetContent(FormSheet fs) { 885 final SingleTableFormSheet stfs = (SingleTableFormSheet)fs; 886 JCountingStockTable jcst = new JCountingStockTable(cs, db, cmp, fShowZeros, ted); 887 setFormSheetComponent((SingleTableFormSheet)fs, jcst); 888 stfs.m_source = cs; 889 stfs.m_db = db; 890 } 891 }); 892 } 893 894 // JStoringStockTable FormSheet creators 895 896 /** 897 * Create and return a new SingleTableFormSheet that will display the contents of a StoringStock. 898 * 899 * <p>The FormSheet will contain a {@link JStoringStockTable}, the individual records are 900 * {@link StockItem StockItems}.</p> 901 * 902 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>, the sorting 903 * order defaults to the natural ordering of the StockItems. The {@link TableEntryDescriptor} defaults to a 904 * {@link DefaultStockItemTED}.</p> 905 * 906 * @param sCaption the caption of the new FormSheet. 907 * @param ss the StoringStock whose contents are to be displayed. 908 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 909 * performed through the FormSheet. 910 */ 911 public static SingleTableFormSheet create(String sCaption, StoringStock ss, UIGate uigGate) { 912 return create(sCaption, ss, uigGate, null, null, new DefaultStockItemTED()); 913 } 914 915 /** 916 * Create and return a new SingleTableFormSheet that will display the contents of a StoringStock. 917 * 918 * <p>The FormSheet will contain a {@link JStoringStockTable}, the individual records are 919 * {@link StockItem StockItems}.</p> 920 * 921 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>, the sorting 922 * order defaults to the natural ordering of the StockItems.</p> 923 * 924 * @param sCaption the caption of the new FormSheet. 925 * @param ss the StoringStock whose contents are to be displayed. 926 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 927 * performed through the FormSheet. 928 * @param ted a TableEntryDescriptor that can split individual {@link StockItem StockItems} into a table's 929 * cells. Must not be <code>null</code>. 930 */ 931 public static SingleTableFormSheet create(String sCaption, StoringStock ss, UIGate uigGate, 932 TableEntryDescriptor ted) { 933 return create(sCaption, ss, uigGate, null, null, ted); 934 } 935 936 /** 937 * Create and return a new SingleTableFormSheet that will display the contents of a StoringStock. 938 * 939 * <p>The FormSheet will contain a {@link JStoringStockTable}, the individual records are 940 * {@link StockItem StockItems}.</p> 941 * 942 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>. The 943 * {@link TableEntryDescriptor} defaults to a {@link DefaultStockItemTED}.</p> 944 * 945 * @param sCaption the caption of the new FormSheet. 946 * @param ss the StoringStock whose contents are to be displayed. 947 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 948 * performed through the FormSheet. 949 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 950 * the natural order of the StockItems will be applied. 951 */ 952 public static SingleTableFormSheet create(String sCaption, StoringStock ss, UIGate uigGate, 953 Comparator<StockItem> cmp) { 954 return create(sCaption, ss, uigGate, null, cmp, new DefaultStockItemTED()); 955 } 956 957 /** 958 * Create and return a new SingleTableFormSheet that will display the contents of a StoringStock. 959 * 960 * <p>The FormSheet will contain a {@link JStoringStockTable}, the individual records are 961 * {@link StockItem StockItems}.</p> 962 * 963 * <p>The {@link DataBasket} used to determine visibility will default to <code>null</code>.</p> 964 * 965 * @param sCaption the caption of the new FormSheet. 966 * @param ss the StoringStock whose contents are to be displayed. 967 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 968 * performed through the FormSheet. 969 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 970 * the natural order of the StockItems will be applied. 971 * @param ted a TableEntryDescriptor that can split individual {@link StockItem StockItems} into a table's 972 * cells. Must not be <code>null</code>. 973 */ 974 public static SingleTableFormSheet create(String sCaption, StoringStock ss, UIGate uigGate, 975 Comparator<StockItem> cmp, TableEntryDescriptor ted) { 976 return create(sCaption, ss, uigGate, null, cmp, ted); 977 } 978 979 /** 980 * Create and return a new SingleTableFormSheet that will display the contents of a StoringStock. 981 * 982 * <p>The FormSheet will contain a {@link JStoringStockTable}, the individual records are 983 * {@link StockItem StockItems}.</p> 984 * 985 * <p>The sorting order defaults to the natural ordering of the StockItems. The {@link TableEntryDescriptor} 986 * defaults to a {@link DefaultStockItemTED}.</p> 987 * 988 * @param sCaption the caption of the new FormSheet. 989 * @param ss the StoringStock whose contents are to be displayed. 990 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 991 * performed through the FormSheet. 992 * @param db the DataBasket that is used to determine visibility of items. 993 */ 994 public static SingleTableFormSheet create(String sCaption, StoringStock ss, UIGate uigGate, DataBasket db) { 995 return create(sCaption, ss, uigGate, db, null, new DefaultStockItemTED()); 996 } 997 998 /** 999 * Create and return a new SingleTableFormSheet that will display the contents of a StoringStock. 1000 * 1001 * <p>The FormSheet will contain a {@link JStoringStockTable}, the individual records are 1002 * {@link StockItem StockItems}.</p> 1003 * 1004 * <p>The sorting order defaults to the natural ordering of the StockItems.</p> 1005 * 1006 * @param sCaption the caption of the new FormSheet. 1007 * @param ss the StoringStock whose contents are to be displayed. 1008 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1009 * performed through the FormSheet. 1010 * @param db the DataBasket that is used to determine visibility of items. 1011 * @param ted a TableEntryDescriptor that can split individual {@link StockItem StockItems} into a table's 1012 * cells. Must not be <code>null</code>. 1013 */ 1014 public static SingleTableFormSheet create(String sCaption, StoringStock ss, UIGate uigGate, DataBasket db, 1015 TableEntryDescriptor ted) { 1016 return create(sCaption, ss, uigGate, db, null, ted); 1017 } 1018 1019 /** 1020 * Create and return a new SingleTableFormSheet that will display the contents of a StoringStock. 1021 * 1022 * <p>The FormSheet will contain a {@link JStoringStockTable}, the individual records are 1023 * {@link StockItem StockItems}.</p> 1024 * 1025 * <p>The {@link TableEntryDescriptor} defaults to a {@link DefaultStockItemTED}.</p> 1026 * 1027 * @param sCaption the caption of the new FormSheet. 1028 * @param ss the StoringStock whose contents are to be displayed. 1029 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1030 * performed through the FormSheet. 1031 * @param db the DataBasket that is used to determine visibility of items. 1032 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 1033 * the natural order of the StockItems will be applied. 1034 */ 1035 public static SingleTableFormSheet create(String sCaption, StoringStock ss, UIGate uigGate, DataBasket db, 1036 Comparator<StockItem> cmp) { 1037 return create(sCaption, ss, uigGate, db, cmp, new DefaultStockItemTED()); 1038 } 1039 1040 /** 1041 * Create and return a new SingleTableFormSheet that will display the contents of a StoringStock. 1042 * 1043 * <p>The FormSheet will contain a {@link JStoringStockTable}, the individual records are 1044 * {@link StockItem StockItems}.</p> 1045 * 1046 * @param sCaption the caption of the new FormSheet. 1047 * @param ss the StoringStock whose contents are to be displayed. 1048 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1049 * performed through the FormSheet. 1050 * @param db the DataBasket that is used to determine visibility of items. 1051 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 1052 * the natural order of the StockItems will be applied. 1053 * @param ted a TableEntryDescriptor that can split individual {@link StockItem StockItems} into a table's 1054 * cells. Must not be <code>null</code>. 1055 */ 1056 public static SingleTableFormSheet create(String sCaption, final StoringStock ss, UIGate uigGate, 1057 final DataBasket db, final Comparator<StockItem> cmp, final TableEntryDescriptor ted) { 1058 return new SingleTableFormSheet(sCaption, uigGate, new STFSContentCreator() { 1059 private static final long serialVersionUID = -2093620574395551989L; 1060 1061 protected void createFormSheetContent(FormSheet fs) { 1062 final SingleTableFormSheet stfs = (SingleTableFormSheet)fs; 1063 JStoringStockTable jsst = new JStoringStockTable(ss, db, cmp, ted); 1064 setFormSheetComponent((SingleTableFormSheet)fs, jsst); 1065 stfs.m_source = ss; 1066 stfs.m_db = db; 1067 } 1068 }); 1069 } 1070 1071 // JDataBasketTable FormSheet creators 1072 1073 /** 1074 * Create and return a new SingleTableFormSheet that will display the contents of a DataBasket. 1075 * 1076 * <p>The FormSheet will contain a {@link JDataBasketTable}, the individual records are 1077 * {@link DataBasketEntry DataBasketEntries}.</p> 1078 * 1079 * <p>The default is to show all entries and apply no grouping. The default sorting order sorts entries by 1080 * their main keys and then by their secondary keys.</p> 1081 * 1082 * @param sCaption the caption of the new FormSheet. 1083 * @param db the DataBasket whose contents are to be displayed. 1084 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1085 * performed through the FormSheet. 1086 * @param ted a TableEntryDescriptor that can split individual {@link DataBasketEntry DataBasketEntries} 1087 * into a table's cells. Must not be <code>null</code>. 1088 */ 1089 public static SingleTableFormSheet create(String sCaption, DataBasket db, UIGate uigGate, 1090 TableEntryDescriptor ted) { 1091 return create(sCaption, db, uigGate, DataBasketConditionImpl.ALL_ENTRIES, null, null, ted); 1092 } 1093 1094 /** 1095 * Create and return a new SingleTableFormSheet that will display the contents of a DataBasket. 1096 * 1097 * <p>The FormSheet will contain a {@link JDataBasketTable}, the individual records are 1098 * {@link DataBasketEntry DataBasketEntries}.</p> 1099 * 1100 * <p>The default is to show all entries and apply no grouping.</p> 1101 * 1102 * @param sCaption the caption of the new FormSheet. 1103 * @param db the DataBasket whose contents are to be displayed. 1104 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1105 * performed through the FormSheet. 1106 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 1107 * entries will be sorted first by their main and then by their secondary keys. 1108 * @param ted a TableEntryDescriptor that can split individual {@link DataBasketEntry DataBasketEntries} 1109 * into a table's cells. Must not be <code>null</code>. 1110 */ 1111 public static SingleTableFormSheet create(String sCaption, DataBasket db, UIGate uigGate, Comparator<DataBasketEntry> cmp, 1112 TableEntryDescriptor ted) { 1113 return create(sCaption, db, uigGate, DataBasketConditionImpl.ALL_ENTRIES, null, cmp, ted); 1114 } 1115 1116 /** 1117 * Create and return a new SingleTableFormSheet that will display the contents of a DataBasket. 1118 * 1119 * <p>The FormSheet will contain a {@link JDataBasketTable}, the individual records are 1120 * {@link DataBasketEntry DataBasketEntries}.</p> 1121 * 1122 * <p>The default is to show all entries. The default sorting order sorts entries by their main keys and 1123 * then by their secondary keys.</p> 1124 * 1125 * @param sCaption the caption of the new FormSheet. 1126 * @param db the DataBasket whose contents are to be displayed. 1127 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1128 * performed through the FormSheet. 1129 * @param dbeg a grouper that can be used to combine several entries into one for display. 1130 * @param ted a TableEntryDescriptor that can split individual {@link DataBasketEntry DataBasketEntries} 1131 * into a table's cells. Must not be <code>null</code>. 1132 */ 1133 public static SingleTableFormSheet create(String sCaption, DataBasket db, UIGate uigGate, 1134 DataBasketEntryGrouper dbeg, TableEntryDescriptor ted) { 1135 return create(sCaption, db, uigGate, DataBasketConditionImpl.ALL_ENTRIES, dbeg, null, ted); 1136 } 1137 1138 /** 1139 * Create and return a new SingleTableFormSheet that will display the contents of a DataBasket. 1140 * 1141 * <p>The FormSheet will contain a {@link JDataBasketTable}, the individual records are 1142 * {@link DataBasketEntry DataBasketEntries}.</p> 1143 * 1144 * <p>The default is to show all entries.</p> 1145 * 1146 * @param sCaption the caption of the new FormSheet. 1147 * @param db the DataBasket whose contents are to be displayed. 1148 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1149 * performed through the FormSheet. 1150 * @param dbeg a grouper that can be used to combine several entries into one for display. 1151 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 1152 * entries will be sorted first by their main and then by their secondary keys. 1153 * @param ted a TableEntryDescriptor that can split individual {@link DataBasketEntry DataBasketEntries} 1154 * into a table's cells. Must not be <code>null</code>. 1155 */ 1156 public static SingleTableFormSheet create(String sCaption, DataBasket db, UIGate uigGate, 1157 DataBasketEntryGrouper dbeg, Comparator<DataBasketEntry> cmp, TableEntryDescriptor ted) { 1158 return create(sCaption, db, uigGate, DataBasketConditionImpl.ALL_ENTRIES, dbeg, cmp, ted); 1159 } 1160 1161 /** 1162 * Create and return a new SingleTableFormSheet that will display the contents of a DataBasket. 1163 * 1164 * <p>The FormSheet will contain a {@link JDataBasketTable}, the individual records are 1165 * {@link DataBasketEntry DataBasketEntries}.</p> 1166 * 1167 * <p>The default is to apply no grouping. The default sorting order sorts entries by 1168 * their main keys and then by their secondary keys.</p> 1169 * 1170 * @param sCaption the caption of the new FormSheet. 1171 * @param db the DataBasket whose contents are to be displayed. 1172 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1173 * performed through the FormSheet. 1174 * @param dbc a condition specifying the entries to be displayed. 1175 * @param ted a TableEntryDescriptor that can split individual {@link DataBasketEntry DataBasketEntries} 1176 * into a table's cells. Must not be <code>null</code>. 1177 */ 1178 public static SingleTableFormSheet create(String sCaption, DataBasket db, UIGate uigGate, 1179 DataBasketCondition dbc, TableEntryDescriptor ted) { 1180 return create(sCaption, db, uigGate, dbc, null, null, ted); 1181 } 1182 1183 /** 1184 * Create and return a new SingleTableFormSheet that will display the contents of a DataBasket. 1185 * 1186 * <p>The FormSheet will contain a {@link JDataBasketTable}, the individual records are 1187 * {@link DataBasketEntry DataBasketEntries}.</p> 1188 * 1189 * <p>The default is to apply no grouping.</p> 1190 * 1191 * @param sCaption the caption of the new FormSheet. 1192 * @param db the DataBasket whose contents are to be displayed. 1193 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1194 * performed through the FormSheet. 1195 * @param dbc a condition specifying the entries to be displayed. 1196 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 1197 * entries will be sorted first by their main and then by their secondary keys. 1198 * @param ted a TableEntryDescriptor that can split individual {@link DataBasketEntry DataBasketEntries} 1199 * into a table's cells. Must not be <code>null</code>. 1200 */ 1201 public static SingleTableFormSheet create(String sCaption, DataBasket db, UIGate uigGate, 1202 DataBasketCondition dbc, Comparator<DataBasketEntry> cmp, TableEntryDescriptor ted) { 1203 return create(sCaption, db, uigGate, dbc, null, cmp, ted); 1204 } 1205 1206 /** 1207 * Create and return a new SingleTableFormSheet that will display the contents of a DataBasket. 1208 * 1209 * <p>The FormSheet will contain a {@link JDataBasketTable}, the individual records are 1210 * {@link DataBasketEntry DataBasketEntries}.</p> 1211 * 1212 * <p>The default sorting order sorts entries by their main keys and then by their secondary keys.</p> 1213 * 1214 * @param sCaption the caption of the new FormSheet. 1215 * @param db the DataBasket whose contents are to be displayed. 1216 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1217 * performed through the FormSheet. 1218 * @param dbc a condition specifying the entries to be displayed. 1219 * @param dbeg a grouper that can be used to combine several entries into one for display. 1220 * @param ted a TableEntryDescriptor that can split individual {@link DataBasketEntry DataBasketEntries} 1221 * into a table's cells. Must not be <code>null</code>. 1222 */ 1223 public static SingleTableFormSheet create(String sCaption, DataBasket db, UIGate uigGate, 1224 DataBasketCondition dbc, DataBasketEntryGrouper dbeg, TableEntryDescriptor ted) { 1225 return create(sCaption, db, uigGate, dbc, dbeg, null, ted); 1226 } 1227 1228 /** 1229 * Create and return a new SingleTableFormSheet that will display the contents of a DataBasket. 1230 * 1231 * <p>The FormSheet will contain a {@link JDataBasketTable}, the individual records are 1232 * {@link DataBasketEntry DataBasketEntries}.</p> 1233 * 1234 * @param sCaption the caption of the new FormSheet. 1235 * @param db the DataBasket whose contents are to be displayed. 1236 * @param uigGate the gate at which to display the FormSheet. May be <code>null</code> only if no editing is 1237 * performed through the FormSheet. 1238 * @param dbc a condition specifying the entries to be displayed. 1239 * @param dbeg a grouper that can be used to combine several entries into one for display. 1240 * @param cmp a comparator defining the order in which to display the individual items. If <code>null</code> 1241 * entries will be sorted first by their main and then by their secondary keys. 1242 * @param ted a TableEntryDescriptor that can split individual {@link DataBasketEntry DataBasketEntries} 1243 * into a table's cells. Must not be <code>null</code>. 1244 */ 1245 public static SingleTableFormSheet create(String sCaption, final DataBasket db, UIGate uigGate, 1246 final DataBasketCondition dbc, final DataBasketEntryGrouper dbeg, final Comparator<DataBasketEntry> cmp, 1247 final TableEntryDescriptor ted) { 1248 return new SingleTableFormSheet(sCaption, uigGate, new STFSContentCreator() { 1249 private static final long serialVersionUID = 5243720296332530319L; 1250 1251 protected void createFormSheetContent(FormSheet fs) { 1252 final SingleTableFormSheet stfs = (SingleTableFormSheet)fs; 1253 JDataBasketTable jdbt = new JDataBasketTable(db, dbc, dbeg, cmp, ted); 1254 setFormSheetComponent((SingleTableFormSheet)fs, jdbt); 1255 stfs.m_source = db; 1256 stfs.m_db = db; 1257 } 1258 }); 1259 } 1260 1261 }