void mt_task_queue::submit(gtask const & t) { submit(t, get_default_prio()); }
static int cpu_read (void) { #if PROCESSOR_CPU_LOAD_INFO || PROCESSOR_TEMPERATURE int cpu; kern_return_t status; #if PROCESSOR_CPU_LOAD_INFO processor_cpu_load_info_data_t cpu_info; mach_msg_type_number_t cpu_info_len; #endif #if PROCESSOR_TEMPERATURE processor_info_data_t cpu_temp; mach_msg_type_number_t cpu_temp_len; #endif host_t cpu_host; for (cpu = 0; cpu < cpu_list_len; cpu++) { #if PROCESSOR_CPU_LOAD_INFO cpu_host = 0; cpu_info_len = PROCESSOR_BASIC_INFO_COUNT; if ((status = processor_info (cpu_list[cpu], PROCESSOR_CPU_LOAD_INFO, &cpu_host, (processor_info_t) &cpu_info, &cpu_info_len)) != KERN_SUCCESS) { ERROR ("cpu plugin: processor_info failed with status %i", (int) status); continue; } if (cpu_info_len < CPU_STATE_MAX) { ERROR ("cpu plugin: processor_info returned only %i elements..", cpu_info_len); continue; } submit (cpu, "user", (counter_t) cpu_info.cpu_ticks[CPU_STATE_USER]); submit (cpu, "nice", (counter_t) cpu_info.cpu_ticks[CPU_STATE_NICE]); submit (cpu, "system", (counter_t) cpu_info.cpu_ticks[CPU_STATE_SYSTEM]); submit (cpu, "idle", (counter_t) cpu_info.cpu_ticks[CPU_STATE_IDLE]); #endif /* PROCESSOR_CPU_LOAD_INFO */ #if PROCESSOR_TEMPERATURE /* * Not all Apple computers do have this ability. To minimize * the messages sent to the syslog we do an exponential * stepback if `processor_info' fails. We still try ~once a day * though.. */ if (cpu_temp_retry_counter > 0) { cpu_temp_retry_counter--; continue; } cpu_temp_len = PROCESSOR_INFO_MAX; status = processor_info (cpu_list[cpu], PROCESSOR_TEMPERATURE, &cpu_host, cpu_temp, &cpu_temp_len); if (status != KERN_SUCCESS) { ERROR ("cpu plugin: processor_info failed: %s", mach_error_string (status)); cpu_temp_retry_counter = cpu_temp_retry_step; cpu_temp_retry_step *= 2; if (cpu_temp_retry_step > cpu_temp_retry_max) cpu_temp_retry_step = cpu_temp_retry_max; continue; } if (cpu_temp_len != 1) { DEBUG ("processor_info (PROCESSOR_TEMPERATURE) returned %i elements..?", (int) cpu_temp_len); continue; } cpu_temp_retry_counter = 0; cpu_temp_retry_step = 1; DEBUG ("cpu_temp = %i", (int) cpu_temp); #endif /* PROCESSOR_TEMPERATURE */ } /* #endif PROCESSOR_CPU_LOAD_INFO */ #elif defined(KERNEL_LINUX) int cpu; counter_t user, nice, syst, idle; counter_t wait, intr, sitr; /* sitr == soft interrupt */ FILE *fh; char buf[1024]; char *fields[9]; int numfields; if ((fh = fopen ("/proc/stat", "r")) == NULL) { char errbuf[1024]; ERROR ("cpu plugin: fopen (/proc/stat) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } while (fgets (buf, 1024, fh) != NULL) { if (strncmp (buf, "cpu", 3)) continue; if ((buf[3] < '0') || (buf[3] > '9')) continue; numfields = strsplit (buf, fields, 9); if (numfields < 5) continue; cpu = atoi (fields[0] + 3); user = atoll (fields[1]); nice = atoll (fields[2]); syst = atoll (fields[3]); idle = atoll (fields[4]); submit (cpu, "user", user); submit (cpu, "nice", nice); submit (cpu, "system", syst); submit (cpu, "idle", idle); if (numfields >= 8) { wait = atoll (fields[5]); intr = atoll (fields[6]); sitr = atoll (fields[7]); submit (cpu, "wait", wait); submit (cpu, "interrupt", intr); submit (cpu, "softirq", sitr); if (numfields >= 9) submit (cpu, "steal", atoll (fields[8])); } } fclose (fh); /* #endif defined(KERNEL_LINUX) */ #elif defined(HAVE_LIBKSTAT) int cpu; counter_t user, syst, idle, wait; static cpu_stat_t cs; if (kc == NULL) return (-1); for (cpu = 0; cpu < numcpu; cpu++) { if (kstat_read (kc, ksp[cpu], &cs) == -1) continue; /* error message? */ idle = (counter_t) cs.cpu_sysinfo.cpu[CPU_IDLE]; user = (counter_t) cs.cpu_sysinfo.cpu[CPU_USER]; syst = (counter_t) cs.cpu_sysinfo.cpu[CPU_KERNEL]; wait = (counter_t) cs.cpu_sysinfo.cpu[CPU_WAIT]; submit (ksp[cpu]->ks_instance, "user", user); submit (ksp[cpu]->ks_instance, "system", syst); submit (ksp[cpu]->ks_instance, "idle", idle); submit (ksp[cpu]->ks_instance, "wait", wait); } /* #endif defined(HAVE_LIBKSTAT) */ #elif CAN_USE_SYSCTL uint64_t cpuinfo[numcpu][CPUSTATES]; size_t cpuinfo_size; int status; int i; if (numcpu < 1) { ERROR ("cpu plugin: Could not determine number of " "installed CPUs using sysctl(3)."); return (-1); } memset (cpuinfo, 0, sizeof (cpuinfo)); #if defined(KERN_CPTIME2) if (numcpu > 1) { for (i = 0; i < numcpu; i++) { int mib[] = {CTL_KERN, KERN_CPTIME2, i}; cpuinfo_size = sizeof (cpuinfo[0]); status = sysctl (mib, STATIC_ARRAY_SIZE (mib), cpuinfo[i], &cpuinfo_size, NULL, 0); if (status == -1) { char errbuf[1024]; ERROR ("cpu plugin: sysctl failed: %s.", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } } } else #endif /* defined(KERN_CPTIME2) */ { int mib[] = {CTL_KERN, KERN_CPTIME}; long cpuinfo_tmp[CPUSTATES]; cpuinfo_size = sizeof(cpuinfo_tmp); status = sysctl (mib, STATIC_ARRAY_SIZE (mib), &cpuinfo_tmp, &cpuinfo_size, NULL, 0); if (status == -1) { char errbuf[1024]; ERROR ("cpu plugin: sysctl failed: %s.", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } for(i = 0; i < CPUSTATES; i++) { cpuinfo[0][i] = cpuinfo_tmp[i]; } } for (i = 0; i < numcpu; i++) { submit (i, "user", cpuinfo[i][CP_USER]); submit (i, "nice", cpuinfo[i][CP_NICE]); submit (i, "system", cpuinfo[i][CP_SYS]); submit (i, "idle", cpuinfo[i][CP_IDLE]); submit (i, "interrupt", cpuinfo[i][CP_INTR]); } /* #endif CAN_USE_SYSCTL */ #elif defined(HAVE_SYSCTLBYNAME) long cpuinfo[CPUSTATES]; size_t cpuinfo_size; cpuinfo_size = sizeof (cpuinfo); if (sysctlbyname("kern.cp_time", &cpuinfo, &cpuinfo_size, NULL, 0) < 0) { char errbuf[1024]; ERROR ("cpu plugin: sysctlbyname failed: %s.", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } submit (0, "user", cpuinfo[CP_USER]); submit (0, "nice", cpuinfo[CP_NICE]); submit (0, "system", cpuinfo[CP_SYS]); submit (0, "idle", cpuinfo[CP_IDLE]); submit (0, "interrupt", cpuinfo[CP_INTR]); /* #endif HAVE_SYSCTLBYNAME */ #elif defined(HAVE_LIBSTATGRAB) sg_cpu_stats *cs; cs = sg_get_cpu_stats (); if (cs == NULL) { ERROR ("cpu plugin: sg_get_cpu_stats failed."); return (-1); } submit (0, "idle", (counter_t) cs->idle); submit (0, "nice", (counter_t) cs->nice); submit (0, "swap", (counter_t) cs->swap); submit (0, "system", (counter_t) cs->kernel); submit (0, "user", (counter_t) cs->user); submit (0, "wait", (counter_t) cs->iowait); #endif /* HAVE_LIBSTATGRAB */ return (0); }
static int cpu_read (void) { #if PROCESSOR_CPU_LOAD_INFO || PROCESSOR_TEMPERATURE int cpu; kern_return_t status; #if PROCESSOR_CPU_LOAD_INFO processor_cpu_load_info_data_t cpu_info; mach_msg_type_number_t cpu_info_len; #endif #if PROCESSOR_TEMPERATURE processor_info_data_t cpu_temp; mach_msg_type_number_t cpu_temp_len; #endif host_t cpu_host; for (cpu = 0; cpu < cpu_list_len; cpu++) { #if PROCESSOR_CPU_LOAD_INFO derive_t derives[CPU_SUBMIT_MAX] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; memset(derives, -1, sizeof(derives)); cpu_host = 0; cpu_info_len = PROCESSOR_BASIC_INFO_COUNT; if ((status = processor_info (cpu_list[cpu], PROCESSOR_CPU_LOAD_INFO, &cpu_host, (processor_info_t) &cpu_info, &cpu_info_len)) != KERN_SUCCESS) { ERROR ("cpu plugin: processor_info failed with status %i", (int) status); continue; } if (cpu_info_len < CPU_STATE_MAX) { ERROR ("cpu plugin: processor_info returned only %i elements..", cpu_info_len); continue; } derives[CPU_SUBMIT_USER] = (derive_t) cpu_info.cpu_ticks[CPU_STATE_USER]; derives[CPU_SUBMIT_NICE] = (derive_t) cpu_info.cpu_ticks[CPU_STATE_NICE]; derives[CPU_SUBMIT_SYSTEM] = (derive_t) cpu_info.cpu_ticks[CPU_STATE_SYSTEM]; derives[CPU_SUBMIT_IDLE] = (derive_t) cpu_info.cpu_ticks[CPU_STATE_IDLE]; submit (cpu, derives); #endif /* PROCESSOR_CPU_LOAD_INFO */ #if PROCESSOR_TEMPERATURE /* * Not all Apple computers do have this ability. To minimize * the messages sent to the syslog we do an exponential * stepback if `processor_info' fails. We still try ~once a day * though.. */ if (cpu_temp_retry_counter > 0) { cpu_temp_retry_counter--; continue; } cpu_temp_len = PROCESSOR_INFO_MAX; status = processor_info (cpu_list[cpu], PROCESSOR_TEMPERATURE, &cpu_host, cpu_temp, &cpu_temp_len); if (status != KERN_SUCCESS) { ERROR ("cpu plugin: processor_info failed: %s", mach_error_string (status)); cpu_temp_retry_counter = cpu_temp_retry_step; cpu_temp_retry_step *= 2; if (cpu_temp_retry_step > cpu_temp_retry_max) cpu_temp_retry_step = cpu_temp_retry_max; continue; } if (cpu_temp_len != 1) { DEBUG ("processor_info (PROCESSOR_TEMPERATURE) returned %i elements..?", (int) cpu_temp_len); continue; } cpu_temp_retry_counter = 0; cpu_temp_retry_step = 1; #endif /* PROCESSOR_TEMPERATURE */ } submit_flush (); /* #endif PROCESSOR_CPU_LOAD_INFO */ #elif defined(KERNEL_LINUX) int cpu; FILE *fh; char buf[1024]; char *fields[9]; int numfields; if ((fh = fopen ("/proc/stat", "r")) == NULL) { char errbuf[1024]; ERROR ("cpu plugin: fopen (/proc/stat) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } while (fgets (buf, 1024, fh) != NULL) { derive_t derives[CPU_SUBMIT_MAX] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; if (strncmp (buf, "cpu", 3)) continue; if ((buf[3] < '0') || (buf[3] > '9')) continue; numfields = strsplit (buf, fields, 9); if (numfields < 5) continue; cpu = atoi (fields[0] + 3); derives[CPU_SUBMIT_USER] = atoll(fields[1]); derives[CPU_SUBMIT_NICE] = atoll(fields[2]); derives[CPU_SUBMIT_SYSTEM] = atoll(fields[3]); derives[CPU_SUBMIT_IDLE] = atoll(fields[4]); if (numfields >= 8) { derives[CPU_SUBMIT_WAIT] = atoll(fields[5]); derives[CPU_SUBMIT_INTERRUPT] = atoll(fields[6]); derives[CPU_SUBMIT_SOFTIRQ] = atoll(fields[6]); if (numfields >= 9) derives[CPU_SUBMIT_STEAL] = atoll(fields[8]); } submit(cpu, derives); } submit_flush(); fclose (fh); /* #endif defined(KERNEL_LINUX) */ #elif defined(HAVE_LIBKSTAT) int cpu; static cpu_stat_t cs; if (kc == NULL) return (-1); for (cpu = 0; cpu < numcpu; cpu++) { derive_t derives[CPU_SUBMIT_MAX] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; if (kstat_read (kc, ksp[cpu], &cs) == -1) continue; /* error message? */ memset(derives, -1, sizeof(derives)); derives[CPU_SUBMIT_IDLE] = cs.cpu_sysinfo.cpu[CPU_IDLE]; derives[CPU_SUBMIT_USER] = cs.cpu_sysinfo.cpu[CPU_USER]; derives[CPU_SUBMIT_SYSTEM] = cs.cpu_sysinfo.cpu[CPU_KERNEL]; derives[CPU_SUBMIT_WAIT] = cs.cpu_sysinfo.cpu[CPU_WAIT]; submit (ksp[cpu]->ks_instance, derives); } submit_flush (); /* #endif defined(HAVE_LIBKSTAT) */ #elif CAN_USE_SYSCTL uint64_t cpuinfo[numcpu][CPUSTATES]; size_t cpuinfo_size; int status; int i; if (numcpu < 1) { ERROR ("cpu plugin: Could not determine number of " "installed CPUs using sysctl(3)."); return (-1); } memset (cpuinfo, 0, sizeof (cpuinfo)); #if defined(KERN_CPTIME2) if (numcpu > 1) { for (i = 0; i < numcpu; i++) { int mib[] = {CTL_KERN, KERN_CPTIME2, i}; cpuinfo_size = sizeof (cpuinfo[0]); status = sysctl (mib, STATIC_ARRAY_SIZE (mib), cpuinfo[i], &cpuinfo_size, NULL, 0); if (status == -1) { char errbuf[1024]; ERROR ("cpu plugin: sysctl failed: %s.", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } } } else #endif /* defined(KERN_CPTIME2) */ { int mib[] = {CTL_KERN, KERN_CPTIME}; long cpuinfo_tmp[CPUSTATES]; cpuinfo_size = sizeof(cpuinfo_tmp); status = sysctl (mib, STATIC_ARRAY_SIZE (mib), &cpuinfo_tmp, &cpuinfo_size, NULL, 0); if (status == -1) { char errbuf[1024]; ERROR ("cpu plugin: sysctl failed: %s.", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } for(i = 0; i < CPUSTATES; i++) { cpuinfo[0][i] = cpuinfo_tmp[i]; } } for (i = 0; i < numcpu; i++) { derive_t derives[CPU_SUBMIT_MAX] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; derives[CPU_SUBMIT_USER] = cpuinfo[i][CP_USER]; derives[CPU_SUBMIT_NICE] = cpuinfo[i][CP_NICE]; derives[CPU_SUBMIT_SYSTEM] = cpuinfo[i][CP_SYS]; derives[CPU_SUBMIT_IDLE] = cpuinfo[i][CP_IDLE]; derives[CPU_SUBMIT_INTERRUPT] = cpuinfo[i][CP_INTR]; submit(i, derives); } submit_flush(); /* #endif CAN_USE_SYSCTL */ #elif defined(HAVE_SYSCTLBYNAME) && defined(HAVE_SYSCTL_KERN_CP_TIMES) long cpuinfo[maxcpu][CPUSTATES]; size_t cpuinfo_size; int i; memset (cpuinfo, 0, sizeof (cpuinfo)); cpuinfo_size = sizeof (cpuinfo); if (sysctlbyname("kern.cp_times", &cpuinfo, &cpuinfo_size, NULL, 0) < 0) { char errbuf[1024]; ERROR ("cpu plugin: sysctlbyname failed: %s.", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } for (i = 0; i < numcpu; i++) { derive_t derives[CPU_SUBMIT_MAX] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; derives[CPU_SUBMIT_USER] = cpuinfo[i][CP_USER]; derives[CPU_SUBMIT_NICE] = cpuinfo[i][CP_NICE]; derives[CPU_SUBMIT_SYSTEM] = cpuinfo[i][CP_SYS]; derives[CPU_SUBMIT_IDLE] = cpuinfo[i][CP_IDLE]; derives[CPU_SUBMIT_INTERRUPT] = cpuinfo[i][CP_INTR]; submit(i, derives); } submit_flush(); /* #endif HAVE_SYSCTL_KERN_CP_TIMES */ #elif defined(HAVE_SYSCTLBYNAME) long cpuinfo[CPUSTATES]; size_t cpuinfo_size; derive_t derives[CPU_SUBMIT_MAX] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; cpuinfo_size = sizeof (cpuinfo); if (sysctlbyname("kern.cp_time", &cpuinfo, &cpuinfo_size, NULL, 0) < 0) { char errbuf[1024]; ERROR ("cpu plugin: sysctlbyname failed: %s.", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } derives[CPU_SUBMIT_USER] = cpuinfo[CP_USER]; derives[CPU_SUBMIT_SYSTEM] = cpuinfo[CP_SYS]; derives[CPU_SUBMIT_NICE] = cpuinfo[CP_NICE]; derives[CPU_SUBMIT_IDLE] = cpuinfo[CP_IDLE]; derives[CPU_SUBMIT_INTERRUPT] = cpuinfo[CP_INTR]; submit(0, derives); submit_flush(); /* #endif HAVE_SYSCTLBYNAME */ #elif defined(HAVE_LIBSTATGRAB) sg_cpu_stats *cs; derive_t derives[CPU_SUBMIT_MAX] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; cs = sg_get_cpu_stats (); if (cs == NULL) { ERROR ("cpu plugin: sg_get_cpu_stats failed."); return (-1); } derives[CPU_SUBMIT_IDLE] = (derive_t) cs->idle; derives[CPU_SUBMIT_NICE] = (derive_t) cs->nice; derives[CPU_SUBMIT_SWAP] = (derive_t) cs->swap; derives[CPU_SUBMIT_SYSTEM] = (derive_t) cs->kernel; derives[CPU_SUBMIT_USER] = (derive_t) cs->user; derives[CPU_SUBMIT_WAIT] = (derive_t) cs->iowait; submit(0, derives); submit_flush(); /* #endif HAVE_LIBSTATGRAB */ #elif defined(HAVE_PERFSTAT) perfstat_id_t id; int i, cpus; numcpu = perfstat_cpu(NULL, NULL, sizeof(perfstat_cpu_t), 0); if(numcpu == -1) { char errbuf[1024]; WARNING ("cpu plugin: perfstat_cpu: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } if (pnumcpu != numcpu || perfcpu == NULL) { if (perfcpu != NULL) free(perfcpu); perfcpu = malloc(numcpu * sizeof(perfstat_cpu_t)); } pnumcpu = numcpu; id.name[0] = '\0'; if ((cpus = perfstat_cpu(&id, perfcpu, sizeof(perfstat_cpu_t), numcpu)) < 0) { char errbuf[1024]; WARNING ("cpu plugin: perfstat_cpu: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } for (i = 0; i < cpus; i++) { derive_t derives[CPU_SUBMIT_MAX] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; derives[CPU_SUBMIT_IDLE] = perfcpu[i].idle; derives[CPU_SUBMIT_SYSTEM] = perfcpu[i].sys; derives[CPU_SUBMIT_USER] = perfcpu[i].user; derives[CPU_SUBMIT_WAIT] = perfcpu[i].wait; submit(i, derives); } submit_flush(); #endif /* HAVE_PERFSTAT */ return (0); }
namespace_ens_begin void CtinyWingsTerrainSprite::init(float width,float height,int insertControlPointCount){ this->CCSprite::init(); m_width=width; m_height=height; m_pointMat.resize(m_nRow); vector<CCPoint>&pointList=m_pointMat[0]; int nseg=ceilf(m_width/m_dx); m_dx=m_width/nseg;//revise dx int nPoint=nseg+1; for(int i=0;i<nPoint;i++){ float x=i*m_dx; CCPoint point(x,m_height); pointList.push_back(point); int nRow=(int)m_pointMat.size(); for(int j=1;j<nRow;j++){ CCPoint _point; _point.x=point.x; _point.y=point.y*(1-(float)j/(nRow-1));//must convert j to float !!! m_pointMat[j].push_back(_point); } }//got m_pointMat; //----create mesh m_mesh=new Cmesh(); m_mesh->autorelease(); m_mesh->retain(); //----create indexVBO m_indexVBO=new CindexVBO(); m_indexVBO->autorelease(); m_indexVBO->retain(); //----colorList m_colorList.push_back(ccc4f(random01(), random01(), random01(), 1)); m_colorList.push_back(ccc4f(random01(), random01(), random01(), 1)); m_colorList.push_back(ccc4f(random01(), random01(), random01(), 1)); //----reShape reGenerateShape(insertControlPointCount); //----update mesh updateMesh(); //----submitMesh submit(); //----create and set shader program { GLchar * fragSource = (GLchar*) CCString::createWithContentsOfFile(CCFileUtils::sharedFileUtils()->fullPathForFilename("shaders/tinyWingsTerrain_nonlinearTexCoord.fsh").c_str())->getCString(); CGLProgramWithUnifos* program = new CGLProgramWithUnifos(); program->autorelease(); program->initWithVertexShaderByteArray(ccPositionTextureColor_vert, fragSource); //bind attribute program->addAttribute(kCCAttributeNamePosition, kCCVertexAttrib_Position); program->addAttribute(kCCAttributeNameColor, kCCVertexAttrib_Color); program->addAttribute(kCCAttributeNameTexCoord, kCCVertexAttrib_TexCoords); //link (must after bindAttribute) program->link(); //get cocos2d-x build-in uniforms program->updateUniforms(); //get my own uniforms program->attachUniform("u_texNonlinearFactor"); program->attachUniform("u_colors"); program->attachUniform("u_cosA"); program->attachUniform("u_sinA"); program->attachUniform("u_ribbonRepeat"); //set program m_program=program; m_program->retain(); //check gl error CHECK_GL_ERROR_DEBUG(); } }
void AsyncIOQueue::submit(AsyncIOOp* op) { submit([op]() { return op; }); }
/* ********************************************************************* */ void OcularDialog::createDialogContent() { ui->setupUi(dialog); connect(&StelApp::getInstance(), SIGNAL(languageChanged()), this, SLOT(retranslate())); ui->ccdListView->setModel(ccdTableModel); ui->ocularListView->setModel(ocularTableModel); ui->telescopeListView->setModel(telescopeTableModel); ui->lensListView->setModel(lensTableModel); // Kinetic scrolling kineticScrollingList << ui->textBrowser << ui->telescopeListView << ui->ccdListView << ui->ocularListView << ui->lensListView; StelGui* gui= dynamic_cast<StelGui*>(StelApp::getInstance().getGui()); if (gui) { enableKineticScrolling(gui->getFlagUseKineticScrolling()); connect(gui, SIGNAL(flagUseKineticScrollingChanged(bool)), this, SLOT(enableKineticScrolling(bool))); } //Now the rest of the actions. connect(ui->closeStelWindow, SIGNAL(clicked()), this, SLOT(close())); connect(ui->TitleBar, SIGNAL(movedTo(QPoint)), this, SLOT(handleMovedTo(QPoint))); connectBoolProperty(ui->checkBoxControlPanel, "Oculars.flagGuiPanelEnabled"); connectIntProperty(ui->guiFontSizeSpinBox, "Oculars.guiPanelFontSize"); connectBoolProperty(ui->checkBoxInitialFOV, "Oculars.flagInitFOVUsage"); connectBoolProperty(ui->checkBoxInitialDirection, "Oculars.flagInitDirectionUsage"); connectBoolProperty(ui->checkBoxResolutionCriterion, "Oculars.flagShowResolutionCriterions"); connectBoolProperty(ui->requireSelectionCheckBox, "Oculars.flagRequireSelection"); connectBoolProperty(ui->limitStellarMagnitudeCheckBox, "Oculars.flagLimitMagnitude"); connectBoolProperty(ui->hideGridsLinesCheckBox, "Oculars.flagHideGridsLines"); connectBoolProperty(ui->scaleImageCircleCheckBox, "Oculars.flagScaleImageCircle"); connectBoolProperty(ui->semiTransparencyCheckBox, "Oculars.flagSemiTransparency"); connectBoolProperty(ui->checkBoxDMSDegrees, "Oculars.flagDMSDegrees"); connectBoolProperty(ui->checkBoxTypeOfMount, "Oculars.flagAutosetMountForCCD"); connectBoolProperty(ui->checkBoxTelradFOVScaling, "Oculars.flagScalingFOVForTelrad"); connectBoolProperty(ui->checkBoxToolbarButton, "Oculars.flagShowOcularsButton"); connectDoubleProperty(ui->arrowButtonScaleDoubleSpinBox, "Oculars.arrowButtonScale"); connectBoolProperty(ui->checkBoxShowCcdCropOverlay, "Oculars.flagShowCcdCropOverlay"); connectIntProperty(ui->guiCcdCropOverlaySizeSpinBox, "Oculars.ccdCropOverlaySize"); // The add & delete buttons connect(ui->addCCD, SIGNAL(clicked()), this, SLOT(insertNewCCD())); connect(ui->deleteCCD, SIGNAL(clicked()), this, SLOT(deleteSelectedCCD())); connect(ui->addOcular, SIGNAL(clicked()), this, SLOT(insertNewOcular())); connect(ui->deleteOcular, SIGNAL(clicked()), this, SLOT(deleteSelectedOcular())); connect(ui->addLens, SIGNAL(clicked()), this, SLOT(insertNewLens())); connect(ui->deleteLens, SIGNAL(clicked()), this, SLOT(deleteSelectedLens())); connect(ui->addTelescope, SIGNAL(clicked()), this, SLOT(insertNewTelescope())); connect(ui->deleteTelescope, SIGNAL(clicked()), this, SLOT(deleteSelectedTelescope())); // Validators ui->ccdName->setValidator(validatorName); ui->ocularName->setValidator(validatorName); ui->telescopeName->setValidator(validatorName); ui->lensName->setValidator(validatorName); initAboutText(); connect(ui->pushButtonMoveOcularUp, SIGNAL(pressed()), this, SLOT(moveUpSelectedOcular())); connect(ui->pushButtonMoveOcularDown, SIGNAL(pressed()), this, SLOT(moveDownSelectedOcular())); connect(ui->pushButtonMoveSensorUp, SIGNAL(pressed()), this, SLOT(moveUpSelectedSensor())); connect(ui->pushButtonMoveSensorDown, SIGNAL(pressed()), this, SLOT(moveDownSelectedSensor())); connect(ui->pushButtonMoveTelescopeUp, SIGNAL(pressed()), this, SLOT(moveUpSelectedTelescope())); connect(ui->pushButtonMoveTelescopeDown, SIGNAL(pressed()), this, SLOT(moveDownSelectedTelescope())); connect(ui->pushButtonMoveLensUp, SIGNAL(pressed()), this, SLOT(moveUpSelectedLens())); connect(ui->pushButtonMoveLensDown, SIGNAL(pressed()), this, SLOT(moveDownSelectedLens())); // The CCD mapper ccdMapper = new QDataWidgetMapper(); ccdMapper->setModel(ccdTableModel); ccdMapper->setSubmitPolicy(QDataWidgetMapper::AutoSubmit); ccdMapper->addMapping(ui->ccdName, 0); ccdMapper->addMapping(ui->ccdChipY, 1); ccdMapper->addMapping(ui->ccdChipX, 2); ccdMapper->addMapping(ui->ccdPixelY, 3); ccdMapper->addMapping(ui->ccdPixelX, 4); ccdMapper->addMapping(ui->ccdResX, 5); ccdMapper->addMapping(ui->ccdResY, 6); ccdMapper->addMapping(ui->ccdRotAngle, 7); ccdMapper->addMapping(ui->ccdBinningX, 8); ccdMapper->addMapping(ui->ccdBinningY, 9); ccdMapper->addMapping(ui->OAG_checkBox, 10); ccdMapper->addMapping(ui->OAGPrismH, 11); ccdMapper->addMapping(ui->OAGPrismW, 12); ccdMapper->addMapping(ui->OAGDist, 13); ccdMapper->addMapping(ui->OAGPrismPA, 14); ccdMapper->toFirst(); connect(ui->ccdListView->selectionModel() , SIGNAL(currentRowChanged(QModelIndex, QModelIndex)), ccdMapper, SLOT(setCurrentModelIndex(QModelIndex))); connectDoubleProperty(ui->ccdRotAngle, "Oculars.selectedCCDRotationAngle"); ui->ccdListView->setSelectionBehavior(QAbstractItemView::SelectRows); ui->ccdListView->setCurrentIndex(ccdTableModel->index(0, 1)); connect(ui->ccdChipY, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->ccdChipX, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->ccdPixelY, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->ccdPixelX, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->ccdResX, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->ccdResY, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->ccdRotAngle, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->ccdBinningX, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->ccdBinningY, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->OAG_checkBox,SIGNAL(stateChanged(int)), ccdMapper, SLOT(submit())); connect(ui->OAGPrismH, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->OAGPrismW, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->OAGDist, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); connect(ui->OAGPrismPA, SIGNAL(editingFinished()), ccdMapper, SLOT(submit())); // The ocular mapper ocularMapper = new QDataWidgetMapper(); ocularMapper->setModel(ocularTableModel); ocularMapper->setSubmitPolicy(QDataWidgetMapper::AutoSubmit); ocularMapper->addMapping(ui->ocularName, 0); ocularMapper->addMapping(ui->ocularAFov, 1); ocularMapper->addMapping(ui->ocularFL, 2); ocularMapper->addMapping(ui->ocularFieldStop, 3); ocularMapper->addMapping(ui->binocularsCheckBox, 4, "checked"); ocularMapper->addMapping(ui->permanentCrosshairCheckBox, 5, "checked"); ocularMapper->toFirst(); connect(ui->ocularListView->selectionModel() , SIGNAL(currentRowChanged(QModelIndex, QModelIndex)), ocularMapper, SLOT(setCurrentModelIndex(QModelIndex))); ui->ocularListView->setSelectionBehavior(QAbstractItemView::SelectRows); ui->ocularListView->setCurrentIndex(ocularTableModel->index(0, 1)); // We need particular refresh methods to see immediate feedback. connect(ui->ocularAFov, SIGNAL(editingFinished()), this, SLOT(updateOcular())); connect(ui->ocularFL, SIGNAL(editingFinished()), this, SLOT(updateOcular())); connect(ui->ocularFieldStop, SIGNAL(editingFinished()), this, SLOT(updateOcular())); connect(ui->binocularsCheckBox, SIGNAL(stateChanged(int)), this, SLOT(updateOcular())); connect(ui->permanentCrosshairCheckBox, SIGNAL(stateChanged(int)), this, SLOT(updateOcular())); // The lens mapper lensMapper = new QDataWidgetMapper(); lensMapper->setModel(lensTableModel); lensMapper->setSubmitPolicy(QDataWidgetMapper::AutoSubmit); lensMapper->addMapping(ui->lensName, 0); lensMapper->addMapping(ui->lensMultiplier, 1); lensMapper->toFirst(); connect(ui->lensListView->selectionModel(), SIGNAL(currentRowChanged(QModelIndex, QModelIndex)), lensMapper, SLOT(setCurrentModelIndex(QModelIndex))); ui->lensListView->setSelectionBehavior(QAbstractItemView::SelectRows); ui->lensListView->setCurrentIndex(lensTableModel->index(0, 1)); connect(ui->lensMultiplier, SIGNAL(editingFinished()), this, SLOT(updateLens())); // The telescope mapper telescopeMapper = new QDataWidgetMapper(); telescopeMapper->setModel(telescopeTableModel); telescopeMapper->setSubmitPolicy(QDataWidgetMapper::AutoSubmit); telescopeMapper->addMapping(ui->telescopeName, 0); telescopeMapper->addMapping(ui->telescopeDiameter, 1); telescopeMapper->addMapping(ui->telescopeFL, 2); telescopeMapper->addMapping(ui->telescopeHFlip, 3, "checked"); telescopeMapper->addMapping(ui->telescopeVFlip, 4, "checked"); telescopeMapper->addMapping(ui->telescopeEQ, 5, "checked"); telescopeMapper->toFirst(); connect(ui->telescopeListView->selectionModel() , SIGNAL(currentRowChanged(QModelIndex, QModelIndex)), telescopeMapper, SLOT(setCurrentModelIndex(QModelIndex))); ui->telescopeListView->setSelectionBehavior(QAbstractItemView::SelectRows); ui->telescopeListView->setCurrentIndex(telescopeTableModel->index(0, 1)); connect(ui->telescopeDiameter, SIGNAL(editingFinished()), this, SLOT(updateTelescope())); connect(ui->telescopeFL, SIGNAL(editingFinished()), this, SLOT(updateTelescope())); connect(ui->telescopeHFlip, SIGNAL(stateChanged(int)), this, SLOT(updateTelescope())); connect(ui->telescopeVFlip, SIGNAL(stateChanged(int)), this, SLOT(updateTelescope())); connect(ui->telescopeEQ, SIGNAL(stateChanged(int)), this, SLOT(updateTelescope())); connect(ui->binocularsCheckBox, SIGNAL(toggled(bool)), this, SLOT(setLabelsDescriptionText(bool))); }
bool DhQAbstractTableModel::Dvhsubmit() { return submit(); }
bool DhQAbstractProxyModel::Dvhsubmit() { return submit(); }
int process( int socket ) { char msg_c[BUF]; //buffer that will hold client msg bzero(msg_c, BUF); char* tmp; char* id; char* command; char* arg; int msg_size; /* Get message from client */ if( (msg_size = read( socket, msg_c, BUF)) < 0) { } else { tmp = msg_c; id = strsep(&tmp, ","); printf("id: %s \n", id); command = strsep(&tmp, ","); printf("Command: %s \n", command); arg = strsep(&tmp, ","); printf("Arg: %s \n", arg); int command_int = atoi(command); char to_ret[sizeof(char)*BUFSIZE]; switch(command_int) { case 4: submit(id, arg, socket ); break; case 1: get_next( id, socket ); break; case 2: get_all( id, socket ); break; case 7: leave( id, socket ); break; case 5: join(socket); break; default: sprintf(to_ret,"%s", " Command not Understood"); break; }//end switch printf("Closed socket \n"); } return msg_size; }//end process
// [SLOT] - slot when pressing next button in creator void creatordialog::on_pushButton_clicked() { #if (DEBUG_ACTIVE==true) qDebug()<<"level="<<level; qDebug()<<"table"<<table; qDebug()<<"CHECKBOX 1:"<<relational_table; qDebug()<<"CHECKBOX 2:"<<relational_table_2; qDebug()<<"first table:"<<first_table; qDebug()<<"second table"<<second_table<<endl; #endif if(ui->checkBox->isChecked()==false && ui->checkBox_2->isChecked()==false && relation==false) { QMessageBox::information(this,"Informacja","Nie nadano relacji"); this->accept(); return; } switch(level) { case 0: ui->stackedWidget->setCurrentIndex(level+1); if(relational_table=="") { #if (DEBUG_ACTIVE==true) qDebug()<<"open_model1"<<relational_table_2<<endl; #endif if(creator_model!=NULL) delete creator_model; creator_model=NULL; creator_model = new QSqlRelationalTableModel(this); init_relation_model(creator_model,ui->tableView_CREATOR_1,relational_table_2); } else if(relational_table_2=="") { #if (DEBUG_ACTIVE==true) qDebug()<<"open_model2"<<relational_table; #endif if(creator_model!=NULL) delete creator_model; creator_model=NULL; creator_model = new QSqlRelationalTableModel(this); init_relation_model(creator_model,ui->tableView_CREATOR_1,relational_table); } else if(relational_table_2!="" && relational_table!="") { #if (DEBUG_ACTIVE==true) qDebug()<<"open_model3"<<relational_table; #endif if(creator_model!=NULL) delete creator_model; creator_model=NULL; creator_model = new QSqlRelationalTableModel(this); init_relation_model(creator_model,ui->tableView_CREATOR_1,relational_table); } if(table_constructor=="Daneosobowe" || table_constructor=="Czesci" || relational_table_2=="" || relational_table=="") { ui->stackedWidget->setCurrentIndex(level+1); ui->pushButton->setIcon(QIcon(path + "/obrazy/exit.png")); ui->pushButton->setIconSize(QSize(40, 40)); } break; case 1: if(table_constructor=="Daneosobowe" || table_constructor=="Czesci" || relational_table_2=="" || relational_table=="") { level=2; } else { if(!relation) { if(!submit(creator_model))break; } #if (DEBUG_ACTIVE==true) qDebug()<<"open_model_2"<<relational_table_2<<endl; #endif init_relation_model(creator_model,ui->tableView_CREATOR_2,relational_table_2); ui->stackedWidget->setCurrentIndex(level+1); ui->pushButton->setIcon(QIcon(path + "/obrazy/exit.png")); ui->pushButton->setIconSize(QSize(40, 40)); break; } case 2: if(!submit(creator_model))break; QMessageBox::information(this,"Informacja","Relacje nadane pomyślnie"); level=0; this->accept(); return; } level++; }