The version I'm currently working on once again has a pretty serious structural change. The code now has a much more modern object architecture, which makes maintenance much easier. The side effects are (1) (the good one) upgrading objects in the code is dramatically simpler. This will make adding new features that require changes to the Tournament or Layout much simpler than in the past. And (2) (the down side) the serialization of these objects results in much larger file sizes. Thus, a saved tournament that may be 50k bytes today will likely be 100k or 150k bytes saved in the new model. Size really isn't the issue (hard drives are enormous in comparison), but loading and saving these files IS, and it will require a not-insignificant increase in load/save times.
All the technical talk aside, loading and saving files (tournaments and layouts) will take longer in the new version. As it turns out, the biggest culprit is the layout. It usually takes up, on average, about 2/3 of a saved tournament file, while the tournament information itself takes the remaining 1/3. Therefore, I've decided it's time to cut the umbilical cord between a tournament and its corresponding layout.
Currently, when you load a tournament file, you are also loading the layout saved with the tournament file. The question I pose to you, the users, is which method do you think would be best to facilitate this change:
(1) The tournament and layout are completely separate items. A tournament and a layout are loaded and saved completely independently of each other. When you load a tournament, the current layout is unaffected. When you load a layout, the current tournament is unaffected (this is how it is today - just like loading any "template"). When you exit the program, you are prompted to save your tournament if it has not been saved, and you are prompted to save your layout, if it has not been saved.
or
(2) Pretty much the same except the tournament has a "pointer" to the layout used. A filename only. When you load the tournament, the software looks for the layout referenced in the tournament file and attempts to load it as well. If it cannot be found, either the current layout remains or the software restores the default layout. When you save your tournament, the filename of the currently loaded layout is saved with the tournament, so the layout can be restored when the tournament is loaded again. Of course this means that you could delete a layout or make dramatic changes to one outside of a tournament, so that the next time you loaded the tournament you wouldn't necessarily see the same layout that was used during that tournament (as you've made changes to the layout).
Initially I was planning to implement (2). But the more I think about it, the more I'm inclined to go with (1). I believe this one is a slightly simpler model, and oddly enough I think it will be easier for people to grasp. I actually think it might be simpler to understand than the current system (with the Layout saved with the tournament).
What do you think?
In the interest of complete disclosure, this isn't technically a vote where I'm going to implement the one with the most votes. But I would like to hear some opinions from people who use the software, and see how this change might affect everyone. Once I get into the code for this, things could change regardless.
Thanks in advance to everyone for contributing.