bool SnesEmu::init(const QString &diskPath, QString *error) { S9xSetSoundMute(FALSE); setDefaultSettings(); S9xSetPlaybackRate(); m_frame = QImage(512, 239, QImage::Format_RGB16); setVideoSrcRect(QRectF(0.0f, 0.0f, 256.0f, 224.f)); setFrameRate(60); GFX.Pitch = 512 * 2; GFX.RealPitch = 512 * 2; GFX.PPL = GFX.Pitch >> 1; GFX.PPLx2 = GFX.Pitch; GFX.Screen = (u8 *)m_frame.bits(); GFX.SubScreen = (u8 *) malloc(GFX.RealPitch * 239); GFX.ZBuffer = (u8 *) malloc(GFX.PPL * 239); GFX.SubZBuffer = (u8 *) malloc(GFX.PPL * 239); GFX.Delta = (GFX.SubScreen - GFX.Screen) >> 1; if (!GFX.Screen || !GFX.SubScreen || !GFX.ZBuffer || !Memory.Init() || !S9xInitAPU() || !GFX.SubZBuffer ) { *error = tr("SNES emulation init failed!"); return false; } S9xInitSound(); if (!S9xGraphicsInit()) { *error = tr("SNES emulation init failed!"); return false; } S9xReset(); setDefaultSettings(); *error = setDisk(diskPath); return error->isEmpty(); }
void S60AudioCaptureSession::initializeSessionL() { m_recorderUtility = CMdaAudioRecorderUtility::NewL(*this, 0, 80,(TMdaPriorityPreference) 0x5210001); updateAudioContainersL(); populateAudioCodecsDataL(); setDefaultSettings(); }
// constructor Config::Config() { _settings = new QSettings(getConfigFile(), QSettings::IniFormat ); _shortcuts = new ShortcutManager(_settings); // check existing config file if (!QFile::exists(getConfigFile())) { // creating conf file from set defaults QFile cf(getConfigFile()); if (cf.open(QIODevice::WriteOnly)) { cf.close(); qDebug() << "creating"; } setDefaultSettings(); saveSettings(); } _imageFormats << "png" << "jpg" << "bmp"; #if QT_VERSION >= 0x040500 _settings->setIniCodec("UTF-8"); #endif _scrNum = 0; }
void EmuSettings::loadSettings() { __DEBUG_IN QSettings settings; int version = settings.value("gpsp_version").toInt(); if( version != KSettingsVersion ) { __DEBUG1("No version was set, creating default settings"); setDefaultSettings(); savecurrentSettings(); return; } gpspsettings.iVersion = version; for(int i=0;i<10;i++) { QString keyval = "gpsp_kebind"; keyval.append( QString::number(i) ); gpspsettings.iScanKeyTable[i] = settings.value(keyval).toUInt(); } gpspsettings.iLastROM = settings.value("gpsp_lastrom").toString(); gpspsettings.iBios = settings.value("gpsp_bios").toString(); gpspsettings.iShowFPS = settings.value("gpsp_showfps").toBool(); gpspsettings.ikeepAspectRatio = settings.value("gpsp_aspectratio").toBool(); gpspsettings.iFrameSkip = settings.value("gpsp_frameskip").toInt(); gpspsettings.iAudioOn = settings.value("gpsp_audioOn").toBool(); gpspsettings.iVolume = settings.value("gpsp_volume").toInt(); gpspsettings.iLastSlot = settings.value("gpsp_lastslot").toInt(); gpspsettings.iScreenSettings = settings.value("gpsp_screensettings").toInt(); __DEBUG_OUT }
/** * @brief CodeEditor::CodeEditor Create empty code editor. * @param parent Get parent of this object. * @param path Path of opened file. * @param type Type of opened shader. */ CodeEditor::CodeEditor(QWidget *parent, QString path, InfoManager::SHADERTYPE type) : QPlainTextEdit(parent) { lineNumberArea = new LineNumberArea(this); oldBlockNumber = 0; customConnect(); updateLineNumberAreaWidth(0); highlightCurrentLine(); pathSet = true; filePath = path; //textModif = false; // set shader type sType = type; // set syntax highlighter highlight = new Highlighter(this); highlight->setDocument(document()); // read the file readFile(); setDefaultSettings(); createRegExps(); }
void EmuSettings::loadSettings() { __DEBUG_IN QSettings settings; int version = settings.value("gpsp_version").toInt(); if( version != KSettingsVersion ) { __DEBUG1("No version was set, creating default settings"); setDefaultSettings(); savecurrentSettings(); return; } gpspsettings.iVersion = version; for(int i=0;i<10;i++) { QString keyval = "gpsp_kebind"; keyval.append( QString::number(i) ); gpspsettings.iScanKeyTable[i] = settings.value(keyval).toUInt(); } gpspsettings.iLastROM = settings.value("gpsp_lastrom").toString(); gpspsettings.iBios = settings.value("gpsp_bios").toString(); gpspsettings.iShowFPS = settings.value("gpsp_showfps").toBool(); gpspsettings.iAudioOn = settings.value("gpsp_audioOn").toBool(); gpspsettings.iVolume = settings.value("gpsp_volume").toInt(); gpspsettings.iLastSlot = settings.value("gpsp_lastslot").toInt(); gpspsettings.iDpadSettings = settings.value("gpsp_dpadsettings").toInt(); gpspsettings.iButtonOpacity = settings.value("gpsp_ButtonOpacity").toInt(); gpspsettings.iStretch = settings.value("gpsp_Stretch").toInt(); gpspsettings.iButtonSettings = settings.value("gpsp_ButtonSettings").toInt(); __DEBUG_OUT }
void Settings::createSettingsFile() { if (!fileExists(Settings::getSettingsPath())) { qCritical() << "Settings file" << Settings::getSettingsPath() <<"does not exist. Creating it now..."; QFile sfile(Settings::getSettingsPath()); if(!sfile.open(QIODevice::WriteOnly)) { qDebug() << "Unable to create" << Settings::getSettingsPath() << "Check folder permissions."; return; } QTextStream header(&sfile); header << "##############################################################" << "\n# SEGS configuration file." << "\n#" << "\n# listen_addr values below should contain the IP the" << "\n# clients will connect to." << "\n#" << "\n# location_addr values below should contain the IP the" << "\n# clients will receive data from." << "\n#" << "\n# Both values are set to 127.0.0.1 by default but should" << "\n# be set to your local IP address on the network" << "\n# for example: 10.0.0.2" << "\n#" << "\n# Default ports are listed below:" << "\n# AccountDatabase db_port: 5432" << "\n# CharacterDatabase db_port: 5432" << "\n# AuthServer location_addr: 2106" << "\n# GameServer listen_addr: 7002" << "\n# GameServer location_addr: 7002" << "\n# MapServer listen_addr: 7003" << "\n# MapServer location_addr: 7003" << "\n#" << "\n##############################################################"; sfile.close(); setDefaultSettings(); return; } else { qDebug() << "Settings file already exists at" << Settings::getSettingsPath(); return; } }
void STDRenderer::restore() { MemoryTexture memwhite; memwhite.init(4, 4, TF_R8G8B8A8); oxygine::operations::op_fill fill; ImageData im = memwhite.lock(); oxygine::operations::applyOperation(fill, im); white = IVideoDriver::instance->createTexture(); white->setName("!renderer. white"); white->init(im, false); white->setLinearFilter(false); setDefaultSettings(); _restored = true; }
void NaoCamera::init() { if(!initialized) { initOpenVideoDevice(); } initSetImageFormat(); initSetFrameRate(); if (!initialized) { initRequestAndMapBuffers(); initQueueAllBuffers(); } enableStreaming(); setDefaultSettings(); initialized = true; }
PointTableWidget::PointTableWidget(QWidget * parent, const QPolygonF * const points, const Settings * const settings) : QTableWidget(parent) , points(*points) { if (settings == NULL) setDefaultSettings(); else this->settings = *settings; setColumnCount(this->settings.colHeader.size()); setHorizontalHeaderLabels(this->settings.colHeader); setColumnWidths(); setSelectionMode(QAbstractItemView::ExtendedSelection); if (this->settings.autoSelectRow) setSelectionBehavior(QAbstractItemView::SelectRows); editingCell = QPoint(-1, -1); connect(this, SIGNAL(cellDoubleClicked(int,int)), this, SLOT(cellEditingSlot(int,int))); connect(this, SIGNAL(cellChanged(int,int)), this, SLOT(updateCell(int,int))); }
// constructor Config::Config() { _settings = new QSettings(getConfigFile(), QSettings::IniFormat); _shortcuts = new ShortcutManager(_settings); // check existing config file if (!QFile::exists(getConfigFile())) { // creating conf file from set defaults QFile cf(getConfigFile()); if (cf.open(QIODevice::WriteOnly)) { cf.close(); } setDefaultSettings(); saveSettings(); } _settings->setIniCodec("UTF-8"); _scrNum = 0; }
void VideoDriverGLES20::restore() { //_us.restore(); setDefaultSettings(); }
int main(int argc, char **argv) { scs_int n, m, col_nnz, nnz, i, q_total, q_num_rows, max_q; Cone * k; Data * d; Sol * sol, * opt_sol; Info info = { 0 }; scs_float p_f, p_l; int seed = 0; /* default parameters */ p_f = 0.1; p_l = 0.3; seed = time(SCS_NULL); switch (argc) { case 5: seed = atoi(argv[4]); /* no break */ case 4: p_f = atof(argv[2]); p_l = atof(argv[3]); /* no break */ case 2: n = atoi(argv[1]); break; default: scs_printf("usage:\t%s n p_f p_l s\n" "\tcreates an SOCP with n variables where p_f fraction of rows correspond\n" "\tto equality constraints, p_l fraction of rows correspond to LP constraints,\n" "\tand the remaining percentage of rows are involved in second-order\n" "\tcone constraints. the random number generator is seeded with s.\n" "\tnote that p_f + p_l should be less than or equal to 1, and that\n" "\tp_f should be less than .33, since that corresponds to as many equality\n" "\tconstraints as variables.\n", argv[0]); scs_printf("\nusage:\t%s n p_f p_l\n" "\tdefaults the seed to the system time\n", argv[0]); scs_printf("\nusage:\t%s n\n" "\tdefaults to using p_f = 0.1 and p_l = 0.3\n", argv[0]); return 0; } srand(seed); scs_printf("seed : %i\n", seed); k = scs_calloc(1, sizeof(Cone)); d = scs_calloc(1, sizeof(Data)); d->stgs = scs_calloc(1, sizeof(Settings)); sol = scs_calloc(1, sizeof(Sol)); opt_sol = scs_calloc(1, sizeof(Sol)); m = 3 * n; col_nnz = (int) ceil(sqrt(n)); nnz = n * col_nnz; max_q = (scs_int) ceil(3 * n / log(3 * n)); if (p_f + p_l > 1.0) { printf("error: p_f + p_l > 1.0!\n"); return 1; } k->f = (scs_int) floor(3 * n * p_f); k->l = (scs_int) floor(3 * n * p_l); k->qsize = 0; q_num_rows = 3 * n - k->f - k->l; k->q = scs_malloc(q_num_rows * sizeof(scs_int)); while (q_num_rows > max_q) { int size; size = (rand() % max_q) + 1; k->q[k->qsize] = size; k->qsize++; q_num_rows -= size; } if (q_num_rows > 0) { k->q[k->qsize] = q_num_rows; k->qsize++; } q_total = 0; for (i = 0; i < k->qsize; i++) { q_total += k->q[i]; } k->s = SCS_NULL; k->ssize = 0; k->ep = 0; k->ed = 0; scs_printf("\nA is %ld by %ld, with %ld nonzeros per column.\n", (long) m, (long) n, (long) col_nnz); scs_printf("A has %ld nonzeros (%f%% dense).\n", (long) nnz, 100 * (scs_float) col_nnz / m); scs_printf("Nonzeros of A take %f GB of storage.\n", ((scs_float) nnz * sizeof(scs_float)) / POWF(2, 30)); scs_printf("Row idxs of A take %f GB of storage.\n", ((scs_float) nnz * sizeof(scs_int)) / POWF(2, 30)); scs_printf("Col ptrs of A take %f GB of storage.\n\n", ((scs_float) n * sizeof(scs_int)) / POWF(2, 30)); printf("Cone information:\n"); printf("Zero cone rows: %ld\n", (long) k->f); printf("LP cone rows: %ld\n", (long) k->l); printf("Number of second-order cones: %ld, covering %ld rows, with sizes\n[", (long) k->qsize, (long) q_total); for (i = 0; i < k->qsize; i++) { printf("%ld, ", (long) k->q[i]); } printf("]\n"); printf("Number of rows covered is %ld out of %ld.\n\n", (long) (q_total + k->f + k->l), (long) m); /* set up SCS structures */ d->m = m; d->n = n; genRandomProbData(nnz, col_nnz, d, k, opt_sol); setDefaultSettings(d); scs_printf("true pri opt = %4f\n", innerProd(d->c, opt_sol->x, d->n)); scs_printf("true dua opt = %4f\n", -innerProd(d->b, opt_sol->y, d->m)); /* solve! */ scs(d, k, sol, &info); scs_printf("true pri opt = %4f\n", innerProd(d->c, opt_sol->x, d->n)); scs_printf("true dua opt = %4f\n", -innerProd(d->b, opt_sol->y, d->m)); if (sol->x) { scs_printf("scs pri obj= %4f\n", innerProd(d->c, sol->x, d->n)); } if (sol->y) { scs_printf("scs dua obj = %4f\n", -innerProd(d->b, sol->y, d->m)); } freeData(d, k); freeSol(sol); freeSol(opt_sol); return 0; }
static PyObject *csolve(PyObject *self, PyObject *args, PyObject *kwargs) { /* data structures for arguments */ PyArrayObject *Ax, *Ai, *Ap, *c, *b; PyObject *cone, *warm = SCS_NULL; PyObject *verbose = SCS_NULL; PyObject *normalize = SCS_NULL; /* get the typenum for the primitive scs_int and scs_float types */ int scs_intType = getIntType(); int scs_floatType = getFloatType(); struct ScsPyData ps = { SCS_NULL, SCS_NULL, SCS_NULL, SCS_NULL, SCS_NULL, }; /* scs data structures */ Data *d = scs_calloc(1, sizeof(Data)); Cone *k = scs_calloc(1, sizeof(Cone)); AMatrix *A; Sol sol = {0}; Info info; char *kwlist[] = {"shape", "Ax", "Ai", "Ap", "b", "c", "cone", "warm", "verbose", "normalize", "max_iters", "scale", "eps", "cg_rate", "alpha", "rho_x", SCS_NULL}; /* parse the arguments and ensure they are the correct type */ #ifdef DLONG #ifdef FLOAT char *argparse_string = "(ll)O!O!O!O!O!O!|O!O!O!lfffff"; char *outarg_string = "{s:l,s:l,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:s}"; #else char *argparse_string = "(ll)O!O!O!O!O!O!|O!O!O!lddddd"; char *outarg_string = "{s:l,s:l,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:s}"; #endif #else #ifdef FLOAT char *argparse_string = "(ii)O!O!O!O!O!O!|O!O!O!ifffff"; char *outarg_string = "{s:i,s:i,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:f,s:s}"; #else char *argparse_string = "(ii)O!O!O!O!O!O!|O!O!O!iddddd"; char *outarg_string = "{s:i,s:i,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:s}"; #endif #endif npy_intp veclen[1]; PyObject *x, *y, *s, *returnDict, *infoDict; d->stgs = scs_malloc(sizeof(Settings)); /* set defaults */ setDefaultSettings(d); if (!PyArg_ParseTupleAndKeywords( args, kwargs, argparse_string, kwlist, &(d->m), &(d->n), &PyArray_Type, &Ax, &PyArray_Type, &Ai, &PyArray_Type, &Ap, &PyArray_Type, &b, &PyArray_Type, &c, &PyDict_Type, &cone, &PyDict_Type, &warm, &PyBool_Type, &verbose, &PyBool_Type, &normalize, &(d->stgs->max_iters), &(d->stgs->scale), &(d->stgs->eps), &(d->stgs->cg_rate), &(d->stgs->alpha), &(d->stgs->rho_x))) { PySys_WriteStderr("error parsing inputs\n"); return SCS_NULL; } if (d->m < 0) { PyErr_SetString(PyExc_ValueError, "m must be a positive integer"); return SCS_NULL; } if (d->n < 0) { PyErr_SetString(PyExc_ValueError, "n must be a positive integer"); return SCS_NULL; } /* set A */ if (!PyArray_ISFLOAT(Ax) || PyArray_NDIM(Ax) != 1) { return finishWithErr(d, k, &ps, "Ax must be a numpy array of floats"); } if (!PyArray_ISINTEGER(Ai) || PyArray_NDIM(Ai) != 1) { return finishWithErr(d, k, &ps, "Ai must be a numpy array of ints"); } if (!PyArray_ISINTEGER(Ap) || PyArray_NDIM(Ap) != 1) { return finishWithErr(d, k, &ps, "Ap must be a numpy array of ints"); } ps.Ax = getContiguous(Ax, scs_floatType); ps.Ai = getContiguous(Ai, scs_intType); ps.Ap = getContiguous(Ap, scs_intType); A = scs_malloc(sizeof(AMatrix)); A->n = d->n; A->m = d->m; A->x = (scs_float *)PyArray_DATA(ps.Ax); A->i = (scs_int *)PyArray_DATA(ps.Ai); A->p = (scs_int *)PyArray_DATA(ps.Ap); d->A = A; /*d->Anz = d->Ap[d->n]; */ /*d->Anz = PyArray_DIM(Ai,0); */ /* set c */ if (!PyArray_ISFLOAT(c) || PyArray_NDIM(c) != 1) { return finishWithErr( d, k, &ps, "c must be a dense numpy array with one dimension"); } if (PyArray_DIM(c, 0) != d->n) { return finishWithErr(d, k, &ps, "c has incompatible dimension with A"); } ps.c = getContiguous(c, scs_floatType); d->c = (scs_float *)PyArray_DATA(ps.c); /* set b */ if (!PyArray_ISFLOAT(b) || PyArray_NDIM(b) != 1) { return finishWithErr( d, k, &ps, "b must be a dense numpy array with one dimension"); } if (PyArray_DIM(b, 0) != d->m) { return finishWithErr(d, k, &ps, "b has incompatible dimension with A"); } ps.b = getContiguous(b, scs_floatType); d->b = (scs_float *)PyArray_DATA(ps.b); if (getPosIntParam("f", &(k->f), 0, cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field f"); } if (getPosIntParam("l", &(k->l), 0, cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field l"); } if (getConeArrDim("q", &(k->q), &(k->qsize), cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field q"); } if (getConeArrDim("s", &(k->s), &(k->ssize), cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field s"); } if (getConeFloatArr("p", &(k->p), &(k->psize), cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field p"); } if (getPosIntParam("ep", &(k->ep), 0, cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field ep"); } if (getPosIntParam("ed", &(k->ed), 0, cone) < 0) { return finishWithErr(d, k, &ps, "failed to parse cone field ed"); } d->stgs->verbose = verbose ? (scs_int)PyObject_IsTrue(verbose) : VERBOSE; d->stgs->normalize = normalize ? (scs_int)PyObject_IsTrue(normalize) : NORMALIZE; if (d->stgs->max_iters < 0) { return finishWithErr(d, k, &ps, "max_iters must be positive"); } if (d->stgs->scale < 0) { return finishWithErr(d, k, &ps, "scale must be positive"); } if (d->stgs->eps < 0) { return finishWithErr(d, k, &ps, "eps must be positive"); } if (d->stgs->cg_rate < 0) { return finishWithErr(d, k, &ps, "cg_rate must be positive"); } if (d->stgs->alpha < 0) { return finishWithErr(d, k, &ps, "alpha must be positive"); } if (d->stgs->rho_x < 0) { return finishWithErr(d, k, &ps, "rho_x must be positive"); } /* parse warm start if set */ d->stgs->warm_start = WARM_START; if (warm) { d->stgs->warm_start = getWarmStart("x", &(sol.x), d->n, warm); d->stgs->warm_start |= getWarmStart("y", &(sol.y), d->m, warm); d->stgs->warm_start |= getWarmStart("s", &(sol.s), d->m, warm); } Py_BEGIN_ALLOW_THREADS /* Solve! */ scs(d, k, &sol, &info); Py_END_ALLOW_THREADS /* create output (all data is *deep copied*) */ /* x */ /* matrix *x; */ /* if(!(x = Matrix_New(n,1,DOUBLE))) */ /* return PyErr_NoMemory(); */ /* memcpy(MAT_BUFD(x), mywork->x, n*sizeof(scs_float)); */ veclen[0] = d->n; x = PyArray_SimpleNewFromData(1, veclen, scs_floatType, sol.x); PyArray_ENABLEFLAGS((PyArrayObject *)x, NPY_ARRAY_OWNDATA); /* y */ /* matrix *y; */ /* if(!(y = Matrix_New(p,1,DOUBLE))) */ /* return PyErr_NoMemory(); */ /* memcpy(MAT_BUFD(y), mywork->y, p*sizeof(scs_float)); */ veclen[0] = d->m; y = PyArray_SimpleNewFromData(1, veclen, scs_floatType, sol.y); PyArray_ENABLEFLAGS((PyArrayObject *)y, NPY_ARRAY_OWNDATA); /* s */ /* matrix *s; */ /* if(!(s = Matrix_New(m,1,DOUBLE))) */ /* return PyErr_NoMemory(); */ /* memcpy(MAT_BUFD(s), mywork->s, m*sizeof(scs_float)); */ veclen[0] = d->m; s = PyArray_SimpleNewFromData(1, veclen, scs_floatType, sol.s); PyArray_ENABLEFLAGS((PyArrayObject *)s, NPY_ARRAY_OWNDATA); infoDict = Py_BuildValue( outarg_string, "statusVal", (scs_int)info.statusVal, "iter", (scs_int)info.iter, "pobj", (scs_float)info.pobj, "dobj", (scs_float)info.dobj, "resPri", (scs_float)info.resPri, "resDual", (scs_float)info.resDual, "relGap", (scs_float)info.relGap, "resInfeas", (scs_float)info.resInfeas, "resUnbdd", (scs_float)info.resUnbdd, "solveTime", (scs_float)(info.solveTime), "setupTime", (scs_float)(info.setupTime), "status", info.status); returnDict = Py_BuildValue("{s:O,s:O,s:O,s:O}", "x", x, "y", y, "s", s, "info", infoDict); /* give up ownership to the return dictionary */ Py_DECREF(x); Py_DECREF(y); Py_DECREF(s); Py_DECREF(infoDict); /* no longer need pointers to arrays that held primitives */ freePyData(d, k, &ps); return returnDict; }
OptionsWidget::OptionsWidget(QString productName,QWidget *parent) : QScrollArea(parent), m_productName(productName), m_settings(QSettings::SystemScope,"osll",m_productName) { m_widget = new QWidget(this); QVBoxLayout * layout = new QVBoxLayout(m_widget); layout->addWidget(new QLabel("Login", m_widget)); layout->addWidget(m_nameEdit = new QLineEdit(m_widget)); layout->addWidget(new QLabel("Password", m_widget)); layout->addWidget(m_passwordEdit = new QLineEdit(m_widget)); layout->addWidget(m_passwordCheckBox = new QCheckBox("Show password", m_widget)); layout->addWidget(new QLabel("Channel name", m_widget)); layout->addWidget(m_channelEdit = new QLineEdit(m_widget)); // NOTE if we use m_widget windget in tracker addition field for username will displayed if (m_productName == "tracker") { layout->addWidget(new QLabel("Name that will be displayed\non Observer map:", m_widget)); layout->addWidget(m_visibleNameEdit = new QLineEdit()); } m_passwordEdit->setEchoMode(QLineEdit::Password); m_passwordCheckBox->setChecked(false); layout->addWidget(new QLabel("Server", m_widget)); layout->addWidget(m_serverUrlEdit = new QLineEdit(m_widget)); layout->addWidget(new QLabel("Port", m_widget)); layout->addWidget(m_serverPortEdit = new QSpinBox(m_widget)); m_serverPortEdit->setMinimum(0); m_serverPortEdit->setMaximum(65535); layout->addWidget(new QLabel("Proxy type", m_widget)); layout->addWidget(m_proxyType = new QComboBox(m_widget)); layout->addWidget(new QLabel("Proxy host", m_widget)); layout->addWidget(m_proxyHostEdit = new QLineEdit(m_widget)); layout->addWidget(new QLabel("Proxy port", m_widget)); layout->addWidget(m_proxyPortEdit = new QSpinBox(m_widget)); m_proxyType->addItem("DefaultProxy", QNetworkProxy::DefaultProxy); m_proxyType->addItem("Socks5Proxy", QNetworkProxy::Socks5Proxy); m_proxyType->addItem("NoProxy", QNetworkProxy::NoProxy); m_proxyType->addItem("HttpProxy", QNetworkProxy::HttpProxy); m_proxyType->addItem("HttpCachingProxy", QNetworkProxy::HttpCachingProxy); m_proxyType->addItem("FtpCachingProxy", QNetworkProxy::FtpCachingProxy); m_proxyPortEdit->setMinimum(0); m_proxyPortEdit->setMaximum(65535); layout->addWidget(new QLabel("Cache type", m_widget)); layout->addWidget(m_cacheType = new QComboBox(m_widget)); layout->addWidget(new QLabel("Cache path", m_widget)); layout->addWidget(m_cachePath = new QLineEdit(m_widget)); layout->addWidget(m_cachePathButton = new QPushButton("Choose dir...", m_widget)); layout->addWidget(new QLabel("Max cache size", m_widget)); layout->addWidget(m_cacheMaxSize = new QSpinBox(m_widget)); m_cacheType->addItem("None", 0); m_cacheType->addItem("Network cache", 1); m_cacheType->addItem("Disk cache", 2); m_cacheType->setCurrentIndex(-1); layout->addWidget(m_doneButton = new QPushButton("Done", m_widget)); layout->addWidget(m_defaultButton = new QPushButton("Default settings", m_widget)); layout->addWidget(m_cancelButton = new QPushButton("Cancel", m_widget)); m_widget->setLayout(layout); this->setWidget(m_widget); this->setWidgetResizable(true); connect(m_doneButton, SIGNAL(clicked()), this, SLOT(onDoneClicked())); connect(m_cancelButton, SIGNAL(clicked()), this, SLOT(onCancelClicked())); connect(m_defaultButton,SIGNAL(clicked()), this, SLOT(setDefaultSettings())); connect(m_proxyType, SIGNAL(currentIndexChanged(int)), this, SLOT(onProxyTypeChanged(int))); connect(m_cacheType, SIGNAL(currentIndexChanged(int)), this, SLOT(onCacheTypeChanged(int))); connect(m_cachePathButton, SIGNAL(clicked()), this, SLOT(onCachePathButtonClick())); connect(m_passwordCheckBox, SIGNAL(clicked(bool)), this, SLOT(onShowPasswordChecked(bool))); onProxyTypeChanged(m_proxyType->currentIndex()); if( m_settings.value("magic").toString() != APP_MAGIC ) { setDefaultSettings(); createSettings(); } initSettings(); applyProxySettings(); }
<< "-rp<#> - Set COM # port for remote link" << "-rs<#> - Remote link speed: 1=slowest, 2=slow, 3=medium, 4=fast" << "-sc - No case checking on symbols" << "-sd<dir> - Source file directory <dir>" << "-vd<dllname> - Use DLL <dllname> for video mode switching" << "-vg - Complete graphics screen save" << "-vn - 43/50 line display not allowed" << "-vp - Enable EGA/VGA palette save"; foreach(QString s, sl3){ menu3->addAction(s); } ui->toolButton_6->setMenu(menu3); connect(menu1,SIGNAL(triggered(QAction*)),this,SLOT(menu1_triggered(QAction*))); connect(menu2,SIGNAL(triggered(QAction*)),this,SLOT(menu2_triggered(QAction*))); connect(menu3,SIGNAL(triggered(QAction*)),this,SLOT(menu3_triggered(QAction*))); connect(ui->pushButton_2,SIGNAL(released()),this,SLOT(setDefaultSettings())); } asmSettings::~asmSettings() { delete ui; } void asmSettings::menu1_triggered(QAction *a) { ui->lineEdit_2->setText(ui->lineEdit_2->text()+' '+a->text().remove(a->text().indexOf(QRegExp(" - ")),a->text().length()-a->text().indexOf(QRegExp(" - ")))); } void asmSettings::menu2_triggered(QAction *a) { ui->lineEdit_4->setText(ui->lineEdit_4->text()+' '+a->text().remove(a->text().indexOf(QRegExp(" - ")),a->text().length()-a->text().indexOf(QRegExp(" - "))));
OMX_ERRORTYPE PcmSplitter::construct(void) { OMX_ERRORTYPE error; OMX_U32 idx, nRoleCount=1; OMX_AUDIO_PARAM_PCMMODETYPE defaultPcmSettings; PcmSplitter_PcmPort *pcmsplitterPort; error = AFM_Component::construct(NB_OUTPUT_PORTS + NB_INPUT_PORTS, nRoleCount,mIsHost); if (error != OMX_ErrorNone) return error; ENS_String<25> role; // Same roles for ARM and DSP role = "audio_splitter.pcm"; role.put((OMX_STRING)mRoles[0]); setActiveRole(mRoles[0]); mBlockSize = DEFAULT_PCM_BLOCKSIZE; defaultPcmSettings.nSize = sizeof(OMX_AUDIO_PARAM_PCMMODETYPE); defaultPcmSettings.eNumData = OMX_NumericalDataSigned; defaultPcmSettings.eEndian = OMX_EndianLittle; defaultPcmSettings.bInterleaved = OMX_TRUE; defaultPcmSettings.ePCMMode = OMX_AUDIO_PCMModeLinear; defaultPcmSettings.nBitPerSample = 16; defaultPcmSettings.nChannels = 2; defaultPcmSettings.nSamplingRate = 48000; defaultPcmSettings.nPortIndex = 0; defaultPcmSettings.eChannelMapping[0] = OMX_AUDIO_ChannelLF; defaultPcmSettings.eChannelMapping[1] = OMX_AUDIO_ChannelRF; //Create PcmSplitter Input Port pcmsplitterPort = new PcmSplitter_PcmPort(0, OMX_DirInput, mBlockSize * defaultPcmSettings.nChannels * defaultPcmSettings.nBitPerSample/8, defaultPcmSettings, *this); if (pcmsplitterPort == 0) { return OMX_ErrorInsufficientResources; } addPort(pcmsplitterPort); if (mIsHost == OMX_TRUE) { pcmsplitterPort->setSupportedProprietaryComm(AFM_HOST_PROPRIETARY_COMMUNICATION); } else { pcmsplitterPort->setSupportedProprietaryComm(AFM_MPC_PROPRIETARY_COMMUNICATION);; } //Create PcmSplitter Output Ports for (idx=1; idx<getPortCount(); idx++) { defaultPcmSettings.nPortIndex = idx; pcmsplitterPort = new PcmSplitter_PcmPort( idx, OMX_DirOutput, mBlockSize * defaultPcmSettings.nChannels * defaultPcmSettings.nBitPerSample/8, defaultPcmSettings, *this); if (pcmsplitterPort == 0) { return OMX_ErrorInsufficientResources; } addPort(pcmsplitterPort); if (mIsHost == OMX_TRUE) { pcmsplitterPort->setSupportedProprietaryComm(AFM_HOST_PROPRIETARY_COMMUNICATION); } else { pcmsplitterPort->setSupportedProprietaryComm(AFM_MPC_PROPRIETARY_COMMUNICATION);; } } setDefaultSettings(); return OMX_ErrorNone; }
int main(int argc, char** argv) { //#define CHECK_FPU_EXCEPTIONS 1 #ifdef CHECK_FPU_EXCEPTIONS int cw = _control87(0, 0); // Set the exception masks off, turn exceptions on cw &= ~(EM_ZERODIVIDE | EM_INVALID); printf("control87 = %#x\n", cw); // Set the control word _control87(cw, MCW_EM); #endif //CHECK_FPU_EXCEPTIONS setDefaultSettings(); int bulletVersion = btGetVersion(); printf("Bullet version %d\n",bulletVersion); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE |GLUT_DEPTH | GLUT_STENCIL); glutInitWindowSize(width, height); mainWindow = glutCreateWindow("http://bulletphysics.com"); #ifdef BT_USE_FREEGLUT glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); #endif entry = g_demoEntries + testIndex; demo = CreatDemo(entry); glutDisplayFunc(SimulationLoop); GLUI_Master.set_glutReshapeFunc(Resize); GLUI_Master.set_glutKeyboardFunc(Keyboard); GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); GLUI_Master.set_glutSpecialUpFunc(KeyboardSpecialUp); GLUI_Master.set_glutMouseFunc(Mouse); glutMotionFunc(MouseMotion); glui = GLUI_Master.create_glui_subwindow( mainWindow, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Tests"); GLUI_Listbox* testList = glui->add_listbox("", &testSelection); glui->add_button("Next Scene", 0,(GLUI_Update_CB)NextScene); glui->add_separator(); GLUI_Spinner* iterationSpinner = glui->add_spinner("Iterations", GLUI_SPINNER_INT, &iterationCount); iterationSpinner->set_int_limits(1, 250); /* GLUI_Spinner* hertzSpinner = glui->add_spinner("Hertz", GLUI_SPINNER_FLOAT, &hz); hertzSpinner->set_float_limits(5.0f, 200.0f); */ glui->add_checkbox("DisableDeactivation", &gDebugNoDeactivation); glui->add_checkbox("Split Impulse", &gUseSplitImpulse); GLUI_Spinner* spinner = 0; spinner = glui->add_spinner("ERP", GLUI_SPINNER_FLOAT, &gErp); // spinner->set_float_limits(0.f,1.f); // spinner = glui->add_spinner("ERP2", GLUI_SPINNER_FLOAT, &gErp2); spinner->set_float_limits(0.f,1.f); spinner = glui->add_spinner("Slop", GLUI_SPINNER_FLOAT, &gSlop); spinner->set_float_limits(0.f,1.f); // spinner = glui->add_spinner("WSP", GLUI_SPINNER_FLOAT,&gWarmStartingParameter); // spinner->set_float_limits (0.f,1.0); glui->add_checkbox("Warmstarting", &gUseWarmstarting); glui->add_checkbox("Randomize Constraints", &gRandomizeConstraints); glui->add_button("Reset Defaults", 0,(GLUI_Update_CB)setDefaultSettingsAndSync); glui->add_separator(); GLUI_Panel* drawPanel = glui->add_panel("Debug Draw"); glui->add_checkbox_to_panel(drawPanel, "AABBs", &gDrawAabb); glui->add_checkbox_to_panel(drawPanel, "Wireframe", &gWireFrame); glui->add_checkbox_to_panel(drawPanel, "Contacts", &gDebugContacts); glui->add_checkbox_to_panel(drawPanel, "Textures", &gDrawTextures); glui->add_checkbox_to_panel(drawPanel, "Shadows", &gDrawShadows); glui->add_checkbox_to_panel(drawPanel, "Clusters", &gDrawClusters); int testCount = 0; btDemoEntry* e = g_demoEntries; while (e->createFcn) { testList->add_item(testCount, e->name); ++testCount; ++e; } glui->add_separator(); glui->add_button("Toggle Pause", 0,(GLUI_Update_CB)TogglePause); glui->add_button("Single Step", 0,(GLUI_Update_CB)SingleSimulationStep); glui->add_button("Reset Scene", 0,(GLUI_Update_CB)ResetScene); glui->add_button("Restart Scene", 0,(GLUI_Update_CB)RestartScene); glui->add_separator(); // glui->add_button("Exit", 0,(GLUI_Update_CB)exit); glui->set_main_gfx_window( mainWindow ); // Use a timer to control the frame rate. glutTimerFunc(framePeriod, Timer, 0); glutMainLoop(); return 0; }
void setDefaultSettingsAndSync() { setDefaultSettings(); glui->sync_live(); }