MSS Code Factory 2.5 Release History

2016.03.08 MSS Code Factory 2.5.13418 Rebuilt and repackaged with CFLib 2.5.13417

CFLib 2.5.13417 corrects an error in the implementation of CFLibBigDecimalUtil that was incorrectly comparing argDigits to MAX_PRECISION instead of comparing argPrecis.

2016.03.08 MSS Code Factory CFLib 2.5.13417 Corrected comparisons in CFLibBigDecimalUtil

The utility class for BigDecimal was incorrectly comparing the argDigits to MAX_PRECISION instead of comparing argPrecis.

2016.03.08 MSS Code Factory 2.5.13407 CFBam 2.6 license changed to Dual-GPLv3

As I intend to integrate the custom code of the MSS Code Factory engine for use by the BAM Editor, the license of the CFBam 2.6 code has been changed to a dual commercial/GPLv3 license. You are no longer allowed to use the source code under the terms of the Eclipse Public License.

2016.03.08 MSS Code Factory 2.5.13403 The CFBam 2.6 model was missing Table.PageData

The Table.PageData boolean has been added to the CFBam 2.6 model. That is the cause of the last remaining build error for the initial 2.6 migration effort.

2016.03.07 MSS Code Factory 2.5.13398 Reworked CFBam 2.6 model to take advantage of EnumTypes

The CFBam 2.6 model has been reworked to remove the lookup tables in favour of the recently supported Enum types. The custom code fragments have also been updated to use the enums defined in the schema interfaces instead of the lookup tables, greatly simplifying the code and improving the readability.

This effort has resulted in the elimination of 7,559 CFBam 2.6 source files and reduced the code base by 1,667,751 lines of code to 11,138,622 lines.

2016.03.07 MSS Code Factory 2.5.13395 Repackaged with CFLib 2.5.13394

The factory has been repackaged with CFLib 2.5.13394. There are no other changes save the version number.

2016.03.07 MSS Code Factory CFLib 2.5.13394 Added setDigitsAndPrecision() to JavaFX CFNumberEditor

The routine setDigitsAndPrecision() has been added to the CFNumberEditor and to the CFNumberTableCell. CFNumberTableCell has been cleaned up to rely on the implementation of formatting provided by CFLibBigDecimalUtil instead of having a separate (and incorrect) implementation.

2016.03.07 MSS Code Factory 2.5.13392 Added relationships to CFAcc 2.6 model

Relationships between a BillItem and a PurchaseOrder and POItem have been established, with appropriate DelDeps added as well. You can also locate the BillItems that reference a PurchaseOrder or POItem from those objects via Children relationships (the BillItem uses Lookup relationships so that pickers are available when editing the relationships.) How detailed you wish to make your tracking of the relationship between BillItems and the PurchaseOrders/POItems is entirely up to the user; you are not required to establish those relationships.

There was already a similar relationship established between ChequeDetails and their potentially-related Bills. There are also relationships between the PaymentDetails and Invoices, and DepositItems and Payments.

This should be the last of the relationships that have to be established for the model. I can't think of anything else I will need in that regard.

2016.03.07 MSS Code Factory 2.5.13390 Adjust order of DelDeps and ClearDeps for CFAcc 2.6

The objects of an account are interdependent, so they need to be cleared and deleted in the correct sequence to minimize problems.

2016.03.06 MSS Code Factory 2.5.13388 Shift sequence of form construction for ListPane Add buttons

When adding new objects, the new instance has to be fully initialized before the form is instantiated over the object. Otherwise there are often problems with null references while working on custom code. Sure I could just keep on changing the order in the custom code, but it is easier to make the change globally.

2016.03.06 MSS Code Factory 2.5.13386 Rebuilt with CFLib 2.5.13385

CFLib 2.5.13385 changes the user feedback of the JavaFX ReferenceEditor to grey out the text edit component when setCustomDisable() is invoked with "true".

2016.03.06 MSS Code Factory CFLib 2.5.13385 Really disable the text field of ReferenceEditors

The text fields of ReferenceEditors are now disabled so that they appear greyed out when the setCustomDisable() method is used for them. That provides better consistency with the rest of the application GUIs, though it means you can't copy the contents of the text field any more. You can't have everything.

2016.03.06 MSS Code Factory 2.5.13383 Implemented workaround for SMTP authentication issue

A friend has been testing MSS Code Factory manufactured code, and encountered a problem with using secure SMTP connections to send emails from the Security Management HTTPS server. I've taken their fix and integrated it with the code produced by MSS Code Factory.

You should add a variable named "MyprojVersionSmtpEnableSMTPS" and set it to false initially. If you can't get a connection to your email server with that setting, try changing the variable to "true" -- that enables an alternative way of using the Java EMail Transport object that worked for my friend.

I will NOT be issuing updates to the MSS Code Factory 2.6 projects with this fix applied at this time; it will get rolled out the next time I do a bulk upload when more fixes are incorporated. CFAcc 2.6 will include the fix with its next update, of course.

If you need this fix, please download this update and remanufacture your java+jee code.

2016.03.06 MSS Code Factory 2.5.13381 Remove contact list selections from AccountConfig for CFAcc 2.6

The contact list filtering is a bad idea, because it doesn't match 1:1 with the account types, so I've removed that feature. I have, however, added a default timezone selection option.

I am going to make the DefaultCurrency selection active for adding the initial AccountConfig only; you will not be able to change the default currency after setting it. You will, however, be able to change the default timezone.

2016.03.05 MSS Code Factory 2.5.13378 Service Pack 9

The interpretation of Digits and Precision for Number columns and types has been corrected through the implementation and use of the CFLibBigDecimalUtil class added to CFLib 2.5.13377.

The inialization and min/max constants are now properly used in most of the manufactured code as well, making things a little more readable and consistent.

You should definitely download this release and remanufacture your code base. The old implementation of Number support was badly broken.

2016.03.05 MSS Code Factory CFLib 2.5.13377 Added CFLibBigDecimalUtil

CFLibBigDecimalUtil has been added in order to support the enhanced usage of BigDecimal for Number columns and types. The new class and methods have also been used in the JavaFX NumberEditor rather than maintaining duplicate code (particularly as the old editor code was incorrectly implemented.)

2016.03.05 MSS Code Factory 2.5.13376 Number specifications are now limited to 100 digits and 99 precision

The Number specifications for MSS Code Factory are now limited to 100 digits with up to 99 fractional precision (in which case there would only be one digit left of the decimal.) Digits have to be greater than the precision for database persistance. Negative precision never has been allowed.

2016.03.05 MSS Code Factory CFBam 2.5.13375 Increase Min/Max/Null/Unknown digits to 100 for Number specifications

The Number specifications don't allow large enough values for the Min/Max/Null/Unknown values. I want to support 100 digit numbers across the board.

2016.03.05 MSS Code Factory 2.5.13372 Digits have to be greater than precision for CFAcc 2.6 numeric types

The number of digits has to be greater than the precision for numeric types. Digits is the total number of digits including the precision.

2016.03.05 MSS Code Factory 2.5.13370 Add Tax, AccountTaxId, InvoiceTax, and BillTax objects to CFAcc 2.6

The Tax object is owned by a Tenant and allows configuration of fixed fee and percentage based taxes.

The AccountTaxId object is a join between an Account and a Tax that lets you specify a tax id code for the combination when that kind of tax is applied for the Account (for example, a GST number.)

The InvoiceTax and BillTax objects join an InvoiceItem or a BillItem to a Tax so that the finalization process knows to calculate those taxes for those line items, and to create line items with the total for that particular type of tax.

This should complete the object set for CFAccounting. Taxes were the only thing I hadn't dealt with (at least to some degree) up to now.

2016.03.05 MSS Code Factory 2.5.13368 Remove Account component Currency specifications for CFAcc 2.6

The Currency specifications for PurchaseOrder, Bill, Invoice, Payment, Cheque, and Deposit have been removed. All transactions should be in the currency of the Account, entered after the conversion and fees have been applied for the conversion. This is an accounting application, not a banking system.

2016.03.04 MSS Code Factory 2.5.13366 Tweak CFAcc 2.6 model with EFT flags

I realized I need an IsEFT flag for Cheques and Deposits. In the case of a Cheque, that means a ChequeNumber doesn't get consumed automatically when it is issued. I also added a ChequeAlwaysEFT flag to the Account object, so that if you create an account for a credit card, you won't have to keep ticking off the EFT checkbox in the GUI.

2016.03.04 MSS Code Factory 2.5.13364 Add Fee and FeeDetail to CFAcc 2.6

I have to be done adding objects other than taxation (which I'm not sure how to do at the moment.) I just HAVE to be done by now... :(

2016.03.04 MSS Code Factory 2.5.13362 Add Deposit and DepositDetail to CFAcc 2.6

The Deposit and DepositDetail have been added to the CFAcc 2.6 model.

2016.03.04 MSS Code Factory 2.5.13359 Change CFAcc 2.6 AccountTypeEnum

Change the account types to:

General - a generic account, usually a rollup
Bank - an account from which cheques can be issued
Payable - an account which issues purchase orders and receives bills
Receivable - an account to which invoices are issued and payments received

Payroll and internal business/departmental accounting are beyond the scope of general accounting. I don't need to complicate things more than they already are.

2016.03.04 MSS Code Factory CFSecurity, CFInternet, CFBam 2.5.13358 Remanufactured with 2016 licensing

The 2.4 models were updated to manufacture updated code with 2016 licensing. MSS Code Factory itself has been recompiled and repackaged with these versions.

2016.03.04 MSS Code Factory 2.5.13355 Rebuilt with CFLib 2.5.13353, CFCore 2.5.13354

The latest versions of CFCore and CFLib have been updated to 2016 licensing, as has MSS Code Factory 2.5 itself. The code which is manufactured by MSS Code Factory 2.4 has not been updated, and will not be at any point in the near future.

2016.03.04 MSS Code Factory CFCore 2.5.13354 Licenses updated for 2016, rebuilt with CFLib 2.5.13353

The licenses have been updated for 2016 and the jar/library rebuilt with CFLib 2.5.13353.

2016.03.04 MSS Code Factory CFLib 2.5.13353 Licenses updated for 2016

The copyright notices for the licenses have been updated for 2016.

2016.03.04 MSS Code Factory 2.5.13351 Business Application Models licenses updated for 2016

The business application models for MSS Code Factory have been updated with 2016 license information. The source code for MSS Code Factory itself has also been updated, but not the jars/libraries it uses.

2016.03.04 MSS Code Factory 2.5.13349 Add the ChequeDetail and PaymentDetail to CFAccounting

The ChequeDetail and PaymentDetail are used to support what are commonly known as "splits", which let you apply a cheque to more than one bill with full or partial payment of each bill, for example. Similarly, payments received can be applied to one or more full or partial invoices.

2016.03.04 MSS Code Factory 2.5.13347 Add the BillItem and InvoiceItem to CFAccounting

The BillItem and InvoiceItem have been added. Things get a little more different for the remaining PaymentDetail, and ChequeDetail objects that I still have to add, as those are not listing actual items, but reference the objects that they apply to instead.

2016.03.04 MSS Code Factory 2.5.13345 Add VendorUnit and POItem to CFAccounting

The details for the purchase orders have been somewhat fleshed out with the addition of a VendorUnit object as a component of an Account, and the POItem as children of the PurchaseOrder. Note that each vendor has its own VendorUnits; they are not shared throughout the whole tenant. This allows one vendor to specify that when they are measuring grams on a purchase order, they are referring to full grams (0 digits), while another vendor may mean hundredths of a gram (2 digits.)

2016.03.03 MSS Code Factory 2.5.13343 Cleaned up user interface to support CFAccounting

I've decided that rather than starting a new project from scratch, I would continue working on CFAccounting and see what I can do about making it a "real" accounting application instead of a prototype. Hey, it is something to keep me occupied.

This release of the factory itself fixes some niggling annoyances that I didn't like about CFAccounting's user interface. Most notably, I didn't like the fact that after Adding an object, I would be brought back to the parent form and would have to View the new object to keep working with it.

So I changed the workflows for the Add and View/Edit forms. They now have the buttons Edit, Save, Close, and Cancel (Save isn't visible for all forms, because sometimes you don't want the new behaviour enabled, particularly for the hierarchy browser object adds.)

Edit takes you into edit mode for a form, enabling the Save and Close buttons as well as Cancel (Cancel is always enabled.)

Save for an Add form will save the object and replace the form with a View/Edit form over the new object in View mode so you can start working with its component objects right away. Save for a View/Edit form saves the current changes and puts the form back in View mode.

Close is the old Save behaviour where the object would be saved and the form closed.

Cancel abandons changes and closes the form, but does NOT undo the changes if you issued a Save previously.

There are some changes to the form instantiation methods to support this new behaviour as well as the changes to the forms themselves, so custom code might not compile after remanufacturing the java+javafx layer.

2016.02.28 MSS Code Factory 2.5.13342 Service Pack 8 -- Life, The Universe, and Everything: I am done with this project

I am done with this project. I have fleshed out and tested the CFAccounting application sufficiently to "prove in" the code manufactured by MSS Code Factory, tweaked the JavaFX user interface to make it safe and usable, and done everything that I want to do with this project.

It has been a long, long 18 year slog, and I am flat out TIRED of working on it. No more.

Not unless someone reports bugs to me. I'm done.

2016.02.28 MSS Code Factory 2.5.13340 Use CFReferenceEditor.setCustomDisable() instead of setDisable()

The setCustomDisable() method doesn't disable the whole pane of the widget, only the Pick button. You should always be able to View the value referenced by the editor, and you should always be able to select the text of the selection name.

2016.02.28 MSS Code Factory CFLib 2.5.13339 Add get/setCustomDisable to CFReferenceEditor

You can't override Node.setDisable(), so I had to add getters and setters for a CustomDisable that should be used instead for this widget. You should always be able to click the View button.

2016.02.28 MSS Code Factory 2.5.13337 Finished locking down form modes, fixed reference editors

Instead of displaying a ViewEditForm when you try to View the target of a ReferenceEditor, the JavaFX code now instantiates an Add form in View mode. The Add forms don't let you do anything with the sub-elements of an object (it doesn't even display them), and when you are in View mode with an Add form, you cannot change any of the data nor Save it, so it is safe to access at any time.

The ReferenceEditor callbacks in the JavaFX code now properly dereference the object using the one set by the editor itself instead of the unsynchronized attributes of the focus object for the form.

Finally, the Picker windows now auto-select the focus object that they were given, so that when you open a Picker over something that already has a selected value, that value is automatically re-selected by the form.

I realized that with the changes I made on the last update, you are not allowed to View selected elements of the lists presented in the EltTabPanes unless the containing Form leaves the EltTabPane in View mode, so you CAN'T damage sub-element data after all.

With this most recent set of changes, I now have the edit mode coordination locked down to a "safe" implementation that should prevent the user from hanging themselves by creating conflicting or inconsistent data states.

2016.02.27 MSS Code Factory 2.5.13335 Reverse interpretation of inEditState when adjusting List button enabling

The list buttons should only be enabled for a list when the form is NOT in edit mode. If you are editing the containing object, you must save or cancel that edit before manipulating the details.

You are allowed to View the details, but not Edit them. However, there is a hole in the system because the ViewEdit forms still have an Edit button that you can click on to enter Edit mode on a sub-object, which really isn't desireable, but I haven't decided on if/how to address that issue.

2016.02.27 MSS Code Factory 2.5.13333 CFAcc.Account object finished?

I think I have finished adding all the attributes and sub-objects that an Account will need. This release adds Next[Cheque/Invoice/PurchaseOrder]Number and [Cheque/Invoice/PurchaseOrder]Digits attributes so that the creation of those sub-objects can auto-generate a sequence number.

This had to be implemented as attributes of the Account because the MSS Code Factory sequence generators can only be global or dispensed by a Cluster or Tenant. You can't create a sequence generator for an actual application object with MSS Code Factory.

2016.02.27 MSS Code Factory 2.5.13331 Add index over AccountType

There is now an index over the AccountType that also includes the IsRollupAccount flag column. This will make it possible to generate lists of allowed "real" accounts in the user interface when selecting an account to issue a cheque for paying a bill, for example.

2016.02.26 MSS Code Factory 2.5.13329 Add AccountType to CFAcc.Account

The AccountType is used to restrict and configure the actions and views that an account can actually present and use.

Budget - An account used for managing project or departmental budgets that cannot issue purchase orders, but which can have money transferred to and from it. The sole purpose is to provide a means of tracking the department's spending and budget, not to handle chequing functions and such. You can pay an Expense bill out of a Budget. You can issue an Invoice to another Budget. You can also issue PurchaseOrderes to another Budget. Basically, the Budget account is a do-anything account that is restricted to dealing with other Budgets instead of Vendors, Customers, or "real" money.

Chequing - A corporate bank chequing account that can be used to pay bills

Customer - A customer account that can have invoices issued to it and from which payments can be received. Essentially an Accounts Receivable type of account.

Payroll - A special chequing account that can only issue cheques to employee contacts.

Saving - A corporate bank savings account that cannot be used to pay bills or issue cheques.

Vendor - You can issue purchase orders to vendors and receive bills from them, but you have to pay them from a corporate Chequing account.

2016.02.26 MSS Code Factory 2.5.13327 Add Payment to CFAcc 2.6 model

I almost forgot you have to be able to receive Payment for the Invoices you issue.

2016.02.26 MSS Code Factory 2.5.13325 Add Bill to CFAcc 2.6 model

The Bill object is created when a purchase order is filled and invoiced; the purchase order itself should not have a Ledger entry, so that relationship has been removed. Instead, you would enter the purchase order id in the bill information. Though I think I only defined a field for the billing code, which I intend to receive the invoice id from the vendor.

2016.02.26 MSS Code Factory 2.5.13322 Add Cheque, Invoice, and PurchaseOrder objects to CFAcc 2.6 model

The CFAcc 2.6 model now includes Cheque, Invoice, and PurchaseOrder objects, which will still need to be fleshed out with their details. However, this fleshes out the object set I need in order to be able to lock down the Account object itself, as the members for these objects have been defined as well.

That means I can now start customizing the Account Add and ViewEdit forms so that the user can no longer make dangerous changes to the data when they access those forms from the Account Hierarchy browser.

2016.02.25 MSS Code Factory 2.5.13320 Emergency Service Pack 7 for XMsg

The XMsg layers have some critical bugs that have been fixed. I consider these to be real "show stoppers", so it is very important that you download this service pack and remanufacture your applications.

The first bug is that if an empty result set is returned from a query, the XMsgClient layer will throw an exception because the result set is null. Now when a null result set is returned, it is mapped to an empty array instead of throwing an exception.

The second bug is that if you define an index that includes an optional column and then pass a null value for that column, the attribute conversions in XMsgRspn and XMsgRqst will throw exceptions because they do not check for null or empty values for index key attributes, only for data attributes. It just so happens that I never had this condition arise in any of my models until today. This insidious bug was only triggered if the first column or columns of the index participate in the primary key of the object.

The CFAcc 2.6 model has also been changed.

2016.02.25 MSS Code Factory 2.5.13318 Correct CFAcc model

The CFAccounting model was erroneously restricting the AccountContact to there being only one contact for an account, when the intent was to model a many-to-many relationship, as it is quite normal to have multiple contacts for corporate accounts. Even if I were dealing with bank accounts, there would be joint accounts to consider.

There are no changes to the other models nor to the rule base, so there is no need to download this release unless you are trying to work with CFAccounting in particular (which I don't recommend at this time, as it is in a state of flux.)

2016.02.24 MSS Code Factory 2.5.13313 Service Pack 6 with Tag object removed from CFCrm

I don't like the Tag implementation I did. It was a hack. It is ugly, it is clumsy, it is crude, and it is GONE. I decided to get it out of there before anyone had a chance to download Service Pack 6.

2016.02.24 MSS Code Factory 2.5.13311 Service Pack 6

Service Pack 6 is being released to coincide with the completion of the implementation and testing of the core 2.6 projects (CFSecurity, CFInternet, and CFCrm.) This release is closer to bug free than any to date has been.

All of the issues with the JavaFX manufactured code have been resolved. Every variety of editor has been tested, nullable and required attributes have been tested, all of the "gotchas" for layouts and field sizing have been addressed, and the system is finally ready for early adopter use on production projects.

There is always the chance someone will find bugs in the code. I have never worked on a bug free system; as long as humans are involved, there will be mistakes and oversights, and I am most definitely a typically flawed and error-prone human.

2016.02.24 MSS Code Factory 2.5.13309 The CFCrm model is now complete

I forgot to remove the old Memo.Memo attribute, but that has been cleaned up and both the model and the custom code for CFCrm 2.6 are now complete. All three of the core projects are now as done as I intend to make them for now. I have some optimization ideas for the CFInternet hierarchy brower, but for now it works and that is good enough to set it aside for now.

2016.02.23 MSS Code Factory 2.5.13307 Add DelDeps to CFCrm model for new objects

The DelDeps had to be specified for the new objects, as otherwise there are constraint violations from the database when deleting Attachments or Memos.

2016.02.23 MSS Code Factory 2.5.13306 CFCrm model enhanced with split of AttachmentData and MemoData

The AttachmentData and MemoData objects contain 1GB BLOB and TEXT attributes respectively. Custom forms will be used in the CFCrm application code to ensure that these objects are only loaded by the JavaFX GUI on an as-needed basis in order to improve performance, reduce network traffic, and reduce the memory footprint of the client.

See the 2.6 Programmers Notes for CFCrm logged today for details.

2016.02.23 MSS Code Factory 2.5.13304 Correct CFCrm model

The CFCrm model neglected to reference the Attachments from a Contact.

2016.02.23 Programmer's Notes

I feel totally burnt out after last night's efforts. I'll get around to working on the binary file load/save support when I feel more functional. It isn't like I am behind schedule, as I have no schedule. :)

2016.02.23 MSS Code Factory 2.5.13302 Critical JavaFX bugs corrected

The critical JavaFX bug was a class-cast exception problem in the AttrPane objects caused by referencing the manufacturing SchemaName instead of dereferencing the targets of lookup and parent references and using the EffSchemaName (i.e. the defining schema name.) This caused class cast exceptions to be thrown when trying to populate the form fields.

Another issue was that the ListPanes were still wrapping their DataTables in a ScrollPane. That is not the correct way to code scrolling for DataTables -- they provide their own scrolling support without having to be wrapped in a scrolling object such as had to be done with Swing.

2016.02.23 MSS Code Factory CFLib 2.5.13301 CFLib.JavaFX.CFConsole now prints exceptions with trace to system.out

In order to make it easier to debug issues, CFLib.JavaFX.CFConsole now logs exceptions with their stack trace to System.out as well as logging the core of the exception to the CFConsole text buffer. This is only useful on Unix and Windows systems; on a Raspberry Pi, you can't see the console while an application is running.

2016.02.22 MSS Code Factory 2.5.13299 Corrected bugs in Id generators for dynamic JDBC

Dynamic JDBC is used by some of the databases when BLOB data is in place. In a few cases, the table type was not being cast to the current schema's version of the table type, resulting in the referenced schema's table type specification being used. That meant that the next...IdGen() method didn't exist in the interface specification.

The CFCrm.Attachment data has been changed from a text file to a BLOB to allow images and other such information to be stored. The client will need customization to allow the user to Load and Save the attachment data, as BLOB fields are not directly supported by manufactured code (as the engine has no idea what kind of attachment is involved.) A limit of 63 attachments will also be enforced to avoid running into Java's 32-bit string size limitations when querying the attachments from the XMsg server. That should limit the size of the actual message string to no more than about 1.5GB -- well below the actual 2GB limit of a signed 32-bit integer.

2016.02.22 MSS Code Factory 2.5.13298 CFCrm and CFAcc no longer depend on CFInternet

The dependencies on CFInternet have been removed from CFCrm and CFAcc. Only those two projects are affected by this change, as only CFAcc references CFCrm. All other projects save for CFSecurity reference CFInternet instead. The Attachments have been made into BLOBs with a maximum size of 16MB each. A limit of 63 attachments per customer will be imposed to prevent running into the limits of Java string sizes used for the Base64 communications.

2016.02.22 MSS Code Factory 2.5.13294 Replace all occurences of Alert with CFConsole.message()

I don't like the JavaFX Alert implementation -- it doesn't deal with multi-line text properly. So rather than work up my own alerts that do it properly, I just switched all alerts to CFConsole messaging.

This release also incorporates major changes to the CFAcc 2.6 model; the database and any customized code for the CFAccounting application are likely completely incompatible if you've been building on it. You really shouldn't rely on CFAcc remaining even vaguely stable while I'm working on it.

2016.02.22 MSS Code Factory 2.5.13292 Kills the pain of a failed CFAcc build with the last version

CFAcc 2.6 builds properly now.

2016.02.22 MSS Code Factory 2.5.13291 Working on CFAcc 2.6 model

The CFAccounting model has been refactored and enhanced. What was an AccountEntry is now a Ledger, so a lot of the tables have been renamed.

2016.02.22 MSS Code Factory 2.5.13290 Add rules to validate PageData settings

There are some simple rules to follow when enabling PageData. First off, you can't use PageData retrieval for a table that has subclasses, because those are actually performed by the server merging the result sets from a query for each subclass in the hierarchy, so there is no consistency in result set ordering and such for those queries that would allow paging.

The second rule is that you have to have a normalized primary key for page data. That is, all of the columns of the primary key have to be required, not nullable.

All of the rule sets now perform a validatePageData step before they produce any output, forcing a traceback/termination of MSS Code Factory if the rules aren't abided by.

2016.02.22 Programmer's Notes

PageData is really a very special case enhancement. It is not something I've ever seen used by bread-and-butter line of business applications. The only places I've seen it are for telecom, banking, and accounting applications where the user normally wants to see the most recent data, and so rarely pages down through the data set.

The way it will work is quite simple, though. I'll make copies of the reader stored procedures, enhanced with a "pg" after the read (so, crsp_table_readpg_by_index.) Those procedures will take optional primary key arguments, which are intended to receive the primary key of the last row retrieved. If such a key is specified, they'll retrieve the next 50 rows of data for the query where the primary key is less than the specified key (as primary keys increase rather than decreasing.)

Unlike the current queries, the result sets will be sorted by descending primary key instead of ascending. All databases support some sort of "first n" clause for their queries, so I'm not worried about it being supported -- I don't need scrollable cursors for it or anything like that.

The hard part will be the fact that I need to support two entire branches of queries -- one with the primary key specified and one without, which is used for the first page of data retrieved.

However, before I work on that, I'll get the essentials of my CFAccounting application coded, and work on the data paging after the basics are working. After all, in the real world, you don't want to fetch the entire ledger from the database, just the most recent data. Otherwise as you use the application, it gets slower and slower until it is completely unusable.

Note that data paging will not be used by the manufactured JavaFX screens at any time. You will always have to write custom forms to leverage data paging; I'll just be enhancing the back-end to provide the programmer the services they need in order to write such forms.

2016.02.22 MSS Code Factory 2.5.13289 Added support for new Table.PageData attribute

The Business Application Model parser has been enhanced to apply the new Table.PageData attribute. If the attribute is not specified, the default value is "false", so that the current behaviour of the factory is the default behaviour whenever I get around to working on data paging.

Which won't be for a long time because I don't need it right now and it will be a rather thorny enhancement to implement. I was just bored, so I thought I'd prepare the core of the engine so all I have to do in the future is work on the rules.

2016.02.22 MSS Code Factory CFBam 2.5.13288 Remanufactured to add Table.PageData boolean attribute

The boolean attribute Table.PageData has been added with a default value of "false". This will take care of the feature enhancements I need to work on data paging at some point in the future. I didn't need to do it tonight, but I was bored...

A complete build of CFBam 2.5 isn't possible with the current version of CFLib, but it is possible to build the core object, RAM, and MssCF layers, which is all I really need as there is no database persistence used by MSS Code Factory 2.5, nor is the base parser implementation used for loading business application model files.

2016.02.21 MSS Code Factory 2.5.13287 Service Pack 5

Service Pack 5 brings support for EnumType specifications with appropriate string representations of the enums in the XML communications and data loader files, corrections to a number of JavaFX bugs, mapping of the Enum ordinals to database shorts, and as thorough a job of testing all of the custom and manufactured JavaFX code as I could do.

I debated putting off releasing SP5 until after I have completed working on customizing CFAccounting and turning it into a "real" application, but I realized there are a few things I might need to do during that coding effort that would break existing applications, so I decided to release this incremental update rather than delaying any further.

As per usual, I am awaiting bug reports from the people that I know who are using the tool, but up until now the effort of identifying, hunting down, and correcting bugs has been up to me. I am running out of ideas to test or add to the code base, however. Particularly as at this point over 99.8% of the Java code for the 2.6 applications is manufactured, and less than 0.2% is custom, hand-written code. 100% of the database code is manufactured. The initialization data is also hand-coded, but that is such a paltry fraction of the total it doesn't even register as anything other than statistical noise.

2016.02.21 MSS Code Factory 2.5.13285 EnumTypes now present as ComboBoxes

The EnumType specifications are now presented as ComboBoxes by the JavaFX user interface. Along with that change, a couple of bugs with the code for user-specified ordering of sub-element lists for newly added objects were corrected, the list synchronization issues for the custom TableListPane of CFDbTest was fixed, and a snippet of stale code in the delete callbacks for the ListPanes was cleaned up so that lists refresh properly when an object is deleted.

2016.02.20 MSS Code Factory 2.5.13282 Debugging of EnumDef support is complete

The debugging of the EnumDef support is as complete as it can get without access to databases other than PostgreSQL. There is always the chance that I erred in my changes to the syntax for supporting EnumDefs, but most of the changes were to the JDBC layers, not to the database scripts, so I expect things to be ok. The only change made to the database scripts was to decrement the Audit values, as Java uses 0-indexed enums, not 1-indexed values.

The XML SAX Loaders work fine, and communications to and from the client via XMsg also work with EnumDef data, as verified via CFDbTest. The test framework for CFDbTest has been updated to make use of the newly defined test data as well, in order to exercise as broad a range of test cases as possible for the SAX Loaders.

I must admit I'm surprised I got it all done in under 12 hours save for the packaging and uploads of the 2.6 projects.

As the definitions of the data have changed rather drastically, I strongly recommend that you download full versions of the 2.6 projects and reinstall your databases. You should also do a full remanufacturing for your own projects and reinstall the databases, as changes were made to the implementation of CFSecurity and CFInternet as well as CFDbTest and CFBam.

2016.02.20 MSS Code Factory 2.5.13281 CFSecurity clean compiles

With the changes made to the JavaFX layer to make use of the latest CFLib, CFSecurity now clean compiles. Whether all this code works remains to be seen, as does whether the remainder of the projects clean compile as well. I'll know in an hour or so.

2016.02.20 MSS Code Factory CFLib 2.5.13280 Added JavaFX CFEnumTableCell

The EnumTableCell converts a generic Enum cell value to it's corresponding display string. There is no corresponding generic editor for enums; instead the StringEditor is used, with code to convert the enum to and from a string added to the manufactured JavaFX code.

Ideally a combo box should be used to display the valid values for an enum, but for now I'm just using a StringEditor and you have to know what values are valid to avoid rejection.

2016.02.20 MSS Code Factory 2.5.13279 Sybase ASE now supports EnumDefs

The Sybase ASE layer has been enhanced to support EnumDefs.

2016.02.20 MSS Code Factory 2.5.13278 PostgreSQL now supports EnumDefs

The PostgreSQL layer has been enhanced to support EnumDefs.

2016.02.20 MSS Code Factory 2.5.13277 Oracle now supports EnumDefs

The Oracle layer has been enhanced to support EnumDefs.

2016.02.20 MSS Code Factory 2.5.13276 MySQL now supports EnumDefs

The MySQL layer has been enhanced to support EnumDefs.

2016.02.20 MSS Code Factory 2.5.13275 Microsoft SQL Server now supports EnumDefs

The MS SQL layer has been enhanced to support EnumDefs.

2016.02.20 MSS Code Factory 2.5.13274 DB/2 LUW now supports EnumDefs

The DB/2 LUW layer has been enhanced to support EnumDefs.

2016.02.20 MSS Code Factory 2.5.13273 Buffers, Obj, XML, and XMsg now support EnumDefs

There are problems with the database layers and with the JavaFX code, but this is a good start. I don't recommend downloading and using this update, as I was reminded by build failures that even CFSecurity has an EnumDef in it, so the code produced by this project won't build cleanly for any projects. It is a work in progress.

2016.02.20 MSS Code Factory 2.5.13272 Working on proper EnumDef support

The EnumDef specifications of a Schema now produce a public enum type in I$SchemaName$Schema, and static methods parse$Name( String value ) and ordinalTo$Name$( Integer value ) in $SchemaName$Schema.

The next chunk of work is likely to break a lot of code as I change the buffer specifications to use the enums instead of shorts, so it may be a while before I post another update.

The goal is to fully support passing enums as name tags in the XML files, but continue to store them as integers in the databases. Rather than changing the database storage from an Int16 to an Int32, however, the ordinals of the Enums will be cast to short for database persistence.

The only models currently using EnumDefs are CFBam and CFDbTest, so this work in progress shouldn't affect too many people or projects.

2016.02.20 MSS Code Factory 2.5.13270 Remove remaining Enums from CFInternet specifications

The remaining Enum specifications have been removed from CFInternet's model. This has required propagating changes from Enums to IdGen specifications in the CRM model as well.

As with the previous release, the database is incompatible, but seeing as the previous release was never uploaded for distribution, you don't need to do anything more than download this latest update and follow the earlier instructions.

2016.02.20 MSS Code Factory 2.5.13269 Rework CFInternet.MimeType specification

The CFInternet.MimeType specification has been reworked to match the contents of /etc/mime.types on Debian "Jessie." The contents of that file has been massaged into an XML initialization file for the 2.6 applications. All 2.6 applications save for CFSecurity need to be remanufactured to apply the database changes.

You will need to recreate your database to use the rebuilt 2.6 application installers.

You will also need to clean up a file in your msscf package after remanufacturing your project as follows:

git rm java/cf*msscf26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*

2016.02.19 MSS Code Factory 2.5.13267 Rework CFSecurity.ISOLanguage specification

The ISOLanguage specification has been reworked to match the structure of the data downloaded from the ISO website so that a complete set of ISO 639.2 codes can be loaded, not just the IOS 639.1 subset.

As a result, all applications will need to be remanufactured and the stale code cleaned up. After manufacturing, you can remove the old files with the following commands run from your projects top directory:

git rm dbcreate/cf*/*/crsp_*iso_lang_by_baseidx.*
git rm dbcreate/cf*/*/crsp_*iso_lang_by_codeidx.*
git rm dbcreate/cf*/*/crsp_*iso_lang_by_countryidx.*
git rm dbcreate/cf*/*/cridx_isolang_xbase.*
git rm dbcreate/cf*/*/cridx_isolang_xcntry.*
git rm dbcreate/cf*/*/cridx_isolang_xcode.*
git rm dbcreate/cf*/*/cridx_iso_lang_h_baseidx.*
git rm dbcreate/cf*/*/cridx_iso_lang_h_codeidx.*
git rm dbcreate/cf*/*/cridx_iso_lang_h_countryidx.*
git rm dbcreate/cf*/*/cr*_iso_langbybaseidx.*
git rm dbcreate/cf*/*/cr*_iso_langbycodeidx.*
git rm dbcreate/cf*/*/cr*_iso_langbycountryidx.*
git rm dbcreate/cf*/*/cridx_iso_lang_hbaseidx.*
git rm dbcreate/cf*/*/cridx_iso_lang_hcodeidx.*
git rm dbcreate/cf*/*/cridx_iso_lang_hcountryidx.*
git rm java/cf*26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*
git rm java/cf*26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*
git rm java/cf*26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*
git rm java/cf*msscf26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*
git rm java/cf*msscf26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*
git rm java/cf*msscf26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*
git rm java/cf*msscf26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*
git rm java/cf*xmsgrqst26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*ISOLanguage*
git rm java/cf*xmsgrqst26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*ISOLanguage*
git rm java/cf*xmsgrqst26/src/net/sourceforge/msscodefactory/*/v2_6/CF*/CF*ISOLanguage*

2016.02.19 MSS Code Factory 2.5.13265 Resize and placement issues corrected, enable states synchronized

Just to be clear: due to database model changes made over the past few days, the current versions of the client installers are NOT compatible with older installations of the 2.6 projects. You need to download full versions of the applications and recreate your databases.

The resize and placement issues for the JavaFX Finder and Picker forms have finally been corrected. It turned out that there was an extra ScrollPane wrapping the data table, which showed up when I was experimenting with AnchorPanes instead of BorderPanes (AnchorPane shows a border around its children.)

The enable states for the ListPane buttons have also been updated and now properly reflect the edit mode of the containing window, whether the list is displaying an add menu, and whether a row is selected.

The selection of rows in the Finder panes now properly update the enable states of their buttons as well.

2016.02.19 MSS Code Factory 2.5.13262 Consolidated JavaFX FinderPane into FinderForm

The JavaFX code has been consolidated into the corresponding code while trying to resolve the resize and placement issues with the element list of the form. While I have had no luck resolving those issues, the code is now denser and tighter.

I give up on resolving the resize and placement issues with the Picker and Finder forms. I'm at a complete loss as to why the lists appear in the upper left and narrower than they can be for the window size. I'm starting to suspect it is a bug with the OpenJFX BorderPane implementation.

You'll have to remove all files from your javafx package source tree after manufacturing with this release.

2016.02.18 MSS Code Factory 2.5.13260 Fix for picker forms

I guess I'm not done yet after all.

The picker forms were generating exceptions because they were trying to reference the data table before it was instantiated. This has been corrected and the picker windows now function correctly.

2016.02.18 MSS Code Factory 2.5.13258 Singleton sub-objects displayed as attribute panes by EltTabs again

When I switched the rule base over to treating an EltTab pane as a list for singleton components, I neglected to consider the fact that such objects are accessed as object accessors, not list accessors. That means the singleton and multiple code branches are not compatible.

However, I also discovered there is only one case where this singleton code comes into effect in the CFAccounting application, and in that case the behavior is ok because the singleton is selected by a picker instead of having to be instantiated.

You should just be aware that if you need to be able add a sub-element, you'll want to make sure that you don't enforce a unique index on the join indexes.

If it proves a problem for that one form in CFAccounting during development, then I'll put in the effort of supporting a singleton list for that one case.

2016.02.18 MSS Code Factory 2.5.13257 Element tabs always display component lists

In order to be able to instantiate a sub-object singleton, a list needs to be displayed, not an attribute pane view. This has been corrected, though I haven't encountered any forms yet during testing that exposed this issue.

2016.02.18 MSS Code Factory 2.5.13255 ISOCurrency.FracSymbol removed from CFSecurity 2.6 model

As I can find no useful web information for populating the fractional symbols for currency specifications, I've decided to remove the storage for such a symbol entirely from the models. All applications need to be remanufactured, rebuilt, and reinstalled as a result.

There are stale files named that you will need to remove from your msscf package source tree in order to get a clean build after remanufacturing with this release.

2016.02.18 MSS Code Factory 2.5.13251 Reworked ISO objects in CFSec, CFCrm, and CFAcc models

The CFSecurity, CFCrm, and CFAccounting models have been updated to resolve issues with instantiating and populating the ISO objects in the database. This issue was discovered while working on the CFAccounting application.

All projects will need to be remanufactured, as all projects incorporate the ISO objects via the lowest level business application model: CFSec. You will need to remove some stale objects from the manufactured msscf package source tree, and you will have to recreate and re-initialize your databases.

There is no change to the engine itself save for the version number change, nor has there been any change to the rule base.

Initialization XML files for the ISO objects used by CFAccounting have been added to all of the projects as well. They should be imported in sequence (they are numbered) along with the security initialization data for your application after you have initialized the cluster and logged in to the application as "system" for the first time. As the ISO data is stored in system-level tables, you only need to import the data once, not for each tenant you create.

2016.02.11 MSS Code Factory 2.5.13248 Repackaged SP4 with CFLib 2.5.13247

Service Pack 4 has been repackaged with CFLib 2.5.13247. This release of CFLib cleans up the production of validation exceptions by the various numeric JavaFX editors, and now provides more detailed information about the reason for the validation failure. This was purely an "optional" excercise for MSS Code Factory, but I thought I'd get it done rather than putting it off until later. Just for something to do this morning.

2016.02.11 MSS Code Factory CFLib 2.5.13247 Numeric JavaFX editor validation exceptions tidied up

The production of validation exceptions by the various numeric JavaFX editors has been cleaned up and now provides more detailed information about the reason for the validation failure. This was purely an "optional" excercise for MSS Code Factory, but I thought I'd get it done rather than putting it off until later. Just for something to do this morning.

2016.02.11 Programmer's Notes: Yes, it is done

I've had another day to think about what I could/might do yet with this project, and the only thing I might actually do is go through the custom widgets in CFLib and enhance/clean up the validation exceptions to provide more explanatory detail by relying on the overflow/underflow exceptions instead of invalid argument exceptions.

I considered doing full custom widgets that would restrict keyboard and paste entries to valid data, but I don't really want to go to the effort. MSS Code Factory is about the factory, not about custom widgets and fancy GUIs. Maybe some day I'll split CFLib off to a separate project and do such customization, but it won't happen any time soon.

Such widget customization was my job for about 5-7 years, and I find it rather boring and tedious work, not a fun thing to code. As I'm on a disability retirement, the first priority for me is that any coding I take on be *fun*. I'm not interested in torturing myself for the free benefit of others.

So, yes, I do believe I am done with this project save for dealing with any bug reports that come along. One of my friends got the cluster configuration form showing up in his browser today; he had a lot of trouble due to his inexperience with setting up Apache Tomcat and connecting to mail servers with the Java extensions for email, but there is nothing I can do about that. The purpose of my documentation is to show you what needs to be configured to run a manufactured service, not to teach you how to configure a web server. I have to assume a certain degree of skillset is present when you are working with this tool, or I'd have to write many hundreds of pages of "documentation" that should really be called "training manuals."

2016.02.10 Programmer's Notes

This has never happened to me before in all my years of programming. I started working with the machines when I was 14 years old -- 37 years ago. Yet this is the first time I believe I have "finished" a project.

There were always feature lists, enhancements, and "the next version" to work on. Projects only ended because their budgets ran out, or because the business decided it was "good enough", not because there were no more ideas about what to do next.

But it has happened with this one. I've added everything I can think of to this kitchen sink. It does everything I ever hoped or dreamed of making it do.

All that is left for it is to await bug reports and to deal with those issues as they come up. But the "to be done" list is empty right now.

It is done.

2016.02.09 MSS Code Factory 2.5.13245 Service Pack 4 repackaged with CFLib 2.5.13244

MSS Code Factory 2.5.13245 Service Pack 4 adds the capturing and logging of validation and processing exceptions to the new CFConsole widget which replaces the place holder TextEdits that had been used by the application code up until now. This addresses the need of the Raspberry Pi to explicitly log exceptions, and also tidies up the performance of the applications for other platforms as you no longer have to keep an eye on the system console for tracebacks printed by the default exception handlers.

The release was repackaged to include sorting of the Add menus on 2016.02.09. This trivial change should have been implemented before the initial 2016.02.08 release.

There are 16,280,390 lines of source code in the 2.5 projects that comprise MSS Code Factory itself, of which roughly 750,000 lines are hand-written.

There are 26,198,013 lines of code in the 2.6 projects, of which only a small fraction is hand written (far less than 1% of the total.)

That is a total of 42,748,403 lines of code delivered over the course of 18 years. An average of 6,465 lines of debugged code per day, if you presume I had worked every single day (which, of course, I came no where near doing, as I had an actual job to attend to for most of those years.)

2016.02.09 MSS Code Factory CFLib 2.5.13244 Corrected minor error in Double editor

The Double editor was mistakenly reporting range validations for setting Min and Max values using Float values instead of Double constraints. This has been corrected.

2016.02.09 MSS Code Factory 2.5.13242 Service Pack 4 - Life, the Universe, and Everything

MSS Code Factory 2.5.13242 Service Pack 4 adds the capturing and logging of validation and processing exceptions to the new CFConsole widget which replaces the place holder TextEdits that had been used by the application code up until now. This addresses the need of the Raspberry Pi to explicitly log exceptions, and also tidies up the performance of the applications for other platforms as you no longer have to keep an eye on the system console for tracebacks printed by the default exception handlers.

The release was repackaged to include sorting of the Add menus on 2016.02.09. This trivial change should have been implemented before the initial 2016.02.08 release.

There are 16,280,390 lines of source code in the 2.5 projects that comprise MSS Code Factory itself, of which roughly 750,000 lines are hand-written.

There are 26,198,013 lines of code in the 2.6 projects, of which only a small fraction is hand written (far less than 1% of the total.)

That is a total of 42,748,403 lines of code delivered over the course of 18 years. An average of 6,465 lines of debugged code per day, if you presume I had worked every single day (which, of course, I came no where near doing, as I had an actual job to attend to for most of those years.)

2016.02.08 MSS Code Factory CFLib 2.5.13241 Cleaned up validation exceptions

The invalid field exceptions already decorate the value with text, so there is no need to do so in the field editor code. In fact it looks rather ugly with formatting done by the field editors.

2016.02.08 MSS Code Factory 2.5.13240 Some edits cleaned up, but saving Edits still doesn't validate properly

Saving Edits still don't validate properly, and I must admit I'm confused as to why. The protocol should be the same as for Adds, but it isn't. For now I'm going to release a build with the Add fixes and give it a few days to debug and think about the problem. I have some personal issues to take care of over the next couple of days, so things should stay stable until Wednesday night at earliest.

2016.02.08 MSS Code Factory CFLib 2.5.13239 Corrected some validation errors

The Date/Time/Timestamp field editors weren't validating data properly.

2016.02.08 MSS Code Factory 2.5.13238 Validation error recovery fixed for Adds

The validation error recovery has been fixed for Add mode windows. Now when you try to Add something and get field validation errors, it will continually display the exceptions, reset the fields to the initial values (except for the ones that validated successfully up to the exception thrower), and let you keep editing until the save is successful.

However, edits of existing objects don't seem to report field validation exceptions at all. I'm going to have to look into that further before I ship a build.

2016.02.08 MSS Code Factory 2.5.13236 Repackaged with CFLib 2.5.13235

Only the version number, run scripts, and build.xml have changed.

2016.02.08 MSS Code Factory CFLib 2.5.13235 Exceptions thrown by widgets now support fieldName specifications

All of the exceptions and APIs used by the field editor widgets for JavaFX now support fieldName arguments as a supplement to the class arguments. This allows more reasonable reporting of user-interface exceptions such as field validation errors.

2016.02.08 Programmer's Notes

I still need to root around in the CFLib code and rework the way exceptions are thrown and formatted by the widgets and the routines they call, but for now I've got the essential framework done for capturing exceptions via console logging.

In particular, you don't get proper messaging for invalid values in the Date/Time/Timestamp editors right now -- they catch and discard the exceptions thrown by the XML parser routines.

So it isn't ready for SP4 by a long shot yet. But it is well on its way.

2016.02.08 MSS Code Factory 2.5.13233 Exceptions are now caught and written to JavaFX CFConsole

The exceptions are now properly identified with field names for the editors, and managed through try/catch blocks on each of the application buttons to log the exceptions to the application's CFConsole instance. You *must* instantiate a CFConsole for your application if you are using the JavaFX code layers.

2016.02.08 MSS Code Factory 2.5.13232 Repackaged with CFLib 2.5.13231

There are no code or rule base changes with this release; it is just to ensure that MSS Code Factory is shipped with the latest version of CFLib (2.5.13231.)

2016.02.08 MSS Code Factory CFLib 2.5.13231 Add field names to JavaFX editors and implement CFConsole

CFConsole is going to replace the text fields in the applications. Each application is expected to instantiate one CFConsole, which is used via static methods to log exceptions raised by the editor widgets and by the execution of the application code. This has always been part of the plan for the application, but until now I wanted to get the exception tracebacks for debug purposes. This implementation doesn't log the traceback.

2016.02.08 MSS Code Factory 2.5.13230 Clean up enable state and sizing of JavaFX buttons

The JavaFX buttons now all have a minimum width of 200 pixels and the enable state has been adjusted to disable the main menu buttons while an Add sub-menu is displayed.

2016.02.07 MSS Code Factory 2.5.13228 Service Pack 3 released

Service Pack 3 brings support for small-resolution displays such as the 7-inch LCD screen of the Raspberry Pi 2B+, which is only an 800x480 display. With these changes, you should now be able to deploy the clients to any smartphone or tablet which supports JDK 8 and the OpenJFX packages, which should include the iOS and Android ports by Gluon.

2016.02.07 MSS Code Factory 2.5.13226 Repackaged with CFLib 2.5.13225

The String, Text, Token, NmToken, and NmTokens editors now set their preferred widths, but not a minimum width. This improves compatability for small real-estate screens like the Raspberry Pi.

2016.02.07 MSS Code Factory CFLib 2.5.13225 Changed the way widths are calculated for string, text, etc. editors

The String, Text, Token, NmToken, and NmTokens editors now set their preferred widths, but not a minimum width. This improves compatability for small real-estate screens like the Raspberry Pi.

2016.02.07 MSS Code Factory 2.5.13223 Button menus wrapped in ScrollPanes, other ScrollPanes fixed

The ScrollPanes for viewing and editing attributes now properly display scroll bars when required. The button menus have all been wrapped in ScrollPanes with dynamic scroll bars so that the menus don't disappear off screen when working on small display real-estate systems like the Raspberry Pi with a 7-inch LCD screen (which is only 800x480.)

While it is crude and painful, the JavaFX applications are now fully usable on the Raspberry Pi.

If they'll fit on the screen of the Raspberry Pi, they'll fit on pretty much any screen, including smart phones using JDK 8 with ports of OpenJFX. (That, apparently, includes Android and iOS devices, so have fun with it!)

2016.02.05 MSS Code Factory 2.5.13221 Rebuilt with CFLib, CFCore with Swing support removed

The Swing support has been removed from CFLib 2.5.13219, CFCore 2.5.13220 has been rebuilt to incorporate those changes, and MSS Code Factory 2.5 itself has been rebuilt and repackaged with those latest jars.

2016.02.05 MSS Code Factory CFCore 2.5.13220 Rebuilt with CFLib 2.5.13219

For the sake of consistency, CFCore 2.5 has been rebuilt with the latest JDK and CFLib 2.5.13219.

2016.02.05 MSS Code Factory CFLib 2.5.13219 Swing support removed

The Swing sub-package has been removed, and some erroneous references to it from the JavaFX package have also been fixed.

2016.02.05 MSS Code Factory 2.5.13217 Swing support removed

The Swing prototype GUI code has been deprecated and removed as the JavaFX layers are now fully capable of superceding that functionality with only a small amount of custom code required for a project.

The CFDbTest 2.6 client has been successfully executed on a Raspberry Pi 2B+ using the Oracle JDK 8 with a Gluon build of the Open JavaFX implementation for that platform. The forms need to have scroll panes added so that the application is actually usable on a 7-inch 800x480 screen, but it does run.

If it will run on a resource-limited platform like a Pi, you should have no problem running the clients on an Android device with the newer OpenJDK 8 based Java environment and the Gluon builds for it. If worst comes to worst, you might have to do a cross-platform build for Google's runtime. But it should work.

It will work better once I've added a few ScrollPanes to wrap the longer lists of buttons used by the menus.

2016.01.31 MSS Code Factory 2.5.13215 Service Pack 2

After spending some more time playing around with the CFDbTest 2.6 JavaFX custom client, I am comfortable with releasing Service Pack 2. I will not be re-uploading the 2.6 projects, as their code remains unchanged. The only change between 2.5.13213 and 2.5.13215 is the version number.

2016.01.31 MSS Code Factory 2.5.13213 Corrected response XSDs

The response XSDs had the wrong element name for the RspnServerProcExecuted element. This has been corrected, and all of the CFDbTest 2.6 custom remote procedures now execute without producing any parser validation errors.

2016.01.31 MSS Code Factory 2.5.13211 Rebuilt with CFLib 2.5.13210

Rebuilt and repackaged with CFLib 2.5.13210.

2016.01.31 MSS Code Factory CFLib 2.5.13210 Correct JavaFX field editors

The JavaFX field editors have been corrected and you can now properly persist a new ReqFullRange object with the CFDbTest custom GUI.

2016.01.29 MSS Code Factory 2.5.13206 JavaFX bug fix for sub-element lists of class hierarchies

During debugging of the CFDbTest hierarchy browser, the only problem encountered was a mistaken reference to buttonAdd instead of buttonCancelAdd when constructing the menu of buttons for a sub-element list view. This has been corrected, and CFDbTest's hierarchy browser is now complete and ready to be propagated to CFBam.

2016.01.29 MSS Code Factory 2.5.13204 JavaFX View/Edit forms can not support deletes

The View/Edit forms for JavaFX can not support deletes because there is no way to reliably synchronize the calling window if someone deletes an object through the instance windows, as they don't expect a deletion to occur, only a view/edit cycle of the object.

Instead, you'll have to delete objects through the finder or sub-element lists, or through the hierarchy browsers. That way the database changes can be properly propagated to the caller.

2016.01.27 MSS Code Factory 2.5.13199 DelDep and ClearDep processing now joins superclass tables

The DelDep and ClearDep processing in the delete stored procedures now join the superclass tables in order to be able to resolve inherited relationships. The code has been tested for PostgreSQL, and the corresponding changes propagated to the other database creation scripts. However, as I only have access to PostgreSQL and MySQL as I no longer have a Windows box, the other databases have not been tested. They should work, though. The change was not particularly complex.

2016.01.27 MSS Code Factory 2.5.13198 Added more DelDeps to models

The CFInternet, CFBam, and CFDbTest models have been enhanced to specify some missing deletion dependencies on the internet object hierarchy. This should take care of the inability to delete objects that have sub-objects in the CFInternet domain browser.

However, it does mean full manufacturing and rebuilds of pretty much every project except CFSecurity.

2016.01.27 MSS Code Factory 2.5.13195 JavaFX Add form and pane synchronization bugs corrected

The JavaFX Add code was not properly propagating the added instance via the callbacks, because only the attribute pane was holding a reference to the newly added instance. This has been corrected by "bubbling up" the added instance from the attribute pane to the other panes via the getJavaFXFocus() APIs.

2016.01.22 MSS Code Factory 2.5.13192 View/Edit forms omit EltTabPane if no elements

The View/Edit panes and forms have been modified to omit the EltTabPane if there are no sub-objects of the viewed/edited object. This is done primarily to clean up the user interface, and doesn't really affect all that many objects, but I felt it should be done before I could forget about it again.

2016.01.17 MSS Code Factory 2.5.13190 FormClosed and Deleted callbacks now pass object arguments

The FormClosed and Deleted callbacks for JavaFX now pass the affected and (stale) deleted objects as arguments. This allows more intelligent refreshing of the user interface, improving performance.

This is particularly important for tree views, as it allows them to add or remove the individual objects from the tree instead of rebuilding the whole node tree, which can be a time-consuming process.

2016.01.17 MSS Code Factory CFCore 2.5.13189 Build refreshed

The build and packaging of the CFCore code has been refreshed just to make sure it is up to date with the latest OpenJDK 8 shipped by Debian Jessie.

2016.01.17 MSS Code Factory CFLib 2.5.13188 Callbacks now pass affected objects as arguments

The ICFDeleteCallback and ICFFormClosed callbacks for JavaFX now pass the affected objects as a generic ICFLibAnyObj argument. This will allow the tree list in the custom CFInternet code to refresh only the affected part of the tree instead of having to rebuild the whole thing (which can be a time-consuming process, and loses the expansion state of the tree nodes.)

2016.01.05 Programmer's Notes

This Christmas I was given a Raspberry Pi 2 B+ with the standard 7-inch touch screen. I am going to target such a system running the default Raspbian GUI as the minimum supported client hardware for running web clients of code produced by MSS Code Factory 2.5.

I'm going to use an HDMI-connected Raspberry Pi as the minimal usable client display configuration for MSS Code Factory 2.5, and use that for performance-testing of the code.

So for roughly $300 ($75 Pi kit, $75 display, $150 external USB3 HDD or a 500GB+ USB3 memory stick mounted as /home coupled with a 256GB USB3 memory stick mounted as root.) anyone can buy a system they can use to access applications that publish their data over the XMsg interface.

The Pi's SD Card is only used to bootstrap the system into the USB device copy of the Raspbian Pi/Debian Linux "Jessie" OS.

This base system provices a web client with automatic update channels to keep the system current without saturating the network by caching as much of the code through system updates as possible.

None of this six month lag time nonsense on fixes and updates for the core OS.

I'm also assuming the remaining two USB ports are your mouse and keyboard, and that you're using a 1080p HDMI monitor (which is actually a higher resolution than the Pi can support, but the Pi can do better than a 720p display, so I'm going to presume the minimum standard display that can support the Pi's maximum display.

Being able to *run* on the Pi doesn't mean it is going to be a *nice* interface with the 7" touch screen. Just that it should work.

2016.01.05 MSS Code Factory 2.5.13171 Added JavaFX Add forms

The JavaFX Add forms do not display sub-instances or lists of elements. Only the new instance currently being edited is visible. You can not Delete the new instance, only Save or Cancel your edits.

2015.12.11 MSS Code Factory 2.5.13168 Added and wired JavaFX Add Form/Pane

The table factories for JavaFX now provide for newAddPane() and newAddForm() interfaces and implementations. The AddPane is based on a ViewEditPane, but with the EltTabPane removed. Currently there is a lot of dead code in the AddPane implementation -- an EltTabPane class gets defined even though it is no longer instantiated.

The new AddForm implemenations are used when Adding an object instance instead of the ViewEditForm that had been previously used. You should not be trying to add sub-element instances until you have persisted the newly added object.

2015.11.26 MSS Code Factory 2.5.13164 Service Pack 1

I've decided to release the current code as Service Pack 1 because I have had no problems working with the JavaFX implementations to date, having resolved the build problems that were plaguing some applications.

I will continue working on the custom code and will release updates to the 2.6 projects for the foreseeable future, but I am comfortable that MSS Code Factory 2.5 itself is ready for a Service Pack release.

2015.11.22 MSS Code Factory 2.5.13162 JavaFX build issues corrected

The JavaFX build issues have been corrected. The test project I've been helping a friend with now builds successfully and completely.

As it turns out, sometimes "import javafx.*;" is accepted by the compiler and sometimes it isn't. It just so happened that it was accepted for the MSS Code Factory 2.6 sub-projects, but not for my friend's project. However, there is nothing in the code that requires "import javafx.*;" for a successful build, so once I removed those statements from the rule base, remanufactured the code, and recompiled, everything worked fine.

2015.11.15 MSS Code Factory 2.5.13160 Correct security initialization data files

The security initialization data files were incorrectly specifying "xsd:schemaLocation" instead of "xsi:schemaLocation".

2015.11.13 MSS Code Factory 2.5.13159 Correct packaging error

The XSDs weren't being properly packaged by the installer.

2015.11.08 MSS Code Factory 2.5.13157 Rebuilt with OpenJDK 8 on Debian "Jessie"

I've shifted back to Debian "Jessie" so I'm rebuilding all of the projects and jars.

2015.11.08 MSS Code Factory CFCore 2.5.13156 Rebuilt with OpenJDK 8 on Debian "Jessie"

I've shifted back to Debian "Jessie" from Ubuntu 15.10.

2015.11.08 MSS Code Factory CFLib 2.5.13155 Rebuilt with OpenJDK 8 and JavaFX on Debian "Jessie"

Due to Ubuntu blowing up my 15.10 installation, I've shifted back to Debian "Jessie" with backports enabled.

2015.11.05 MSS Code Factory 2.5.13154 Major bug fixes for non-2.6 projects

The naming of files and packages was completely incorrect for anything other than the MSS Code Factory 2.6 sub-projects. I can't believe I never thought to test this before I was helping a friend out with a project of his that is going to be using this tool. My bad.

But it is fixed.

None of the 2.6 projects themselves are affected by the fixes.

2015.11.04 MSS Code Factory 2.5.13152 Add audit attributes to XMsg create requests

All of the code in existence is expecting to deal with the revision and audit attributes for create requests, so that has to be incorporated in the XSD create requests as well as the update requests.

2015.11.04 MSS Code Factory 2.5.13150 Use a JavaFX workaround instead of TableView.refresh()

It turns out that TableView.refresh() is not public for the Oracle implementation of JavaFX, only for the OpenJDK add-on implementation. So I've replaced the calls to refresh() with the column visiblity hack from

2015.10.29 MSS Code Factory 2.5.13148 Corrected enable state of JavaFX list panes

The enable states of the "menu" buttons for the JavaFX list panes were incorrect. They now follow the proper protocol.

2015.10.26 MSS Code Factory 2.5.13146 Multi-line text now works

All of the rule files have changed to 1.0 XML syntax specifications. Just because. I also switched over to encoding newlines as 
 and carriage returns as 
, and lo and behold:


2015.10.26 MSS Code Factory CFCore 2.5.13145 Revert to XML 1.0

Aside from reverting to XML 1.0, I discovered I forgot to check in the code before shipping the code that relies on this library.

My bad.

2015.10.26 MSS Code Factory CFLib 2.5.13144 Revert to XML 1.0

I'm not sure, but I think I get a different SAXParser implementation when using 1.0 instead of 1.1 XML version files/messages. One key difference is that Xerces now only seems to strip the newlines from multi-line string attributes, rather than normalizing all of the spaces within that text.

It's not good, but it's better than what I was seeing with the last release. Once I've rebuilt everything with 1.0 instead of 1.1 XML, I'll also retest to see if the grammar cache gets used now. If it does, then I know the problem was Xerces installing a non-Xerces SAX parser for 1.1 syntax.

2015.10.25 MSS Code Factory 2.5.13142 Life, the Universe, and XSDs

The XSDs manufactured were specifying qualified attribute names instead of unqualified. As all of the runtime-generated XML uses unqualified attribute names, this had been causing problems with the debugging of the XMsg communications.

You do need to copy the XSDs to $ECLIPSE_HOME/../bin/xsd to debug the web services, or the XSDs won't be resolved. You would also need to copy them to ../bin/xsd relative to the runtime current working directory of your web application server if deploying the WARs. You can find all the relevent .XSDs in the bin/xsd directory of the installer packages (where they are used when running the client applications through the startup scripts.)

The client-server XMsg implementation now runs without complaining about invalid elements or attributes, but after all this work I've discovered that Xerces still does not honour the whitespace preserve specifications. However, there is one more Xerces option I can turn on that is supposed to enable attribute validation -- perhaps that will convince Xerces to stop normalizing my strings.

Why in the world anything other than an xsd:normalizedString type is being NORMALIZED in the first place is beyond me. Why bother with a normalizedString type if the default behavior for a REGULAR string is to normalize it?

Note that changing the value of the feature "" seems to make no difference whatsoever. I'm starting to suspect that maybe PostgreSQL is munging my data. I can't believe that Xerces would have a broken XML implementation that doesn't recognize whitespace preservation options.

2015.10.25 MSS Code Factory CFLib 2.5.13141 Correct XSD references in runtime-generated XML

There were a couple of cases where the runtime XML documents were referring to the XSD as ../bin/myschema.xsd instead of ../bin/xsd/myschema.xsd, which was causing validation errors from the XMsg communications.

2015.10.24 MSS Code Factory 2.5.13139 Correct XSD references in security initialization files

The secinit files created for the applications were not using the relative paths for locating the security structured XSD file. That has been corrected.

All of the code built clean, though I have yet to test it. However, after exercising the parsers with MSS Code Factory itself, I'm comfortable that all I'll need to do is maybe copy the XSD files to another ../bin/xsd directory relative to where the runtimes are executing from.

2015.10.24 MSS Code Factory 2.5.13138 Use relative paths for XML schema locators

All of the XML documents in MSS Code Factory have been updated to reference the schema documents using relative paths. All of the XML documents should be validated during load with this release, including the rule cartridges.

2015.10.24 MSS Code Factory CFCore 2.5.13137 Use relative paths for XML schema locators

As with the CFLib implementations, CFCore now uses relative paths for XML schema locators. The switch over to validation of SAX parsers with XML schemas was made common to the SAX base parser class in CFLib, so no changes were required for the actual parser code other than changing over to the relative paths when trying to open the schema as a file instead of as a resource.

2015.10.24 MSS Code Factory CFLib 2.5.13136 Use relative paths for XML schema locators

After much digging, I discovered that Xerces-J does not use the grammar cache for validating XML schema documents. Instead, it always relies on the schemaLocation specification in the XML document itself.

In order to work around the issue, I'm going to copy all XSDs to bin/xsd for each of the projects, and attempt to resolve the file ../bin/xsd/someschema.xsd in the JAR files before using the resource file built into the jar. All XML documents, including those built by XMsg, will use this relative path reference for locating their schema definitions. While this is not an ideal situation, it will allow me to enable the validation throughout the system, which will hopefully allow me to correct the string normalization problem I've been working on all these days.

2015.10.24 MSS Code Factory 2.5.13135 MSSBam specifications are now validated

The parser for the MSSBam specifications has been specifically enhanced to perform SAX validation with a schema specification. However, the parser is not recognizing and using the cached grammars that I have loaded.

I'm going to see if there is a way to build a Schema object from a set of Grammar objects. If so, I'll try specifying an integrated Schema when I instantiate the parser, in hopes that doing so will convince the parser to recognize the document schema without having to access the schema file directly.

Right now all of the models are referencing the schema directly on my development box file system. This is not the way I want to do things in the long run. I want caching to work, damnit!

If you use this build for generic models, they will parse properly, but there will be a lot of complaints about the schema not being resolved/read while parsing the MSSBam specification. You could modify your models to specify the hard-coded system path to your copy of the .xsd for the MSSBam, but I don't know that I would recommend that. It is probably better to wait for me to resolve the schema specification issues.

2015.10.24 MSS Code Factory CFLib 2.5.13134 Working on SAX parser validation

It turns out I have parser validation disabled. Not what I intended. I've made the parser a protected attribute instead of a private one so I can work on test code in the parser specification instead of having to keep reworking and repackaing CFLib to do my testing. There is no other difference in this version of CFLib.

2015.10.24 MSS Code Factory 2.5.13132 Switch all XML to version 1.1

In addition to switching all of the XML to 1.1 syntax, I've also reworked the grammar caching in the CFLib implementation, rewired the way grammars are added to the cache, and tweaked the instantiation of the SAX parsers to enable schema validation but not DTD validation.

2015.10.24 MSS Code Factory CFCore 2.5.13131 Switch all XML to version 1.1

All of the XML documents now use 1.1 syntax.

2015.10.24 MSS Code Factory 2.5.13130 Switch all XML to version 1.1

I'm still trying to deal with the loss of white space for attributes, so I'm switching everything over to XML 1.1 from 1.0 in hopes that it might help to resolve the issue.

2015.10.23 MSS Code Factory CFLib 2.5.13129 Enable schema validation for SAX parsers

The SAX parsers need to have schema validation turned on in order to (hopefully) preserve the whitespace of attributes.

2015.10.22 MSS Code Factory 2.5.13127 All XSDs now specify whiteSpace preserve for String and Text attributes

The XSDs produced by the system now specify that white space is to be preserved for all String and Text attributes of an application.

2015.10.22 MSS Code Factory 2.5.13124 Corrected ICFRefreshCallback cast in JavaFX ListPane

The ListPane implementation was checking for an instance of ICFForm and then casting to ICFRefreshCallback without properly making sure the instance is also castable to ICFRefreshCallback.

2015.10.22 MSS Code Factory 2.5.13122 CFInternet model corrected, all 2.6 projects remanufactured

The License object was not a proper XSD component of the BaseDomain, so the test data wasn't parsing properly when performing a data import for CFInternet.

2015.10.21 MSS Code Factory 2.5.13120 Rebuilt with CFLib 2.5.13119

Rebuilt, repackaged, and redeployed with CFLib 2.5.13119, adding the objects CFLibFiringList and CFLibFireOnInstanceOf.

2015.10.21 MSS Code Factory CFLib 2.5.13119 Added CFLibFiringList of CFLibFireOnInstanceOf

The element CFLibFireOnInstanceOf callback hooks have been defined along with a CFLibFiringList extension of an ArrayList implementation for firing registered callbacks when the current object instance matches the class the callbacks have specified.

2015.10.21 MSS Code Factory 2.5.13116 Used to remanufacture code with promoted License support

The CFBam model had to be tweaked before it could be manufactured and built.

2015.10.21 MSS Code Factory 2.5.13114 Promote License from CFBam 2.6 to CFInternet 2.6

The License object has been promoted to a generic Internet interface, so that licenses can be specified by generic internet data loaders. Licensing is a common issue to deal with, so it makes sense to generalize the implementation and interface.

2015.10.17 MSS Code Factory 2.5.13110 Remove CFEnSyntax 2.6 sub-project

I didn't bookmark the website I was using as the guideline for designing the CFEnSyntax 2.6 business model, and I wasn't really planning on doing anything with that project anyhow, so it has been purged from the set of 2.6 models and the 2.5 scripts that used to reference it.

2015.10.05 MSS Code Factory 2.5.13108 JavaFX now refreshes the data tables/list boxes properly

The data tables were being repopulated with new data sets, but because the instances often matched the old data sets, the display wasn't being properly refreshed. Simply performing a refresh() on the data table resolves the problem. Best of all, I've discovered that any existing row selections are retained across the refresh process, saving me the hassle of figuring out how to code that behaviour.

2015.10.02 MSS Code Factory 2.5.13105 Corrected implementation of JavaFX Add functionality

In addition to correcting the generic JavaFX Add object functionality, the CFAcc 2.6 model has been corrected to get rid of errors in the tenant delete stored procedures.

I will not be producing JavaFX custom code for CFEnSyntax, CFBam, and CFDbTest 2.6 at this time. CFEnSyntax needs significant rework and enhancement of its model, and CFBam and CFDbTest have data which is dependant on the CFInternet objects and I haven't decided exactly how I want to deal with that situation yet.

2015.10.02 MSS Code Factory 2.5.13104 Edited objects are now flushed by minimizeMemory()

The minimizeMemory() method was originally written with direct client-server applications in mind, but with the primary use being HTTP client-server applications now, it is necessary to flush the edited objects at the back-end cache. This may cause problems if I don't automatically acquire edits during updates and deletes; I'll have to look into the code and do some testing before I release this change.

2015.10.02 MSS Code Factory 2.5.13101 CFAsterisk configuration no longer owned by Internet HostNode

In order to allow easy editing of the CFAsterisk configuration data with the JavaFX client, the Internet HostNode is now a Parent of the configuration data instead of a Container. This allows Finder forms to be produced for the configuration objects.

2015.09.22 MSS Code Factory 2.5.13094 All 2.6 projects now build clean

All of the 2.6 projects now build clean for the JavaFX CRUD GUI components.

2015.09.21 MSS Code Factory CFLib 2.5.13093 Corrected cell formatter for UInt64

The cell formatter for UInt64 was mistakenly referring to a Number instead of a BigDecimal.

2015.09.20 MSS Code Factory 2.5.13091 Core JavaFX functionality complete

The core functionality of the JavaFX GUI is now complete. I can get back to working on the custom forms and the development of an actual application (CF Accounting.)

2015.09.20 MSS Code Factory CFLib 2.5.13090 Added ICFDeleteCallback

ICFDeleteCallback is invoked by delete forms when they delete an instance.

2015.09.20 MSS Code Factory 2.5.13088 Callbacks for View/Edit form closure coded and tested

When you close a View/Edit form, there is now a callback to the invoking form that gets executed so the calling form knows that it's time to refresh it's data views. Only the View/Edit forms need this callback so far.

Deletes still need some work, but once those are working, all of the key functionality will be in place and I can start worrying about cleaning up nice-to-haves that are wandering around my befuddled mind. :)

2015.09.18 MSS Code Factory 2.5.13086 Added enable/disable support to View/Edit/Attr forms and panes

The enabling and disabling of the various widgets has been added to the Attr and View/Edit forms and panes. A bug with the initialization of the detail lists in those forms has also been corrected.

This release is also built and packaged with CFLib 2.5.13085.

2015.09.18 MSS Code Factory CFLib 2.5.13085 Corrected truncated field sizes

The editors for string, nmtoken, etc. now set a minimum field size of 400 pixels wide instead of 40 when their MaxLen is set to more than 40. If you want wider fields in an application, just adjust the sizing attributes after setting MaxLen -- they only get calculated by setting MaxLen, not at runtime.

The callback interface ICFFormClosedCallback has also been added, because there are no window closed events the way that I use JavaFX, and I need those events to know when a child form has closed so I can refresh the parent's data.

2015.09.17 MSS Code Factory 2.5.13083 TableView selections adjust buttons now

The selection of rows in the table views now adjust the enable/disable state of the "menu" buttons of the application. You can also bring up the various detail windows, though I doubt they work properly yet (except for cancelling/closing.)

2015.09.17 MSS Code Factory 2.5.13081 TableView sorting implemented

TableView sorting has been implemented and the cell renderers have been migrated to CFLib 2.5. The Number cell renderer has been enhanced with the extra Digits and Precis arguments for construction, and the appropriate arguments are now passed by the manufactured code.

2015.09.17 MSS Code Factory CFLib 2.5.13080 Cell renderers migrated and enhanced

The cell renderers have been migrated from CFSecurity and enhanced with the formatting code that the Swing equivalents were using.

2015.09.16 MSS Code Factory 2.5.13078 Initial testing of JavaFX table views done

The table views have been tested for displaying existing data, but there are no selection options coded yet so you can't pick a row and view it in a detail form yet, but that will come in due time. At least the data shows up.

2015.09.16 MSS Code Factory 2.5.13076 JavaFX table view population coded but not tested

The initial draft of the TableView population has been coded but is completely untested. Certain features like sorting by chain or qualified name will have to be re-coded later.

2015.09.16 MSS Code Factory 2.5.13074 JavaFX reference cell rendering added, warnings cleaned up

There are no more warnings when compiling the JavaFX code, and the cell rendering of relationships/references has been prototyped.

2015.09.16 MSS Code Factory 2.5.13072 JavaFX cell rendering code prototyped

The cell rendering code for the JavaFX table views has been prototyped. The core objects for the rendering are currently in CFSecurity's JavaFX implementation rather than CFLib while I work on getting them functional and debugged.

But before I debug anything, I'll have to populate the data for my table views.

2015.09.16 MSS Code Factory 2.5.13070 Key bugs fixed for JavaFX

Some of the initial key bugs with object setup and cross-linking have been fixed, so now you can navigate to the finder windows for the security cluster, system, and tenant data. None of the data is actually populated yet, so you can't add, select/view, or delete objects yet, but it is a start.

2015.09.12 MSS Code Factory 2.5.13068 Rebuilt with CFLib 2.5.13067

There were changes to the rules, so I'll re-manufacture the five core development projects before I build and package them, just to be sure (CFSecurity, CFInternet, CFCrm, CFAcc, and CFAcc Custom.) I won't bother refreshing the other projects until I have this JavaFX thing working to some degree.

2015.09.12 MSS Code Factory CFLib 2.5.13067 New form management objects added for JavaFX

New form manager interfaces and implementations have been added to the JavaFX package of CFLib.

2015.09.11 MSS Code Factory 2.5.13063 JavaFX code cleaned up and reorganized

Each of the subject facets now only produces CRUD forms for the tables they've defined, and reference the existing implementations from the other packages that are supposed to be included in the build. Thus everything using JavaFX will likely include the javafx.jar for CFSecurity 2.6.

2015.09.11 MSS Code Factory 2.5.13061 Clean build of JavaFX code

It may not be done and I know it won't work yet, but it builds clean, so I can integrate it into my build process for CFSecurity, CFInternet, CFCrm, and CFAcc, manufacturing those projects with the new rule base so I have the code needed to build the new jars.

Then I can test the new code and work on it through a CFSecurity 2.6 client connecting to my CFAcc 2.6 PostgreSQL server. Then the real fun will start: making it actually go.

2015.09.10 MSS Code Factory 2.5.13059 One more form needs to be adapted before I have a clean compile

I still need to deal with the PickerPanes, and then I'll finally have a clean build of the JavaFX CRUD forms. They won't actually work yet, of course, but it means I can stitch the code into the build and the debugger so I can start exercising it.

2015.09.10 MSS Code Factory 2.5.13057 The first list box form (List, of course) compiles clean

The ListPane objects now compile clean for the JavaFX efforts, but I know for a fact that they won't actually run because there are no custom cell renderers installed and everything is returning objects instead of fussing around with the details.

I'll have to dive into custom cell renderers next, and figure out how to best migrate my Swing cell renderers to JavaFX (CFLib code changes coming up!)

2015.09.10 MSS Code Factory 2.5.13055 The bulk of the CRUD forms have been migrated to JavaFX

The List, Picker, and Finder forms with their list boxes are all that remain to be first-cut-ported from Swing to JavaFX. I've made significant UI changes all the way along, as I'm pursuing a different UI metaphor this time which should be better-suited to touch devices and cell phones.

I'm rethinking my approach to the "Add" menu (implemented as a CFVBox). Instead of displaying it as a popup, maybe I'll wire it via setLeft() to display it on the left side of the border pane. When you select an item from the list, it does the action and removes the "menu" from the left side of the display by calling setLeft( null ). But that means I need an artificial "Close Menu" button as well that does nothing but remove the "menu" from the left side of the display.

2015.09.09 MSS Code Factory 2.5.13053 Portions of JavaFX CRUD now build

A significant portion of the CRUD code for JavaFX now builds (4-5 of the rule sets now produce valid source code files.) There is still a lot to be done, of course, but it is coming along nicely.

2015.09.09 MSS Code Factory 2.5.13051 Draft of migration of Swing CRUD forms to JavaFX

The new code produced by the JavaFX rules is so far from compiling at this point it isn't even a bad joke... But here it is, such as I'm starting with. These are the pieces of code I intend to whip into shape to form JavaFX CRUD forms.

2015.09.09 MSS Code Factory 2.5.13048 Rebuilt and repackaged with CFLib 2.5.13047

Yada, yada, yada.

2015.09.09 MSS Code Factory CFLib 2.5.13047 A few more interface objects

There were a few more JavaFX glue objects missing. As well as some non-default constructors for the HBox and VBox implementations.

2015.09.09 MSS Code Factory 2.5.13046 Rebuilt and repackaged with CFLib 2.5.13045

Just a "to be sure" refresh using the latest CFLib 2.5.13045.

2015.09.09 MSS Code Factory CFLib 2.5.13045 Fleshed out remaining "widget" hierarchy

I went through all of the forms coded for the custom Security interface so far, and created the missing CF* equivalents. Note that my JavaFX sub-package for CFLib is an unorganized collection of what I actually use to create a GUI, not a full-featured set of everything JavaFX has to offer. I'm not trying to replace JavaFX -- I'm just trying to wedge myself in there in case I ever need to apply global fixes or enhancements to the user interface behaviours.

For example, I'd like to have visual feedback of the validation state (i.e. highlighting fields orange/disabled or red/enabled when they are invalid according to their editor and field value range attributes.)

Fields should "gray out" when they're disabled, not just cease activation. Alternatively, maybe there is a "read only" option in JavaFX that I should be using instead. So much to learn...

2015.09.09 MSS Code Factory 2.5.13043 Rebuilt with CFLib 2.5.13042

No changes to the rules or the core code. Just a perfunctory rebuild and repackage to keep everything in sync with CFLib.

2015.09.08 MSS Code Factory CFLib 2.5.13042 Life, the Universe, and Everything: JavaFX

JavaFX now has a foundation layer of controls (widgets) migrated from the CFLib Swing widget set, including a wide variety of Panes you might want to have your application frames/windows/forms inheriting from in order to implement the basic focus interface defined by CFLib.

I haven't dealt with list boxes yet, so I don't know what will be involved in migrating the cell renderers. That will have to wait until later.

I'm probably still missing a few widgets. The combo box comes to mind as one that has to be done yet.

2015.09.08 MSS Code Factory 2.5.13039 Initdata now specifies new IsVisible attribute

The SecGroup and TSecGroup entries in the security initialization data manufactured for the project needed to specify the new IsVisible attribute.

2015.09.07 MSS Code Factory 2.5.13037 Modified CFSecurity 2.6 model

Add a visibility flag to the groups with indexes for searching for visible groups for a given cluster or tenant. The "all" tabs of the planned security interfaces will return (surprise, surprise) all groups, but the default/preferred user interface is to filter only those which have IsVisible=true.

All projects need to be manufactured at some point, but for now I'll only be doing the ones I'm actively working with: CFSecurity, CFInternet, CFCrm, and CFAcc 2.6.

2015.09.07 MSS Code Factory 2.5.13033 Default implementation of get/setServerURL() returns null, ignores setting

The generic interface methods get/set ServerURL() have been added to the fundamental schema interface. These methods only get overloaded by the HTTP client implementation, which makes use of the settings to establish connections over the network. All other backing stores ignore this attribute.

2015.09.07 MSS Code Factory 2.5.13029 Default implementation of getCFTipClientHandler() returns null

The generic interface method getCFTipClientHandler() is defined by the schema backing store interface now, but only the XMsgClient implementation actually overrides the default "return null" behaviour with a valid instance. Your code which calls this method must therefore detect and respond to nulls accordingly, as it will have problems if it is ever run while directly connected to the database through a client-server implementation.

2015.09.02 MSS Code Factory 2.5.13016 Updated CFAcc 2.6 model

I'm working on CFAccounting in earnest now for something to keep me busy.

2015.09.01 MSS Code Factory 2.5.13014 TODO items taken care of

Various *CFAll26[.bash/.bat] scripts have been added to the 2.5 deployment in an effort to further automate the process of producing a refresh of the 2.6 projects.

My "duty cycle" for this box is now:

# Most times for a P4 2.4 GHz with 4G of 800MHz DDR2, 7200rpm Seagate Baraccuda 1TB HDD, Ubuntu 15.04 amd64
cd ~/msscodefactory
time CleanCFAll26.bash
real time minimum 26 seconds for already-cleaned projects, maximum 54 seconds for fully-populated projects
time ManufactureCFAll26.bash
real time 56m57s
real time laptop Core i7 17m01s
time BuildCFAll26.bash
real time 224m41s
real time laptop Core i7 96m37s
time GitAddCFAll26.bash
real time 3m43s
real time laptop Core i7 7m14s
GitCFAll26.bash tag 2.6.13015
GitCFAll26.bash push
GitCFAll26.bash push --tags
time ArchiveCFAll26.bash 13015
real time 5m01s
time PackageCFAll26.bash 13015
real time 3m37s
real time laptop Core i7 1m53s
TOTAL TIME > 292m79s
TOTAL TIME laptop Core i7 > 127m00s, a 57% time improvement

2015.08.31 Programmer's Notes

MSS Code Factory 2.5.13012 is the last major feature-add release of the project after being in development since 1998 (yes, I worked on this project for 17 years!) There will be updates to the models as I try using it to write some applications (in particular, I've decided to work with CFAcc 2.6 and create a Java/FX user interface using that code as a foundation for a distributed accounting application), and there may be bug fix releases as those applications are developed, but no new features or functionality are expected to be added in the future. As it is, roughly 2/3 of what MSS Code Factory produces for code is the result of "scope creep" compared to my original vision for the tool.

There needs to be a 2.5 Service Pack 1 that either implements or exception-throws the "todo" items in the current manufactured code. There are still a few of those tags in the code, so that needs to be cleaned up before I call it quits.

I have to be a professional and pay attention to the details, you know? The same as I did my entire career. Finish the job as completely as I knew how.

I think I'm going to shift to the Windows laptop for a few days, and see if there are any issues running under the Microsoft Windows 10/Oracle JDK 8 environment. So I'll get the application rebuilt under the Windows stack, and think about packaging that as an alternative installation file.

I need to refresh all my Windows stack since Windows 10 was released and I applied the update. I need to make sure everything still works as planned, though I will not be re-installing any database engine other than PostgreSQL. PostgreSQL is "big enough" for testing.

Once I've made sure the Windows 10 stack works, I'll jump back to my Linux box for developing the GUI application client and supporting server implementation (CFAcc 2.6 Code Factory Accounting.)

2015.08.28 MSS Code Factory 2.5.13012 PROD

All of the 2.6 projects now build properly, so 2.5 is being released to production without further ado. This release doesn't really change anything since the 2.3 Service Pack 1 release; it is just built using the code produced by those changes internally (eating my own dog food.)

2015.08.28 MSS Code Factory 2.5.13011 Fixed ManufacturingSchema reference

The ManufacturingSchema reference now properly resolves the schema that is being manufactured, at the price of using a volatile static which means you can't run multiple instances of the factory in the same process any more (not that I ever did, but I did try to make it multi-threaded.)

2015.08.28 MSS Code Factory 2.5.13010 JavaExpandPackage fixed -- resume testing

JavaExpandPackage processing has been fixed, so I'm going to resume testing after I've remanufactured all the 2.6 code.

2015.08.28 MSS Code Factory 2.5.13009 Working on debugging JavaExpandPackage

There is one bug remaining -- JavaExpandPackage isn't getting processed properly. I'll have to drop into an Eclipse debug session to figure it out. There may be changes to CFCore required, though I suspect the problem lies in the CFEnging code of the factory itself rather than in the lower layers -- the only change to CFCore was renaming from 2.3 to 2.5 and adapting the class hierarchy names accordingly; the core code wasn't actually changed.

2015.08.28 MSS Code Factory 2.5.13006 Ready for testing

MSS Code Factory 2.5 is now ready for testing. This is going to take a good day in my estimation, as I'll have to create the git projects for the 2.6 code series, manufacture the code, migrate the non-manufactured components from 2.4, and do the builds.

As this is the final release of MSS Code Factory (barring future bug reports), I'll want to make sure everything builds properly before I issue the official production release of 2.5 -- this is only a preview/test release.

2015.08.27 MSS Code Factory CFBam 2.5.13005 Clean build

CFBam 2.5 now builds cleanly.

2015.08.27 MSS Code Factory CFInternet 2.5.13004 Clean build

CFInternet 2.5 now builds cleanly.

2015.08.27 MSS Code Factory CFSecurity 2.5.13003 Clean build

CFSecurity 2.5 now builds cleanly.

2015.08.27 MSS Code Factory CFCore 2.5.13001 Migrated from 2.5

CFCore 2.5 has been migrated from CFCore 2.3.

2015.08.27 MSS Code Factory CFLib 2.5.12999 Migrated from 2.3

CFLib has been migrated to 2.5 from 2.3.

2015.08.27 MSS Code Factory CFCore, CFSecurity, CFInternet, CFBam 2.5.12998 Initial manufacturing runs complete

The initially manufactured code has been checked in.