kaccelgen.h

Go to the documentation of this file.

/*  This file is part of the KDE project
    Copyright (C) 2000 Keunwoo Lee <klee@cs.washington.edu>

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB. If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA  02110-1301, USA.
*/

#ifndef KACCELGEN_H
#define KACCELGEN_H

#include <kdeui_export.h>

#include <QtCore/QMap>
#include <QtCore/QString>
#include <QtCore/QStringList>

namespace KAccelGen
{

// HELPERS

template <class Iter>
class Deref
{
public:
    static QString deref(Iter i) { return *i; }
};

template <class Iter>
class Deref_Key
{
public:
    static QString deref(Iter i) { return i.key(); }
};

inline bool
isLegalAccelerator(const QString& str, int index)
{
    return index >= 0 && index < str.length()
        && str[index].isLetterOrNumber();
}

template <class Iter, class Deref>
inline void
loadPredefined(Iter begin, Iter end, QMap<QChar,bool>& keys)
{
    for (Iter i = begin; i != end; ++i) {
        QString item = Deref::deref(i);
        int user_ampersand = item.indexOf(QLatin1Char('&'));
        if( user_ampersand >= 0 ) {
            // Sanity check.  Note that we don't try to find an
            // accelerator if the user shoots him/herself in the foot
            // by adding a bad '&'.
            if( isLegalAccelerator(item, user_ampersand+1) ) {
                keys.insert(item[user_ampersand+1], true);
            }
        }
    }
}


// ///////////////////////////////////////////////////////////////////
// MAIN USER FUNCTIONS


template <class Iter, class Iter_Deref >
void
generate(Iter begin, Iter end, QStringList& target)
{
    // Will keep track of used accelerator chars
    QMap<QChar,bool> used_accels;

    // Prepass to detect manually user-coded accelerators
    loadPredefined<Iter,Iter_Deref>(begin, end, used_accels);

    // Main pass
    for (Iter i = begin; i != end; ++i) {
        QString item = Iter_Deref::deref(i);

        // Attempt to find a good accelerator, but only if the user
        // has not manually hardcoded one.
        int user_ampersand = item.indexOf(QLatin1Char('&'));
        if( user_ampersand < 0 || item[user_ampersand+1] == QLatin1Char('&')) {
            bool found = false;
            int j;

            // Check word-starting letters first.
            for( j=0; j < item.length(); ++j ) {
                if( isLegalAccelerator(item, j)
                    && !used_accels.contains(item[j])
                    && (0 == j || (j > 0 && item[j-1].isSpace())) ) {
                    found = true;
                    break;
                }
            }

            if( !found ) {
                // No word-starting letter; search for any letter.
                for( j=0; j < item.length(); ++j ) {
                    if( isLegalAccelerator(item, j)
                        && !used_accels.contains(item[j]) ) {
                        found = true;
                        break;
                    }
                }
            }

            if( found ) {
                // Both upper and lower case marked as used
                used_accels.insert(item[j].toUpper(),true);
                used_accels.insert(item[j].toLower(),true);
                item.insert(j,QLatin1Char('&'));
            }
        }

        target.append( item );
    }
}

template <class Iter>
inline void
generateFromKeys(Iter begin, Iter end, QStringList& target)
{
    generate< Iter, Deref_Key<Iter> >(begin, end, target);
}


inline void
generate(const QStringList& source, QStringList& target)
{
    generate<QStringList::ConstIterator, Deref<QStringList::ConstIterator> >(source.begin(), source.end(), target);
}

template <class Key>
inline void
generateFromValues(const QMap<Key,QString>& source, QStringList& target)
{
    generate<typename QMap<Key,QString>::ConstIterator, Deref_Key<typename QMap<Key,QString>::ConstIterator> >(source.begin(), source.end(), target);
}

template <class Data>
inline void
generateFromKeys(const QMap<QString,Data>& source, QStringList& target)
{
    generateFromKeys(source.begin(), source.end(), target);
}


} // end namespace KAccelGen

#endif