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++;
}
