base.cc

c++的guiQt做的开发

/** @file
 Base - base class handling command line commands
*/

#include "base.h"
#include <assert.h>
#include "util.h"

namespace gui {

using namespace std;

/** Structure holding command parameters */
class CommandParams {
public:
 /** Link back to base, needed for querying enum types */
 Base *base;

 /** Constructor */
 CommandParams(Base *b) {
  base=b;
  maxParamLength=1;
  extraHelp="";
 }

 /**
  Add new parameter for function
  @param type Type of parameter
  @param name Name of parameter
  @param description Human readable description of parameter
  @param caption Human readable name iof parameter (to be used in dialogs, etc ...)
  @param defValue Default value used when parameter not specified
 */
 void add(const QString &type,const QString &name,const QString &description,const QString &caption,const QString &defValue=QString::null) {
  types+=type;
  names+=name;
  descriptions+=description;
  captions+=caption;
  defValues+=defValue;
  maxParamLength=MAX(maxParamLength,name.length());
 }

 /** Return list of parameter names enclosed in brackets */
 QString paramList() {
  QString help="";
  for(int i=0;i<types.size();i++) {
   help+=" ["+names[i]+"]";
  }
  return help;
 }

 /** Return html formatted help for parameter */
 QString htmlHelpText() {
  QString help=QObject::tr("Parameters")+":<br>";
  for(int i=0;i<types.size();i++) {
   QString namePad=names[i];
   for (int q=names[i].length();q<maxParamLength;q++) {
    namePad+="&nbsp;";
   }
   help+="<code>&nbsp;&nbsp;<b>"+namePad+"</b></code> "+descriptions[i];
   bool openedBracket=false;
   if (base->isEnumType(types[i])) { // An enum type
    help+=" ("+base->enumInfo(types[i]);
    openedBracket=true;
   }
   if (!defValues[i].isNull()) {
    if (openedBracket) help+=", "; else help+=" (";
    help+=QObject::tr("default is %1").arg(defValues[i]);
    openedBracket=true;
   }
   if (openedBracket) help+=")";
   help+="<br>";
  }
  help+=extraHelp;
  return help;
 }

 /**
  Return number of mandatory parameters
 */
 int needParams() {
  int p=defValues.size();
  while (p && !defValues[p-1].isNull()) p--;
  return p;
 }

 /**
  Given list of parameters, return map with named parameters assigned
  For unspecified parameters, default value will be given
  @param params Parameter array
 */
 SMap toMap(const QStringList &params) {
  SMap s;
  int nParam=params.size();
  for(int i=0;i<types.size();i++) {
   if (i>=nParam) {
    s[names[i]]=defValues[i];
   } else {
    s[names[i]]=params[i];
   }
  }
  return s;
 }

 /**
  Return list of parameter names
 */
 const QStringList& paramNames() {
  return names;
 }

 /**
  Return list of parameter types
 */
 const QStringList& paramTypes() {
  return types;
 }

 /**
  Return list of parameter types
 */
 const QStringList& paramHelps() {
  return descriptions;
 }

 /**
  Return list of parameter captions
 */
 const QStringList& paramCaptions() {
  return captions;
 }

 /**
  Return extra help text
 */
 const QString &helpText() {
  return extraHelp;
 }

 /**
  Sets extra help text to be printed after last parameter
  @param txt New helptext
 */
 void setExtraHelp(const QString &txt) {
  extraHelp=txt;
 }

private:
 /** number of character in name of longest parameter (always at least 1) */
 int maxParamLength;
 /** extra help text to be printed after last parameter */
 QString extraHelp;
 /** Types of parameters */
 QStringList types;
 /** Names of parameters */
 QStringList names;
 /** Captions of parameters */
 QStringList captions;
 /** Descriptions of parameters */
 QStringList descriptions;
 /** Default parameter values */
 QStringList defValues;
};

/** default constructor */
Base::Base() {
 commandsSorted=true;
 maxCommandLength=1;
invokedFunction=QString::null;
}

/** Unregister all functions */
void Base::unregisterAll() {
 /** Delete all command parameters */
 QMapIterator<QString,CommandParams*> i(func_param);
 while (i.hasNext()) {
  i.next();
  assert(i.value());
  delete i.value();
 }
 func.clear();
 func_p.clear();
 func_param.clear();
 commands.clear();
 maxCommandLength=1;
 globalParams.clear();
 helpTexts.clear();
}

/** default destructor */
Base::~Base() {
 unregisterAll();
}

/**
 Specify function parameter - append to list of already existing parameters
 @param funcName Name of function
 @param type Type of parameter
 @param name Name of parameter
 @param description Human readable description of parameter
 @param caption Human-readable name of parameter. If not defined, equals to description
 @param defValue Default value used when parameter not specified
*/
void Base::addFuncParam(const QString &funcName,const QString &type, const QString &name,const QString &description,const QString &caption/*=QString::null*/,const QString &defValue/*=QString::null*/) {
 if (!func_param[funcName]) func_param[funcName]=new CommandParams(this);
 func_param[funcName]->add(type,name,description,(caption.isNull()?description:caption),defValue); 
}

/**
 Add general help common for all parameters.
 Will be shown after parameter list
 @param funcName name of function
 @param helpText Help text for parameters
*/
void Base::addFuncParamHelp(const QString &funcName,const QString &helpText) {
 if (!func_param[funcName]) func_param[funcName]=new CommandParams(this);
 func_param[funcName]->setExtraHelp(helpText);
}

/**
 Register function without parameters to be invoked on specified command
 @param name Name of the function
 @param fn Pointer to class function
 @param helpText help text for this command
 */
void Base::addFunc(const QString &name,CommandFunc fn,const QString &helpText) {
 assert(!func.contains(name));
 assert(!func_p.contains(name));
 func[name]=fn;
 helpTexts[name]=helpText;
 maxCommandLength=MAX(maxCommandLength,name.length());
 commands+=name;
 commandsSorted=false;
}

/**
 Register function with parameters to be invoked on specified command
 @param name Name of the function
 @param fn Pointer to class function
 @param helpText help text for this command
 */
void Base::addFunc(const QString &name,CommandFuncParam fn,const QString &helpText) {
 assert(!func.contains(name));
 assert(!func_p.contains(name));
 func_p[name]=fn;
 helpTexts[name]=helpText;
 maxCommandLength=MAX(maxCommandLength,name.length());
 commands+=name;
 commandsSorted=false;
}

/**
 Return string info for given enum or empty string if not an enum value.
 For use with commandline help system
 @param id Identifier of the enum
 */
QString Base::enumInfo(const QString &id) {
 if (!enumKeyList.count(id)) return "";
 QStringList values=enumValueList[id];
 QStringList keys=enumKeyList[id];
 QString ret="";
 for (int i=0;i<values.count();i++) {
  if (i>0) ret+=", ";
  ret+=keys[i]+" = "+values[i];
 }
 return ret;
}

/**
 Check if given type is an enum type. Return true if enum type, false if not
 @param name Name of type
*/
bool Base::isEnumType(const QString &name) {
 return (enumKeyList.count(name)>0); 
}

/**
 Return keys for given enum type
 @param name Name of type
*/
QStringList Base::enumKeys(const QString &name) {
 return enumKeyList.value(name);
}

/**
 Return values for given enum type
 @param name Name of type
*/
QStringList Base::enumValues(const QString &name) {
 return enumValueList.value(name);
}

/**
 Register enum value for use with dialogs and parameter help
 @param id Identifier of the enum
 @param keys Keys of enum elements
 @param values Values of enum elements
 */
void Base::registerEnum(const QString &id,const QStringList &values,const QStringList &keys) {
 enumKeyList[id]=keys;
 enumValueList[id]=values;
}

/**
 Register enum value for use with dialogs and parameter help - overloaded function
 @param id Identifier of the enum
 @param start Keys are numbered from number start, counting up
 @param values Values of enum elements
 */
void Base::registerEnum(const QString &id,const QStringList &values,int start/*=0*/) {
 QStringList keys;
 for (int i=0;i<values.count();i++) {
  keys.append(QString::number(i+start));
 }
 registerEnum(id,values,keys);
}

/**
 Register enum value for use with dialogs and parameter help - overloaded function
 @param id Identifier of the enum
 @param start Keys are numbered from number start, counting up
 @param values Values of enum elements. Values are separated in string by '|' character.
 */
void Base::registerEnum(const QString &id,const QString &values,int start/*=0*/) {
 registerEnum(id,values.split('|'),start);
}

/**
 Register enum value for use with dialogs and parameter help - overloaded function
 @param id Identifier of the enum
 @param start Keys of enum elements. Keys are separated in string by '|' character.
 @param values Values of enum elements. Values are separated in string by '|' character.
 */
void Base::registerEnum(const QString &id,const QString &values,const QString &keys) {
 registerEnum(id,values.split('|'),keys.split('|'));
}

/**
 Return parameter as float, given its name
 @param name name of the parameter
*/
float Base::getParamFloat(const QString &name) {
 return getParam(name).toFloat();
}

/**
 Return parameter as double, given its name
 @param name name of the parameter
*/
double Base::getParamDouble(const QString &name) {
 return getParam(name).toDouble();
}

/**
 Return parameter as int, given its name
 @param name name of the parameter
*/
int Base::getParamInt(const QString &name) {
 return getParam(name).toInt();
}

/**
 Return parameter as scale (int), given its name
 Format can be either plain int, or int suffixed with % - scale to X percent
 @param name name of the parameter
*/
int Base::getParamScaleInt(const QString &name) {
 QString p=getParam(name);
 QRegExp r("^\\+?([0-9]+)%$");
 int pos=r.indexIn(p);
 if (pos>-1) {
  return -r.cap(1).toInt();
 }
 return p.toInt();
}

/**
 Return parameter as scale (double), given its name
 Format can be either plain double, or double suffixed with % - scale to X percent
 @param name name of the parameter
*/
double Base::getParamScaleDouble(const QString &name) {
 QString p=getParam(name);
 QRegExp r("^([0-9.eE+-]+)%$");
 int pos=r.indexIn(p);
 if (pos>-1) {
  return -r.cap(1).toDouble();
 }
 return p.toDouble();
}

/**
 Return parameter as string, given its name
 @param name name of the parameter
*/
QString Base::getParam(const QString &name) {
 return globalParams[name];
}

/**
 Return help text for one command in HTML format.
 @param name Name of command
 @param longText if true, return full help text of command, otherwise one-line command description
*/
QString Base::helpTextHtml(const QString &name, bool longText/*=false*/) {
 QString text=helpTexts.value(name);
 if (longText) {
  //Long text
  QString params="";
  if (func_param.contains(name)) {
   // Add parameters in format " [x] [y] "
   params=QString(" ")+(func_param[name]->paramList());
   // Add help for parameters
   text+=QString("<br>")+func_param[name]->htmlHelpText();
  }
  return QString("<b><code>")+name+"</code></b>"+params+"<br>"+text;
 } else {
  //Short one-liner
  QString namePad=name;
  for (int i=name.length();i<maxCommandLength;i++) {
   namePad+="&nbsp;";
  }
  return QString("<code>")+namePad+"\t</code> "+text;
 }
}

/**
 If inside an invoked function, this will return its name.
 Otherwise it will return null string.
*/
QString Base::currentFunction() {
 return invokedFunction;
}

/**
 Run command with given parameters
 @param context Context of command - which object will be used as "this" for invoked functions
 @param cmd command name
 @param params Array with parameters
*/
bool Base::invokeCommand(MainWindow *context,const QString &cmd, const QStringList &params) {
 if (func.contains(cmd)) {
  QString last=invokedFunction;
  invokedFunction=cmd;
  (context->*(func[cmd]))();
  invokedFunction=last;
  return true;
 }
 if (func_p.contains(cmd)) {
  QString last=invokedFunction;
  invokedFunction=cmd;
  (context->*(func_p[cmd]))(params);
  invokedFunction=last;
  return true;
 }
 return false;
}

/**
 Return minimal number of parameters required by specified function
 @param funcName name of function
*/
int Base::minParamCount(const QString &funcName) {
 CommandParams *p=func_param[funcName];
 assert(p);
 if (!p) return 0;
 return p->needParams();
}

/**
 Convert array with parameters to named parameters, for specified function.
 Store the map in globalParams
 @param funcName name of function
 @param param Parameter array
 */
void Base::paramsToMap(const QString &funcName,const QStringList &param) {
 CommandParams *p=func_param[funcName];
 assert(p);
 if (!p) globalParams.clear();
 globalParams=p->toMap(param);
}

/**
 Convert array with parameters to named parameters, for specified function.
 Return the map
 @param funcName name of function
 @param param Parameter array
 */
SMap Base::paramMap(const QString &funcName,const QStringList &param) {
 CommandParams *p=func_param[funcName];
 if (!p) return SMap();
 return p->toMap(param);
}

/**
 Return list of parameter names for specified function.
 @param funcName name of function
*/
QStringList Base::paramNames(const QString &funcName) {
 CommandParams *p=func_param[funcName];
 if (!p) return QStringList();
 return p->paramNames();
}

/**
 Return list of parameter types for specified function.
 @param funcName name of function
*/
QStringList Base::paramTypes(const QString &funcName) {
 CommandParams *p=func_param[funcName];
 if (!p) return QStringList();
 return p->paramTypes();
}

/**
 Return list of parameter helps for specified function.
 @param funcName name of function
*/
QStringList Base::paramHelps(const QString &funcName) {
 CommandParams *p=func_param[funcName];
 if (!p) return QStringList();
 return p->paramHelps();
}

/**
 Return list of parameter captions for specified function.
 @param funcName name of function
*/
QStringList Base::paramCaptions(const QString &funcName) {
 CommandParams *p=func_param[funcName];
 if (!p) return QStringList();
 return p->paramCaptions();
}

/**
 Return helptext printed before parameter list
 @param funcName name of function
*/
QString Base::beforeParamHelp(const QString &funcName) {
 return helpTexts.value(funcName);
}

/**
 Return helptext printed after parameter list
 @param funcName name of function
*/
QString Base::afterParamHelp(const QString &funcName) {
 CommandParams *p=func_param[funcName];
 if (!p) return QString::null;
 return p->helpText();
}

/**
 Check if given command name is a valid function
 @param funcName name of function
 */
bool Base::validCommand(const QString &funcName) {
 return helpTexts.contains(funcName);
}

/**
 Return lisrt of commands, sorted alphabetically
*/
const QStringList& Base::commandList() {
 if (!commandsSorted) {
  commands.sort();
  commandsSorted=true;
 }
 return commands;
}

} //namespace base