bool ConfigurationManager::setOptionValue(const QString &name, const QString &value)
{
if ( !m_options.contains(name) )
return false;
const QString oldValue = optionValue(name).toString();
m_options[name].setValue(value);
if ( optionValue(name) == oldValue )
return false;
AppConfig().setOption(name, m_options[name].value());
emit configurationChanged();
return true;
}
bool VRPNTrackerAxis::parseTransform(const std::string& axis,
Matrix3f& transformOut )
{
static const boost::regex k_axis_re("^([xyzXYZ])([xyzXYZ])([xyzXYZ])$");
static std::map<char,Vector3f> k_axisMap =
boost::assign::map_list_of ('X', Vector3f::UNIT_X)
('Y', Vector3f::UNIT_Y)
('Z', Vector3f::UNIT_Z);
boost::smatch optResult;
if (boost::regex_search(axis, optResult, k_axis_re))
{
for (size_t r = 0; r < transformOut.ROWS; ++r)
{
std::string optionValue(optResult.str(r+1));
LBASSERT(optionValue.size() == 1);
const char ax = optionValue[0];
const float scale = std::isupper(ax) ? 1.f : -1.f;
const Vector3f v = scale * k_axisMap[std::toupper(ax)];
transformOut.set_row(r, v);
}
}
else
return false;
return true;
}
int
main(int argc, char *argv[])
{
FILE *output = stderr;
char temp[80];
const char *separate_str = DEFAULT_SEPARATE_STR;
bool esc_pressed = FALSE;
int offset = 1;
int offset_add;
int retval = DLG_EXIT_OK;
int done;
int j;
eOptions code;
const Mode *modePtr;
#ifndef HAVE_COLOR
int use_shadow = FALSE; /* ignore corresponding option */
#endif
#if defined(ENABLE_NLS)
/* initialize locale support */
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#elif defined(HAVE_SETLOCALE)
(void) setlocale(LC_ALL, "");
#endif
program = argv[0];
dialog_vars.output = output;
if (argc == 2) { /* if we don't want clear screen */
switch (lookupOption(argv[1], 7)) {
case o_print_maxsize:
(void) initscr();
fprintf(output, "MaxSize: %d, %d\n", SLINES, SCOLS);
end_dialog();
break;
case o_print_version:
fprintf(output, "Version: %s\n", VERSION);
break;
default:
case o_help:
Help();
break;
}
return 0;
}
if (argc < 2) {
Help();
}
init_dialog();
#ifdef HAVE_RC_FILE
if (!strcmp(argv[1], "--create-rc")) {
if (argc != 3) {
sprintf(temp, "Expected a filename for %s", argv[1]);
Usage(temp);
}
end_dialog();
create_rc(argv[2]);
return 0;
}
#endif
while (offset < argc && !esc_pressed) {
memset(&dialog_vars, 0, sizeof(dialog_vars));
dialog_vars.aspect_ratio = DEFAULT_ASPECT_RATIO;
dialog_vars.tab_len = TAB_LEN;
dialog_vars.output = output;
done = FALSE;
while (offset < argc && !done) { /* Common options */
switch (lookupOption(argv[offset], 1)) {
case o_title:
dialog_vars.title = optionString(argv, &offset);
break;
case o_backtitle:
dialog_vars.backtitle = optionString(argv, &offset);
break;
case o_separate_widget:
separate_str = optionString(argv, &offset);
break;
case o_separate_output:
dialog_vars.separate_output = TRUE;
break;
case o_cr_wrap:
dialog_vars.cr_wrap = TRUE;
break;
case o_no_kill:
dialog_vars.cant_kill = TRUE;
break;
case o_nocancel:
dialog_vars.nocancel = TRUE;
break;
case o_size_err:
dialog_vars.size_err = TRUE;
break;
case o_beep:
dialog_vars.beep_signal = TRUE;
break;
case o_beep_after:
dialog_vars.beep_after_signal = TRUE;
break;
case o_shadow:
use_shadow = TRUE;
break;
case o_defaultno:
defaultno = TRUE;
break;
case o_default_item:
dialog_vars.default_item = optionString(argv, &offset);
break;
case o_item_help:
dialog_vars.item_help = TRUE;
break;
case o_no_shadow:
use_shadow = FALSE;
break;
case o_print_size:
dialog_vars.print_siz = TRUE;
break;
case o_print_maxsize:
fprintf(output, "MaxSize: %d, %d\n", SLINES, SCOLS);
break;
case o_print_version:
fprintf(output, "Version: %s\n", VERSION);
break;
case o_tab_correct:
dialog_vars.tab_correct = TRUE;
break;
case o_sleep:
dialog_vars.sleep_secs = optionValue(argv, &offset);
break;
case o_stderr:
dialog_vars.output = output = stderr;
break;
case o_stdout:
dialog_vars.output = output = stdout;
break;
case o_tab_len:
dialog_vars.tab_len = optionValue(argv, &offset);
break;
case o_aspect:
dialog_vars.aspect_ratio = optionValue(argv, &offset);
break;
case o_begin:
dialog_vars.begin_set = TRUE;
dialog_vars.begin_y = optionValue(argv, &offset);
dialog_vars.begin_x = optionValue(argv, &offset);
break;
case o_clear:
if (argc == 2) { /* we only want to clear the screen */
killall_bg(&retval);
(void) refresh();
end_dialog();
return 0;
}
dialog_vars.dlg_clear_screen = TRUE;
break;
case o_noitem:
case o_fullbutton:
/* ignore */
break;
default: /* no more common options */
done = TRUE;
break;
}
if (!done)
offset++;
}
for (j = 1; j < argc; j++) {
if (strncmp(argv[j - 1], "--", 2) == 0 &&
strcmp(argv[j - 1], "--backtitle") != 0 &&
strcmp(argv[j - 1], "--title") != 0) {
dlg_trim_string(argv[j]);
}
}
if (argv[offset] == NULL) {
Usage("Expected a box option");
}
if (lookupOption(argv[offset], 2) != o_checklist
&& dialog_vars.separate_output) {
sprintf(temp, "Expected --checklist, not %.20s", argv[offset]);
Usage(temp);
}
if (dialog_vars.aspect_ratio == 0)
dialog_vars.aspect_ratio = DEFAULT_ASPECT_RATIO;
put_backtitle();
/* use a table to look for the requested mode, to avoid code duplication */
modePtr = 0;
if ((code = lookupOption(argv[offset], 2)) != o_unknown)
modePtr = lookupMode(code);
if (modePtr == 0) {
sprintf(temp, "Unknown option %.20s", argv[offset]);
Usage(temp);
}
if (arg_rest(&argv[offset]) < modePtr->argmin) {
sprintf(temp, "Expected at least %d tokens for %.20s, have %d",
modePtr->argmin - 1, argv[offset],
arg_rest(&argv[offset]) - 1);
Usage(temp);
}
if (modePtr->argmax && arg_rest(&argv[offset]) > modePtr->argmax) {
sprintf(temp,
"Expected no more than %d tokens for %.20s, have %d",
modePtr->argmax - 1, argv[offset],
arg_rest(&argv[offset]) - 1);
Usage(temp);
}
retval = (*(modePtr->jumper)) (dialog_vars.title, argv + offset, &offset_add);
offset += offset_add;
if (retval == DLG_EXIT_ESC) {
esc_pressed = TRUE;
} else {
if (dialog_vars.beep_after_signal)
(void) beep();
if (dialog_vars.sleep_secs)
(void) napms(dialog_vars.sleep_secs * 1000);
if (offset < argc) {
switch (lookupOption(argv[offset], 7)) {
case o_and_widget:
(void) fputs(separate_str, output);
offset++;
break;
case o_unknown:
sprintf(temp, "Expected --and-widget, not %.20s",
argv[offset]);
Usage(temp);
break;
default:
/* if we got a cancel, etc., stop chaining */
if (retval != DLG_EXIT_OK)
esc_pressed = TRUE;
else
dialog_vars.dlg_clear_screen = TRUE;
break;
}
}
if (dialog_vars.dlg_clear_screen)
dialog_clear();
}
}
killall_bg(&retval);
(void) refresh();
end_dialog();
return retval; /* assume this is the same as exit(retval) */
}
bool Quassel::init() {
if(_initialized)
return true; // allow multiple invocations because of MonolithicApplication
if (_handleCrashes) {
// we have crashhandler for win32 and unix (based on execinfo).
#if defined(Q_OS_WIN32) || defined(HAVE_EXECINFO)
# ifndef Q_OS_WIN32
// we only handle crashes ourselves if coredumps are disabled
struct rlimit *limit = (rlimit *) malloc(sizeof(struct rlimit));
int rc = getrlimit(RLIMIT_CORE, limit);
if(rc == -1 || !((long)limit->rlim_cur > 0 || limit->rlim_cur == RLIM_INFINITY)) {
# endif /* Q_OS_WIN32 */
signal(SIGABRT, handleSignal);
signal(SIGSEGV, handleSignal);
# ifndef Q_OS_WIN32
signal(SIGBUS, handleSignal);
}
free(limit);
# endif /* Q_OS_WIN32 */
#endif /* Q_OS_WIN32 || HAVE_EXECINFO */
}
_initialized = true;
qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
registerMetaTypes();
Network::setDefaultCodecForServer("ISO-8859-1");
Network::setDefaultCodecForEncoding("UTF-8");
Network::setDefaultCodecForDecoding("ISO-8859-15");
if(isOptionSet("help")) {
cliParser()->usage();
return false;
}
if(isOptionSet("version")) {
std::cout << qPrintable("Quassel IRC: " + Quassel::buildInfo().plainVersionString) << std::endl;
return false;
}
DEBUG = isOptionSet("debug");
// set up logging
if(Quassel::runMode() != Quassel::ClientOnly) {
if(isOptionSet("loglevel")) {
QString level = optionValue("loglevel");
if(level == "Debug") _logLevel = DebugLevel;
else if(level == "Info") _logLevel = InfoLevel;
else if(level == "Warning") _logLevel= WarningLevel;
else if(level == "Error") _logLevel = ErrorLevel;
}
QString logfilename = optionValue("logfile");
if(!logfilename.isEmpty()) {
_logFile = new QFile(logfilename);
if(!_logFile->open(QIODevice::Append | QIODevice::Text)) {
qWarning() << "Could not open log file" << logfilename << ":" << _logFile->errorString();
_logFile->deleteLater();
_logFile = 0;
}
}
#ifdef HAVE_SYSLOG
_logToSyslog = isOptionSet("syslog");
#endif
}
return true;
}
// Function definitions.
// -----------------------------------------------------------------
void mexFunction (int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
try {
// Check to see if we have the correct number of input and output
// arguments.
if (nrhs < minNumInputArgs)
throw MatlabException("Incorrect number of input arguments");
// Get the starting point for the variables. This is specified in
// the first input argument. The variables must be either a single
// matrix or a cell array of matrices.
int k = 0; // The index of the current input argument.
ArrayOfMatrices x0(prhs[k++]);
// Create the output, which stores the solution obtained from
// running IPOPT. There should be as many output arguments as cell
// entries in X.
if (nlhs != x0.length())
throw MatlabException("Incorrect number of output arguments");
ArrayOfMatrices x(plhs,x0);
// Load the lower and upper bounds on the variables as
// ArrayOfMatrices objects. They should have the same structure as
// the ArrayOfMatrices object "x".
ArrayOfMatrices lb(prhs[k++]);
ArrayOfMatrices ub(prhs[k++]);
// Check to make sure the bounds make sense.
if (lb != x || ub != x)
throw MatlabException("Input arguments LB and UB must have the same \
structure as X");
// Get the Matlab callback functions.
MatlabString objFunc(prhs[k++]);
MatlabString gradFunc(prhs[k++]);
// Get the auxiliary data.
const mxArray* auxData;
const mxArray* ptr = prhs[k++];
if (nrhs > 5) {
if (mxIsEmpty(ptr))
auxData = 0;
else
auxData = ptr;
}
else
auxData = 0;
// Get the intermediate callback function.
MatlabString* iterFunc;
ptr = prhs[k++];
if (nrhs > 6) {
if (mxIsEmpty(ptr))
iterFunc = 0;
else
iterFunc = new MatlabString(ptr);
}
else
iterFunc = 0;
// Set the options for the L-BFGS algorithm to their defaults.
int maxiter = defaultmaxiter;
int m = defaultm;
double factr = defaultfactr;
double pgtol = defaultpgtol;
// Process the remaining input arguments, which set options for
// the IPOPT algorithm.
while (k < nrhs) {
// Get the option label from the Matlab input argument.
MatlabString optionLabel(prhs[k++]);
if (k < nrhs) {
// Get the option value from the Matlab input argument.
MatlabScalar optionValue(prhs[k++]);
double value = optionValue;
if (!strcmp(optionLabel,"maxiter"))
maxiter = (int) value;
else if (!strcmp(optionLabel,"m"))
m = (int) value;
else if (!strcmp(optionLabel,"factr"))
factr = value / mxGetEps();
else if (!strcmp(optionLabel,"pgtol"))
pgtol = value;
else {
if (iterFunc) delete iterFunc;
throw MatlabException("Nonexistent option");
}
}
}
// Create a new instance of the optimization problem.
x = x0;
MatlabProgram program(x,lb,ub,&objFunc,&gradFunc,iterFunc,
(mxArray*) auxData,m,maxiter,factr,pgtol);
// Run the L-BFGS-B solver.
SolverExitStatus exitStatus = program.runSolver();
if (exitStatus == abnormalTermination) {
if (iterFunc) delete iterFunc;
throw MatlabException("Solver unable to satisfy convergence \
criteria due to abnormal termination");
}
else if (exitStatus == errorOnInput) {
