DDR Europe tournament parser now by default sets all players to Norway. Syntax fixes for SQL. Update example SQL.

Add a script (and output SQL) for getting the country list from Wikipedia.

Begin changing the country stuff.
- All players must now have a country.
- There are clubs.
- Countries have three-letter IOC country codes.

The changes are not yet reflected in the data.

Don't show bigscreen controls in public mode.

The last do-finish-tournament fix was completely wrong, try to do it properly this time.

Fix UTF-8.

Make the DDR Europe parsing scripts distinguish tournaments based on their season as well, not just the name.

Make more room for the players in the "top 10 scores" screen.

Fix crash in RotateScreen when there are no subscreens.

Fix max score for players; only chosen songs can't be selected twice.

Fix list of finished groups; don't show elimination/seeding groups, show finished parallels even if they are in a non-finished round.

Cache revision.
21:15-04:00

Add an SQL snippet for fixing some stuff related to chosen/random songs in the data from DDR Europe.

Added CC04-8 data.

"Candy" now has a white star by it; updated parsers and all relevant SQL.

Added a simple flag in ccbs.pm to make the system suitable for public viewing (ie. no changes).

When there's only one group, insert it with ID 0, not ID 1, so the rest of the scripts understand it's special.

Set all songs to single expert per default (this will break when we go to DDREx, though..)

Don't show total if we only have one song.

Fix off-by-one for "needs to lead" code.

Don't show "needs to qualify" if all in group qualify.

Fixed "number of played songs" detection for bigscreen, making the "needs to lead" etc. work again.

Hack the rotate screen so it doesn't delay new updates of a screen any longer just because that screen contained new info at the time (see the comments).

Remove versus item from the TODO, it should be okay now.

Clarified the meaning of players_per_machine in the templates.

Actually fetch the number of players on the machine at a time, so the versus code works.

Add code in the bigscreen for supporting versus groups (not finished yet).

Refactoring, always refactoring...

Remove an obsolete comment.

Yet more refactoring.

Yet more refactoring.

Added refactoring comment

More refactoring.

More refactoring.

Mild refactoring.

Make the bigscreen application read in the number of players per machine, but don't do anything useful with it yet.

The front end can now choose how many players play per machine (1 or 2).

Added a field in the bigscreen active groups allowing for versus play.

Added note to TODO

Let each screen get width and height in as a parameter on draw() instead of hardcoding it to SCREEN_WIDTH * SCREEN_HEIGHT.
This is quite ugly at places, but it seems to work well. This isn't really done for the speed
boost (although fades etc. are quite a lot smoother when the split screen can do all its work
in the native resolution instead of fading and _then_ downscaling), but primarily for the
legibility (ie. let FreeType _understand_ that we are on a smaller screen, so get hinting etc.
right), which seems to have improved by quite a lot (the overall "polish" look is a bit down,
though, probably the autohinter is evil).

19:30-04:00

Forgot to add the prototype for set_screen_size().

Let the font system take in a physical resolution, instead of #define-ing it (quite ugly).

Set default resolution to 1024x768.

Make a "logical resolution" (yuck!) of 800x600 for all the screens, and make fonts.cpp compensate for that.

Replace 800x600 width a resolution from a .h file. Lots of positions are still hardcoded, though.

Implement a simple priority system.
The priority system is used to determine which screen is shown first if two or more screens
have updated information (ie. a group screen is more important than a "today's high scores"
screen, which is in turn more important than "today's most chosen songs", as the latter is
mainly a curiosity).

- Add a get_priority() to GenericScreen, default 0.
- Implement get_priority() for GroupScreen and Top10ScoreScreen, set to 10 and 5 resp.
- Make RotateScreen automatically pick the screen with the highest priority if two or more
  have forced updates.

Make sure each screen stays on for a minimum of three seconds (eight if it contains new info).

Rename same_fade to fade_to_new_info, plus minor code cleanup.

Fix "slowly to red" fading (aka same_fade) when we have a forced transition.

Make the "top 10 scores" and "top 5 chosen songs" screens only say they're updated if there is actual new data.

Fix a bug where all new screens would be cycled on start.

The auxilliary screen now also shows all finished groups.

Stop RotateScreen from crashing when it has no subscreens.

Adjusted the columns in the top 5 chosen songs a bit.

Added a "top 5 chosen songs this tournament" screen.

Added TODO list from e-mail.

Put all the auxilliary screens in a rotate screen.

Split the bigscreen objects in the Makefile into slightly more manageable groups.

Actually fetch and display the top 10 scores.

Add the framework for a top 10 screen.

Added a primary key for the "active screens" table.

Fetch the list of auxilliary screens.

Added a new mini-table for auxilliary bigscreen screens.

When editing scores in the web interface, put the web browser approximately back at the group.

Write the machine number (if any) in the header.

Make the bigscreen application support running groups on multiple machines.

Make the number of machines settable via the web interface.

Compile TinyPTC with Xshm.

Fix two signed/unsigned warnings.
20:00-20:30
22:00-00:00

Adjust the fade time back to 0.5 again, after the "starting fade time" fix.

Start the fade when we can display the first frame of it, not when we know that there is a new page. This gets rid of the "kink" we find at the start of a fade if the new screen tok a bit to generate.

Read max score for all players in one shot as well, with a new query and an index which speeds up that query a lot.

Fetch all the "max score for song" entries in one go instead of one at a time.

Clamp number of players shown to nine. Squeeze players a bit more together when we're over seven, to get room for up to nine.

Don't use split screen if we only have one screen.

Removed some debugging printf-s, converted some sprintf to std::sprintf.

Make "mode" a local variable to the for loop, now that we don't need it anymore.

Allow a mix of long and short names in the display of the chosen songs.

Cache revision.
18:00-18:45

Adjusted the fade times a bit.

Fetch the actual high score from the database when showing high score on the group screen.

Correct the logic for finding out what songs a player can choose (only random songs in the same parallel count)

Don't show "need to qualify" if it's identical to "need to win"

Moved the bottom text a bit up, to get it more readable.

Add a line for "needed to secure qualifiction"/"needed to qualify". SQL cleanups. Don't show "to lead" line if it's identical to "to win".

Add preliminary "needs to qualify/win" text.
14:00-17:00

Try to make the column for the chosen songs as fixed-width as possible.

Find out which player is playing next (and which song), but don't print it yet.

The main screen is now a split screen of rotation screens (each with a single group)

Make the "red stuff is new stuff" fade a lot prettier.

Add a better framework for showing what's changed.

Actually check in changes from last time...

Do the same number of my_draw_text() in all cases, to prepare for the "show differences in red" code.

Do some funky channel magic on fading between different versions of the same screen. This needs a lot more work; it should be done on a lower level, really.

Change await_notifications() timeout if something is invalidated (less CPU used when there's no action)

Make RotateScreen fade between the individual screens.

Cache revision.
18:45-03:15

GroupScreen now checks the "last updated" information.

Add information to the SQL schema saying when the group was last updated. Make the web interface update that information.