AlphaKey.cpp (find unique menu shortcuts).

[orefa]

A small annoyance for me is the lack of unique shortcut letters in menus: some are duplicates, some are absent. It can be tedious to search for a unique letter for each item, especially when menus are long and many items have letters in common. So I wrote a small console-based utility to do this (below) for all to use as they see fit, including the Code::Blocks developpers of course. ;-)

Enter titles one at a time, either from the console or a redirected data file. The program also provides useful information like a table of letters used, available but unused shortcut candidates and unused letters to help vary the actual titles in order to achieve uniqueness. For example, a little bit of fiddling assisted by this utility yielded this reworked Code::Blocks "File" menu:

n: (N)ew file
e: N(e)w project

o: (O)pen
f: Recent (f)iles
r: (R)ecent projects

s: (S)ave file
a: S(a)ve project
v: Sa(v)e workspace
y: Save ever(y)thing

i: Save f(i)le as
j: Save pro(j)ect as
w: Save (w)orkspace as

c: (C)lose file
l: C(l)ose project
k: Close wor(k)space

p: (P)rint
x: E(x)port

u: R(u)n script

t: Proper(t)ies

q: (Q)uit

Changed: from "save all files" to "save everything" because:
- not enough unique shortcut letters,
- projects and workspaces are not edited like "files",
- it's even better to save all files, projects and workspace in one go.

Deleted: "close all", which is redundant with close file, close project and close workspace. Alternatively, use "h: close everyt(h)ing" to match "save everything".

Well, hopefully someone will find this useful. I think this is the right place to post it since the intent was to help developpers polish up the Code::Blocks menus.

Code Select Expand


//------------------------------------------------------------------------------
// AlphaKey
//
// This program takes as input a list of "titles" that may be used in menus
// or dialog boxes and attempts to identify a unique alphabetic key from 'a'
// to 'z' which can be used to uniquely identify each title. The purpose is
// to select the best letter as a shortcut to the title in question (which
// would be underlined in a Windows application).
//
// Obviously, there is an input limit of 26 titles. The program will fail to
// find a unique key for each title if there are less unique letters used in
// the list than there are titles. Even if there are enough unique letters,
// the search may still fail if they are not distributed so that each title
// indeed has at least one letter that can be uniquely its own. For example
// this list: "aa", "bb", "ab" and "xy" holds 4 unique letters in 4 titles
// yet does not have unique keys for each of the first 3 items.
//
// The search is exhaustive, all possible combinations are examined, which
// can take a while for larger title sets. The search is fast if a solution
// exists and the titles are already listed in the "most desirable" order,
// that is items that have a key early on in the title appear first. If the
// first title's only possible key is the last letter of the word, then all
// unsuccessful possibilities must first be ruled out starting at the first
// letter. Avoiding this by re-ordering the input prevents such worst-case
// scenarios.
//
// Despite an occasional worst-case run, an exhaustive search is good to
// provide the "best order" for keys since the first successful letter
// appears early in early titles for a fairly natural key selection.
//
// Tips & Tricks
//
// Reserve letter(s) that must be assigned to a specific titles by entering
// these single letters first followed by a '|' character. All letters after
// this will be ignored in the search. For efficiency, enter these first in
// the input list. Example: enter "s|Save" and "a|Save As" to reserve these
// letter keys for these titles. A few favorite letters can also be specified
// with "saf|Save file" and "av|Save As" for example.
//
// If a search takes too long, look for the presence of a unique letter in all
// titles (print the table to see). Reserve the unique letter for this title
// (as above), then repeat the search.
//
// Moving titles around a little can speed up the search process and/or
// produce alternate selections. Vary the input order.
//
//------------------------------------------------------------------------------

#include <cctype>
#include <cstdio>
#include <cstring>

//------------------------------------------------------------------------------
// Work data.

char titles[27][100];       // List of titles.
int  titleCount;            // Input count.
char streamlined[26][27];   // Unique lowercase letters in each title.
char keys[26];              // Resulting letter key for each title.
bool used[26];              // Work flags for letters already used.

//------------------------------------------------------------------------------

/* Read a line "cleanly" and return its length. */
int strget(char *destination, int bufferSize, FILE *inStream) {
    char *str = destination;
    int c;
    // Skip leading whitespace.
    do {
        c = getc(inStream);
    } while (c != EOF && c != '\n' && isspace(c));
    // Read until the end or until the buffer is full.
    while (c != EOF && c != '\n' && bufferSize > 1) {
        *str++ = (char) c; bufferSize--;
        c = getc(inStream);
    }
    // Terminate and trim trailing whitespace.
    do {
        *str-- = '\0';
    } while (str >= destination && isspace(*str));
    // Clear out the input buffer.
    while (c != EOF && c != '\n') {
        c = getc(inStream);
    }
    // Return the input length.
    return str - destination + 1;
}

// Read a list of titles, one title per line. Return true if a list of up
// to 26 titles was provided. If the list is empty or exceeds 26, issue an
// error message and return false.
bool inputTitles() {
    titleCount = 0;
    while (strget(titles[titleCount], 100, stdin)) {
        if (++titleCount > 26) {
            fprintf(stderr, "Error: More than 26 titles.\n");
            return false;
        }
    }
    if (titleCount == 0) {
        fprintf(stderr, "Error: No data.\n");
        return false;
    }
    return true;
}

// For efficient processing, streamline a title by copying into 'dst' only
// unique lowercase letters from 'title'. Preserve ordering of used letters.
void streamline(char* dst, const char* title) {
    char const * DST = dst;
    while (*title && (*title != '|')) {    // Ignore what follows '|'
        if (isalpha(*title)) {
            char letter = tolower(*title);

            const char* cp = DST;           // Is this letter already in dst?
            while (cp < dst && letter != *cp) {
                ++cp;
            }

            if (cp == dst) {                // No prior duplicate in 'dst':
                *dst = letter;              //    store this unique letter
                ++dst;                      //    and advance position.
            }
        }
        ++title;                            // Next title character.
    }
    *dst = '\0';                            // End the letter array as a string.
}

// Set streamlined versions of all titles.
void streamlineAll() {
    for (int i = 0; i < titleCount; ++i) {
        streamline(streamlined[i], titles[i]);
    }
}

// Clear all 'used' flags.
void clearUsed() {
    for (int i = 0; i < 26; ++i) {
        used[i] = false;
    }
}

// Mark all letters used in the (streamlined) title at index 'i'.
void markUsedIn(int i) {
    for (int j = 0; streamlined[i][j]; ++j) {
        used[streamlined[i][j] - 'a'] = true;
    }
}

// Mark all letters used in all titles.
void markUsedInAll() {
    clearUsed();
    for (int i = 0; i < titleCount; ++i) {
        markUsedIn(i);
    }
}

// Set all unique letters used and return their count.
int uniqueLetters() {
    int count = 0;
    markUsedInAll();
    for (int i = 0; i < 26; ++i) {
        if (used[i]) ++count;
    }
    return count;
}

//------------------------------------------------------------------------------
// Main recursive search function.

bool findUniqueAlpha(int titleIndex = 0) {
    // If the title index has passed the end then the search was successful.
    if (titleIndex == titleCount) {
        return true;
    }
    // Try using each letter in turn as a key for this title.
    for (char* letter = streamlined[titleIndex]; *letter; ++letter) {
        // Progress report.
        if (titleIndex < 4) {
            printf("Searching...");
            // Show nesting level visually using spaces.
            for (int i = 0; i < titleIndex; ++i) {
                printf(" ");
            }
            printf("%c\n", *letter);
        }
        // Try this letter as key if it is not already in use.
        int index = *letter - 'a';
        if (!used[index]) {
            used[index] = true;
            if (findUniqueAlpha(titleIndex + 1)) {  // Recurse with next title.
                keys[titleIndex] = *letter;         // Success, store the key.
                return true;                        // Leave the flag set.
            }
            used[index] = false;                    // Clear flag, continue.
        }
    }
    // No solution found for this title given all letters already used as key.
    return false;
}

//------------------------------------------------------------------------------
// Reporting functions

// Show letters either used or not used.
void showUsed(bool usage, const char* header = 0) {
    if (header) {
        printf(header);
    }
    for (int i = 0; i < 26; ++i) {
        if (used[i] == usage) {
            printf(" %c", char('a' + i));
        }
    }
}

// Show a table of letters used by each title.
void showTable() {
    for (int i = 0; i < titleCount; ++i) {
        // Mark each letter used by this title alone.
        clearUsed();
        markUsedIn(i);
        // Show 26 markers, either a used letter or a delimiting character.
        for (int j = 0; j < 26; ++j) {
            printf("%c", used[j] ? char('a' + j) : '.');
        }
        // End the line with the corresponding title.
        printf("  %s\n", titles[i]);
    }
    printf("\n");
}

// Show all keys and their corresponding titles.
void showKeys() {
    for (int i = 0; i < titleCount; ++i) {
        printf("%c: %s\n", keys[i], titles[i]);
    }
}

// Show letters used in titles but not in keys.
void showAvailableKeys(const char* header = 0) {
    // Check each used letter against the set of keys.
    markUsedInAll();
    int count = 0;
    for (int i = 0; i < 26; ++i) {
        if (used[i]) {
            char letter = char('a' + i);
            // Clear the flag is this letter is used in a key.
            for (int j = 0; j < titleCount; ++j) {
                if (keys[j] == letter) {
                    used[i] = false;
                    break;
                }
            }
            // Is this letter still available for use as a key?
            if (used[i]) {
                ++count;
            }
        }
    }
    // Report on available letters only if there are any.
    if (count) {
        showUsed(true, header);
    }
}

int showHelp() {
    printf("\n"
           "AlphaKey requires input of one title per line, each one up to\n"
           "99 characters in length. Input an empty line (press Enter alone)\n"
           "to end data entry.\n"
           "\n"
           "Use \"AlphaKey -table\" to just see a table of letters used by\n"
           "each title provided as input.\n"
           "\n"
           "Use character | to force the selection of any letter before it\n"
           "as key for the title. Letters after | are ignored. Example: use\n"
           "\"fn|Family Name\" to force selection of either f or n as key.\n");
    return 0;
}

//------------------------------------------------------------------------------

int main(int argc, char* argv[]) {
    // Check command line arguments.
    bool wantTable = (argc == 2)
                  && (*argv[1] == '-' || *argv[1] == '/')
                  && (strcmp(argv[1] + 1, "table") == 0);
    if (argc != 1 && !wantTable) {
        return showHelp();
    }
    // Process the input, if any.
    if (inputTitles()) {
        // All accessory functions use array 'streamlined' instead of 'titles'.
        streamlineAll();

        if (wantTable) {
            showTable();
        }
        else {
            int uniqueCount = uniqueLetters();
            if (uniqueCount < titleCount) {
                // Error situation, not enough unique letters.
                showTable();
                printf("\nOnly %d unique letters in %d different titles.\n",
                       uniqueCount, titleCount);
                showUsed(false, "\nUnused letters:");
            }
            else {
                // Start searching (clear 'used' first).
                clearUsed();
                if (findUniqueAlpha()) {
                    printf("\n\n\n");
                    showTable();
                    showKeys();
                    showAvailableKeys("\nAvailable keys:");
                    if (titleCount < 26) {
                        markUsedInAll();
                        showUsed(false, "\nUnused letters:");
                    }
                }
                else {
                    showTable();
                    printf("\nNo solution found.\n");
                }
            }
            printf("\n");
        }
    }
    return 0;
}