static void f7_prog(int mode) { int pos=1; void *pscr=NULL; if(mode>2) { messanykey(10,15," Highlight the corresponding\n" "structure function"); return; } if(!sf_num[mode-1]) return; f3_key[4]=NULL; for(;;) { static double xMin=0.0, xMax=1.0, scale = 91.187; static int nPoints=100; double f[150]; char strmen[]="\030 " " x-Min = XXX " " x-Max = YYY " " Npoints = NNN " " QCD-scale= QQQ " " Display plot x*F(x) " " Display plot F(x) "; improveStr(strmen,"XXX","%.3f",xMin); improveStr(strmen,"YYY","%.3f",xMax); improveStr(strmen,"NNN","%d",nPoints); improveStr(strmen,"QQQ","%.1fGeV",scale); menu1(54,14,"",strmen,"n_alpha_view",&pscr,&pos); switch(pos) { case 0: f3_key[4]=f7_prog; return; case 1: correctDouble(55,18,"xMin = ",&xMin,1); break; case 2: correctDouble(55,18,"xMax = ",&xMax,1); break; case 3: correctInt(50,18,"nPoints = ",&nPoints,1); break; case 4: correctDouble(50,18,"QCD-scale = ",&scale,1); break; case 5: case 6: if(xMin>=0 && xMax>xMin && xMax<=1 && nPoints>=3 && nPoints<=150 && scale>0.5) { void * screen; double dx=(xMax-xMin)/(2*nPoints); double be=sf_be[mode-1]; int i; get_text(1,1,maxCol(),maxRow(),&screen); for(i=0;i<nPoints;i++) { double x=xMin+(i+0.5)*(xMax-xMin)/nPoints; f[i]=strfun_(mode,x,scale); if(pos==5) f[i]*=x; if(be!=1.) f[i]*=be*pow(1.-x,be-1.); } { char p_name[20], mess[STRSIZ]; strcpy(p_name,pinf_int(Nsub,mode,NULL,NULL)); if(pos==5) strcat(p_name,"(x)*x"); else strcat(p_name,"(x)"); strFunName(mode,mess); trim(mess); sprintf(mess+strlen(mess)," [QCD-scale = %.1f GeV]",scale); plot_1(xMin+dx,xMax-dx,nPoints,f,NULL,mess,"x",p_name); } put_text(&screen); } else messanykey(16,5," Correct input is \n" " 0<=xMin<xMax<=1,\n" " QCD-scale > 0.5 GeV\n" " 3<=nPoints<=150"); break; } } }
int main(int argc, char* argv[]) { DWORD err; CPco_cl_com camera; CPco_me4_edge grabber; int board=0; char infostr[100]; char number[20]; int x; char c; int ima_count=100; int loop_count=1; int PicTimeOut=10000; //10 seconds WORD act_recstate; DWORD exp_time,delay_time,pixelrate; DWORD width,height,secs,nsecs; SC2_Camera_Description_Response description; PCO_SC2_CL_TRANSFER_PARAM clpar; int bufnum=20; double freq; SHORT ccdtemp,camtemp,pstemp; WORD camtype; DWORD serialnumber; WORD actlut,lutparam; // log.set_logbits(0x0001FFFF); printf("Logging set to 0x%x\n",log.get_logbits()); camera.log=&log; grabber.log=&log; printf("Try to open Camera\n"); err=camera.Open_Cam(0); if(err!=PCO_NOERROR) { printf("error 0x%x in Open_Cam, close application",err); getchar(); return -1; } err=camera.PCO_GetCameraType(&camtype,&serialnumber); if((err!=PCO_NOERROR)||(camtype!=CAMERATYPE_PCO_EDGE)) { printf("Wrong camera for this application"); camera.Close_Cam(); getchar(); return -1; } printf("Try to open Grabber\n"); err=grabber.Open_Grabber(board); if(err!=PCO_NOERROR) { printf("error 0x%x in Open_Grabber, close application",err); camera.Close_Cam(); getchar(); return -1; } exp_time=5000; delay_time=1000; err=camera.PCO_GetCameraDescriptor(&description); if(err!=PCO_NOERROR) printf("PCO_GetCameraDescriptor() Error 0x%x\n",err); err=camera.PCO_GetInfo(1,infostr,sizeof(infostr)); if(err!=PCO_NOERROR) printf("PCO_GetInfo() Error 0x%x\n",err); else printf("Camera Name is: %s serialnumber %d\n",infostr,serialnumber); err=camera.PCO_SetCameraToCurrentTime(); if(err!=PCO_NOERROR) printf("PCO_SetCameraToCurrentTime() Error 0x%x\n",err); err=camera.PCO_GetTransferParameter(&clpar,sizeof(clpar)); if(err!=PCO_NOERROR) printf("PCO_GetTransferParameter() Error 0x%x\n",err); else { printf("Baudrate : %d\n",clpar.baudrate); printf("Clockfrequency: %d\n",clpar.ClockFrequency); printf("Dataformat : 0x%x\n",clpar.DataFormat); printf("Transmit : 0x%x\n",clpar.Transmit); } err=camera.PCO_GetTemperature(&ccdtemp,&camtemp,&pstemp); if(err!=PCO_NOERROR) printf("PCO_GetTemperature() Error 0x%x\n",err); else { printf("current temperatures\n"); printf("Sensor: %d\n",ccdtemp); printf("Camera: %d\n",camtemp); printf("PowerSupply: %d\n",pstemp); } err=camera.PCO_GetPixelRate(&pixelrate); if(err!=PCO_NOERROR) printf("PCO_GetPixelrate() Error 0x%x\n",err); else printf("actual PixelRate: %d\n",pixelrate); printf("possible PixelRates:\n"); for(x=0;x<4;x++) { if(description.dwPixelRateDESC[x]!=0) { printf("%d: %d\n",x,description.dwPixelRateDESC[x]); } } err=camera.PCO_GetLut(&actlut,&lutparam); if(err!=PCO_NOERROR) printf("PCO_GetLut() Error 0x%x\n",err); //set RecordingState to STOP err=camera.PCO_SetRecordingState(0); if(err!=PCO_NOERROR) printf("PCO_SetRecordingState() Error 0x%x\n",err); err=camera.PCO_SetTimestampMode(2); if(err!=PCO_NOERROR) printf("PCO_SetTimestampMode() Error 0x%x\n",err); //set camera timebase to ms err=camera.PCO_SetTimebase(1,1); if(err!=PCO_NOERROR) printf("PCO_SetTimebase() Error 0x%x\n",err); err=camera.PCO_SetDelayExposure(delay_time,exp_time); if(err!=PCO_NOERROR) printf("PCO_SetDelayExposure() Error 0x%x\n",err); //prepare Camera for recording err=camera.PCO_ArmCamera(); if(err!=PCO_NOERROR) printf("PCO_ArmCamera() Error 0x%x\n",err); err=camera.PCO_GetActualSize(&width,&height); if(err!=PCO_NOERROR) printf("PCO_GetActualSize() Error 0x%x\n",err); printf("Actual Resolution %d x %d\n",width,height); //transfer dataformat must be changed depending on pixelrate and horizontal resolution err=camera.PCO_GetPixelRate(&pixelrate); if(err!=PCO_NOERROR) printf("PCO_GetPixelrate() Error 0x%x\n",err); if((width>1920)&&(pixelrate>=286000000)) { clpar.DataFormat=SCCMOS_FORMAT_TOP_CENTER_BOTTOM_CENTER|PCO_CL_DATAFORMAT_5x12; printf("width>1920 %d && pixelrate >=286000000 %d Dataformat 0x%x\n",width,pixelrate,clpar.DataFormat); } else { clpar.DataFormat=SCCMOS_FORMAT_TOP_CENTER_BOTTOM_CENTER|PCO_CL_DATAFORMAT_5x16; printf("width<=1920 %d || pixelrate<286000000 %d Dataformat 0x%x\n",width,pixelrate,clpar.DataFormat); } err=camera.PCO_SetTransferParameter(&clpar,sizeof(clpar)); if(err!=PCO_NOERROR) printf("PCO_TransferParameter() Error 0x%x\n",err); err=camera.PCO_ArmCamera(); if(err!=PCO_NOERROR) printf("PCO_ArmCamera() Error 0x%x\n",err); err=grabber.Set_DataFormat(clpar.DataFormat); if(err!=PCO_NOERROR) printf("Set_DataFormat() Error 0x%x\n",err); err=grabber.Set_Grabber_Size(width,height); if(err!=PCO_NOERROR) printf("Set_Grabber_Size() Error 0x%x\n",err); err=grabber.Allocate_Framebuffer(20); if(err!=PCO_NOERROR) printf("Allocate_Framebuffer() Error 0x%x\n",err); err=camera.PCO_SetRecordingState(1); if(err!=PCO_NOERROR) printf("PCO_SetRecordingState() Error 0x%x\n",err); c=' '; while(c!='x') { int ch; c=' '; printf("\n"); camera.PCO_GetRecordingState(&act_recstate); camera.PCO_GetDelayExposure(&delay_time,&exp_time); camera.PCO_GetCOCRuntime(&secs,&nsecs); freq=nsecs; freq/=1000000000; freq+=secs; freq=1/freq; printf("actual recording state %s actual freq: %.3lfHz %.2lfMB/sec\n",act_recstate ? "RUN" : "STOP",freq,(freq*width*height*2)/(1024*1024)); printf("\n"); printf("x to close camera and program\n"); printf("l to set loop_count actual value =%d\n",loop_count); printf("c to set imagecount actual imagecount=%d\n",ima_count); printf("b to set number of allocated buffers actual =%d\n",bufnum); printf("t to set picture timeout actual timeout=%d\n",PicTimeOut); printf("e to set exposure time actual exposuretime=%dus\n",exp_time); printf("d to set delay time actual delaytime=%dus\n",delay_time); printf("f to set Dataformat 0x%x and LUT 0x%x\n",clpar.DataFormat,actlut); printf("p to set pixelrate actual pixelrate %d\n",pixelrate); printf("0 to set recording state to OFF\n"); printf("1 to set recording state to ON\n"); printf("2 Single Grab \n"); printf("3 Start Grab in allocated buffers\n"); printf("4 Start Grab loop (%d images)\n",ima_count); fflush(stdin); for( x = 0; (x < 2) && ((ch = getchar()) != EOF) && (ch != '\n'); x++ ) c=(char)ch; if(c=='c') { printf("enter ima_count ...<CR>: "); get_number(number,10); if(strlen(number)) ima_count=atoi(number); } else if(c=='l') { printf("enter loop_count ...<CR>: "); get_number(number,10); if(strlen(number)) loop_count=atoi(number); } else if(c=='b') { printf("enter number of buffers to allocate ...<CR>: "); get_number(number,5); if(strlen(number)) { int i=atoi(number); grabber.Free_Framebuffer(); if((err=grabber.Allocate_Framebuffer(i))!=PCO_NOERROR) { printf("Allocation failed use old number %d\n",bufnum); err=grabber.Allocate_Framebuffer(bufnum); printf("Any key <CR> to proceed"); getchar(); } else bufnum=i; } } else if(c=='t') { printf("enter picture timeout ...<CR>: "); get_number(number,10); if(strlen(number)) PicTimeOut=atoi(number); } else if(c=='e') { printf("enter new exposure time in us ...<CR>: "); get_number(number,10); if(strlen(number)) { exp_time=atoi(number); if(act_recstate==1) camera.PCO_SetRecordingState(0); err=camera.PCO_SetDelayExposure(delay_time,exp_time); err=camera.PCO_GetDelayExposure(&delay_time,&exp_time); err=camera.PCO_ArmCamera(); if(err!=PCO_NOERROR) printf("PCO_ArmCamera() Error 0x%x\n",err); if(act_recstate==1) camera.PCO_SetRecordingState(1); } } else if(c=='d') { printf("enter new delay time in us ...<CR>: "); get_number(number,10); if(strlen(number)) { delay_time=atoi(number); if(act_recstate==1) camera.PCO_SetRecordingState(0); err=camera.PCO_SetDelayExposure(delay_time,exp_time); err=camera.PCO_GetDelayExposure(&delay_time,&exp_time); err=camera.PCO_ArmCamera(); if(err!=PCO_NOERROR) printf("PCO_ArmCamera() Error 0x%x\n",err); if(act_recstate==1) camera.PCO_SetRecordingState(1); } } else if(c=='p') { printf("enter new pixelrate in MHz ...<CR>: "); get_number(number,4); if(strlen(number)) { unsigned int dataformat=clpar.DataFormat; DWORD p; int x; p=atoi(number)*1000*1000; for(x=0;x<4;x++) { if((p<description.dwPixelRateDESC[x]+1000*1000)&& (p>description.dwPixelRateDESC[x]-1000*1000)) { p=description.dwPixelRateDESC[x]; break; } } if(x>=4) { printf("pixelrate %d not supported",p); continue; } if(act_recstate==1) camera.PCO_SetRecordingState(0); err=camera.PCO_SetPixelRate(p); if(err!=PCO_NOERROR) printf("PCO_SetPixelRate() Error 0x%x\n",err); err=camera.PCO_ArmCamera(); if(err!=PCO_NOERROR) printf("PCO_ArmCamera() Error 0x%x\n",err); camera.PCO_GetPixelRate(&pixelrate); //this is a must do if((width>1920)&&(pixelrate>=286000000)) clpar.DataFormat=(clpar.DataFormat&~PCO_CL_DATAFORMAT_MASK)|PCO_CL_DATAFORMAT_5x12; //this is can do // else // clpar.DataFormat=(clpar.DataFormat&~PCO_CL_DATAFORMAT_MASK)|PCO_CL_DATAFORMAT_5x16; if(dataformat!=clpar.DataFormat) { err=camera.PCO_SetTransferParameter(&clpar,sizeof(clpar)); if(err!=PCO_NOERROR) printf("PCO_TransferParameter() Error 0x%x\n",err); err=camera.PCO_ArmCamera(); if(err!=PCO_NOERROR) printf("PCO_ArmCamera() Error 0x%x\n",err); err=grabber.Set_DataFormat(clpar.DataFormat); if(err!=PCO_NOERROR) printf("Set_DataFormat() Error 0x%x\n",err); err=grabber.Set_Grabber_Size(width,height); if(err!=PCO_NOERROR) printf("Set_Grabber_Size() Error 0x%x\n",err); } if(act_recstate==1) camera.PCO_SetRecordingState(1); } } else if(c=='f') { int dataformat,lut; dataformat=lut=-1; printf("enter new Dataformat in HEX ...<CR>: "); get_hexnumber(&dataformat,4); if((dataformat&SCCMOS_FORMAT_MASK)==0) dataformat|=SCCMOS_FORMAT_TOP_CENTER_BOTTOM_CENTER; if( ((dataformat& PCO_CL_DATAFORMAT_MASK)!=PCO_CL_DATAFORMAT_5x16) &&((dataformat& PCO_CL_DATAFORMAT_MASK)!=PCO_CL_DATAFORMAT_5x12) &&((dataformat& PCO_CL_DATAFORMAT_MASK)!=PCO_CL_DATAFORMAT_5x12L)) { printf("DataFormat 0x%x not supported" ,dataformat); continue; } printf("installed LUT's:\n"); for(int x=0;x<camera.num_lut;x++) printf("%d: '%20s' Id 0x%x %02d->%02d Format 0x%x\n",x+1 ,camera.cam_lut[x].Description,camera.cam_lut[x].wIdentifier ,camera.cam_lut[x].bInputWidth,camera.cam_lut[x].bOutputWidth ,camera.cam_lut[x].wFormat); printf("enter new LUT ID in HEX ...<CR>: "); get_hexnumber(&lut,4); if((dataformat>0)&&(lut>=0)) { if(act_recstate==1) camera.PCO_SetRecordingState(0); if((width>1920)&&(pixelrate>=286000000)) clpar.DataFormat=(dataformat&~PCO_CL_DATAFORMAT_MASK)|PCO_CL_DATAFORMAT_5x12; else clpar.DataFormat=dataformat; err=camera.PCO_SetTransferParameter(&clpar,sizeof(clpar)); if(err!=PCO_NOERROR) printf("PCO_TransferParameter() Error 0x%x\n",err); actlut=lut; err=camera.PCO_SetLut(actlut,0); if(err!=PCO_NOERROR) printf("PCO_TransferParameter() Error 0x%x\n",err); err=camera.PCO_ArmCamera(); if(err!=PCO_NOERROR) printf("PCO_ArmCamera() Error 0x%x\n",err); err=grabber.Set_DataFormat(clpar.DataFormat); if(err!=PCO_NOERROR) printf("Set_DataFormat() Error 0x%x\n",err); err=grabber.Set_Grabber_Size(width,height); if(err!=PCO_NOERROR) printf("Set_Grabber_Size() Error 0x%x\n",err); if(act_recstate==1) camera.PCO_SetRecordingState(1); } } else if(c=='0') { err=camera.PCO_SetRecordingState(0); if(err==PCO_NOERROR) printf("\nrecoding state is set to STOP\n"); } else if(c=='1') { err=camera.PCO_SetRecordingState(1); if(err==PCO_NOERROR) printf("\nrecoding state is set to RUN\n"); } else if(c=='2') { if(act_recstate==0) printf("\nStart Camera before grabbing\n"); else { char filename[300]; printf("enter filename ...<CR>: \n"); printf("if filename has suffix .b16 save image in b16 format\n"); printf("if filename has suffix .tif save image in tif format\n"); printf("if nothing is entered, no file will be saved\n"); get_text(filename,300); if(strlen(filename)) grab_single(&grabber,filename); else grab_single(&grabber); } printf("\n"); } else if(c=='3') { if(act_recstate==0) printf("\nStart Camera before grabbing\n"); else grab_count(&grabber,bufnum); printf("\n"); } else if(c=='4') { if(act_recstate==0) printf("\nStart Camera before grabbing\n"); else grab_loop(&grabber,ima_count); printf("\n"); } } err=grabber.Free_Framebuffer(); grabber.Close_Grabber(); camera.Close_Cam(); return 0; }
int TimeStretchFraction::handle_event() { plugin->scale = 1.0 / atof(get_text()); return 1; }
int VocoderBands::handle_event() { plugin->config.bands = atoi(get_text()); plugin->send_configure_change(); return 1; }
static int info_text( TEXT * text, REGION * bbox, int * z, int * drawme ) { const char * str = get_text( text ); REGION prev = *bbox; FONT * font; int changed = 0; * drawme = 0; // Splinter if ( !str || !*str ) { /* bbox->x = -2; bbox->y = -2; bbox->x2 = -2; bbox->y2 = -2; */ return 0; } font = gr_font_get( text->fontid ); if ( !font ) { /* bbox->x = -2; bbox->y = -2; bbox->x2 = -2; bbox->y2 = -2; */ return 0; } * drawme = 1; * z = text->z; /* Calculate the text dimensions */ text->_x = text->x; text->_y = text->y; text->_width = gr_text_width( text->fontid, ( const unsigned char * ) str ); text->_height = gr_text_height_no_margin( text->fontid, ( const unsigned char * ) str ); /* Update the font's maxheight (if needed) */ if ( !font->maxheight ) { int c; for ( c = 0 ; c < 256 ; c++ ) { if ( !font->glyph[c].bitmap ) continue; if ( font->maxheight < ( int )font->glyph[c].bitmap->height + font->glyph[c].yoffset ) font->maxheight = ( int )font->glyph[c].bitmap->height + font->glyph[c].yoffset; } } /* Adjust top-left coordinates for text alignment */ switch ( text->alignment ) { case ALIGN_TOP: // 1 case ALIGN_CENTER: // 4 case ALIGN_BOTTOM: // 7 text->_x -= text->_width / 2; break; case ALIGN_TOP_RIGHT: // 2 case ALIGN_CENTER_RIGHT: // 5 case ALIGN_BOTTOM_RIGHT: // 8 text->_x -= text->_width - 1; break; } switch ( text->alignment ) { case ALIGN_CENTER_LEFT: // 3 case ALIGN_CENTER: // 4 case ALIGN_CENTER_RIGHT: // 5 text->_y -= font->maxheight / 2; break; case ALIGN_BOTTOM_LEFT: // 6 case ALIGN_BOTTOM: // 7 case ALIGN_BOTTOM_RIGHT: // 8 text->_y -= font->maxheight - 1; break; } /* Fill the bounding box */ bbox->x = text->_x; bbox->y = text->_y; bbox->x2 = text->_x + text->_width - 1; bbox->y2 = text->_y + text->_height - 1; /* Check if the var has changed since last call */ changed = text->z != text->last_z || bbox->x != prev.x || bbox->y != prev.y || bbox->x2 != prev.x2 || bbox->y2 != prev.y2; text->last_z = text->z; switch ( text->on ) { case TEXT_TEXT: return changed; case TEXT_STRING: case TEXT_FLOAT: case TEXT_INT: case TEXT_DWORD: case TEXT_POINTER: if ( text->last_value == *( int * )text->var ) return changed; text->last_value = *( int * )text->var; return 1; case TEXT_BYTE: case TEXT_SBYTE: case TEXT_CHAR: if ( text->last_value == *( uint8_t * )text->var ) return changed; text->last_value = *( uint8_t * )text->var; return 1; case TEXT_WORD: case TEXT_SHORT: if ( text->last_value == *( uint16_t * )text->var ) return changed; text->last_value = *( uint16_t * )text->var; return 1; case TEXT_CHARARRAY: return 1; } return changed; }
int PrefsRenderFarmPort::handle_event() { pwindow->thread->preferences->renderfarm_port = atol(get_text()); return 1; }
void SkPicturePlayback::handleOp(SkReader32* reader, DrawType op, uint32_t size, SkCanvas* canvas, const SkMatrix& initialMatrix) { switch (op) { case NOOP: { SkASSERT(size >= 4); reader->skip(size - 4); } break; case CLIP_PATH: { const SkPath& path = fPictureData->getPath(reader); uint32_t packed = reader->readInt(); SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); bool doAA = ClipParams_unpackDoAA(packed); size_t offsetToRestore = reader->readInt(); SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset()); canvas->clipPath(path, regionOp, doAA); if (canvas->isClipEmpty() && offsetToRestore) { reader->setOffset(offsetToRestore); } } break; case CLIP_REGION: { SkRegion region; reader->readRegion(®ion); uint32_t packed = reader->readInt(); SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); size_t offsetToRestore = reader->readInt(); SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset()); canvas->clipRegion(region, regionOp); if (canvas->isClipEmpty() && offsetToRestore) { reader->setOffset(offsetToRestore); } } break; case CLIP_RECT: { const SkRect& rect = reader->skipT<SkRect>(); uint32_t packed = reader->readInt(); SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); bool doAA = ClipParams_unpackDoAA(packed); size_t offsetToRestore = reader->readInt(); SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset()); canvas->clipRect(rect, regionOp, doAA); if (canvas->isClipEmpty() && offsetToRestore) { reader->setOffset(offsetToRestore); } } break; case CLIP_RRECT: { SkRRect rrect; reader->readRRect(&rrect); uint32_t packed = reader->readInt(); SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); bool doAA = ClipParams_unpackDoAA(packed); size_t offsetToRestore = reader->readInt(); SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset()); canvas->clipRRect(rrect, regionOp, doAA); if (canvas->isClipEmpty() && offsetToRestore) { reader->setOffset(offsetToRestore); } } break; case PUSH_CULL: break; // Deprecated, safe to ignore both push and pop. case POP_CULL: break; case CONCAT: { SkMatrix matrix; reader->readMatrix(&matrix); canvas->concat(matrix); break; } case DRAW_ATLAS: { const SkPaint* paint = fPictureData->getPaint(reader); const SkImage* atlas = fPictureData->getImage(reader); const uint32_t flags = reader->readU32(); const int count = reader->readU32(); const SkRSXform* xform = (const SkRSXform*)reader->skip(count * sizeof(SkRSXform)); const SkRect* tex = (const SkRect*)reader->skip(count * sizeof(SkRect)); const SkColor* colors = nullptr; SkXfermode::Mode mode = SkXfermode::kDst_Mode; if (flags & DRAW_ATLAS_HAS_COLORS) { colors = (const SkColor*)reader->skip(count * sizeof(SkColor)); mode = (SkXfermode::Mode)reader->readU32(); } const SkRect* cull = nullptr; if (flags & DRAW_ATLAS_HAS_CULL) { cull = (const SkRect*)reader->skip(sizeof(SkRect)); } canvas->drawAtlas(atlas, xform, tex, colors, count, mode, cull, paint); } break; case DRAW_BITMAP: { const SkPaint* paint = fPictureData->getPaint(reader); const SkBitmap bitmap = shallow_copy(fPictureData->getBitmap(reader)); const SkPoint& loc = reader->skipT<SkPoint>(); canvas->drawBitmap(bitmap, loc.fX, loc.fY, paint); } break; case DRAW_BITMAP_RECT: { const SkPaint* paint = fPictureData->getPaint(reader); const SkBitmap bitmap = shallow_copy(fPictureData->getBitmap(reader)); const SkRect* src = get_rect_ptr(reader); // may be null const SkRect& dst = reader->skipT<SkRect>(); // required SkCanvas::SrcRectConstraint constraint = (SkCanvas::SrcRectConstraint)reader->readInt(); canvas->legacy_drawBitmapRect(bitmap, src, dst, paint, constraint); } break; case DRAW_BITMAP_MATRIX: { const SkPaint* paint = fPictureData->getPaint(reader); const SkBitmap bitmap = shallow_copy(fPictureData->getBitmap(reader)); SkMatrix matrix; reader->readMatrix(&matrix); SkAutoCanvasRestore acr(canvas, true); canvas->concat(matrix); canvas->drawBitmap(bitmap, 0, 0, paint); } break; case DRAW_BITMAP_NINE: { const SkPaint* paint = fPictureData->getPaint(reader); const SkBitmap bitmap = shallow_copy(fPictureData->getBitmap(reader)); const SkIRect& src = reader->skipT<SkIRect>(); const SkRect& dst = reader->skipT<SkRect>(); canvas->drawBitmapNine(bitmap, src, dst, paint); } break; case DRAW_CLEAR: canvas->clear(reader->readInt()); break; case DRAW_DATA: { // This opcode is now dead, just need to skip it for backwards compatibility size_t length = reader->readInt(); (void)reader->skip(length); // skip handles padding the read out to a multiple of 4 } break; case DRAW_DRRECT: { const SkPaint& paint = *fPictureData->getPaint(reader); SkRRect outer, inner; reader->readRRect(&outer); reader->readRRect(&inner); canvas->drawDRRect(outer, inner, paint); } break; case BEGIN_COMMENT_GROUP: reader->readString(); // deprecated (M44) break; case COMMENT: reader->readString(); reader->readString(); // deprecated (M44) break; case END_COMMENT_GROUP: // deprecated (M44) break; case DRAW_IMAGE: { const SkPaint* paint = fPictureData->getPaint(reader); const SkImage* image = fPictureData->getImage(reader); const SkPoint& loc = reader->skipT<SkPoint>(); canvas->drawImage(image, loc.fX, loc.fY, paint); } break; case DRAW_IMAGE_NINE: { const SkPaint* paint = fPictureData->getPaint(reader); const SkImage* image = fPictureData->getImage(reader); const SkIRect& center = reader->skipT<SkIRect>(); const SkRect& dst = reader->skipT<SkRect>(); canvas->drawImageNine(image, center, dst, paint); } break; case DRAW_IMAGE_RECT_STRICT: case DRAW_IMAGE_RECT: { const SkPaint* paint = fPictureData->getPaint(reader); const SkImage* image = fPictureData->getImage(reader); const SkRect* src = get_rect_ptr(reader); // may be null const SkRect& dst = reader->skipT<SkRect>(); // required // DRAW_IMAGE_RECT_STRICT assumes this constraint, and doesn't store it SkCanvas::SrcRectConstraint constraint = SkCanvas::kStrict_SrcRectConstraint; if (DRAW_IMAGE_RECT == op) { // newer op-code stores the constraint explicitly constraint = (SkCanvas::SrcRectConstraint)reader->readInt(); } canvas->legacy_drawImageRect(image, src, dst, paint, constraint); } break; case DRAW_OVAL: { const SkPaint& paint = *fPictureData->getPaint(reader); canvas->drawOval(reader->skipT<SkRect>(), paint); } break; case DRAW_PAINT: canvas->drawPaint(*fPictureData->getPaint(reader)); break; case DRAW_PATCH: { const SkPaint& paint = *fPictureData->getPaint(reader); const SkPoint* cubics = (const SkPoint*)reader->skip(SkPatchUtils::kNumCtrlPts * sizeof(SkPoint)); uint32_t flag = reader->readInt(); const SkColor* colors = nullptr; if (flag & DRAW_VERTICES_HAS_COLORS) { colors = (const SkColor*)reader->skip(SkPatchUtils::kNumCorners * sizeof(SkColor)); } const SkPoint* texCoords = nullptr; if (flag & DRAW_VERTICES_HAS_TEXS) { texCoords = (const SkPoint*)reader->skip(SkPatchUtils::kNumCorners * sizeof(SkPoint)); } SkAutoTUnref<SkXfermode> xfer; if (flag & DRAW_VERTICES_HAS_XFER) { int mode = reader->readInt(); if (mode < 0 || mode > SkXfermode::kLastMode) { mode = SkXfermode::kModulate_Mode; } xfer.reset(SkXfermode::Create((SkXfermode::Mode)mode)); } canvas->drawPatch(cubics, colors, texCoords, xfer, paint); } break; case DRAW_PATH: { const SkPaint& paint = *fPictureData->getPaint(reader); canvas->drawPath(fPictureData->getPath(reader), paint); } break; case DRAW_PICTURE: canvas->drawPicture(fPictureData->getPicture(reader)); break; case DRAW_PICTURE_MATRIX_PAINT: { const SkPaint* paint = fPictureData->getPaint(reader); SkMatrix matrix; reader->readMatrix(&matrix); const SkPicture* pic = fPictureData->getPicture(reader); canvas->drawPicture(pic, &matrix, paint); } break; case DRAW_POINTS: { const SkPaint& paint = *fPictureData->getPaint(reader); SkCanvas::PointMode mode = (SkCanvas::PointMode)reader->readInt(); size_t count = reader->readInt(); const SkPoint* pts = (const SkPoint*)reader->skip(sizeof(SkPoint)* count); canvas->drawPoints(mode, count, pts, paint); } break; case DRAW_POS_TEXT: { const SkPaint& paint = *fPictureData->getPaint(reader); TextContainer text; get_text(reader, &text); size_t points = reader->readInt(); const SkPoint* pos = (const SkPoint*)reader->skip(points * sizeof(SkPoint)); canvas->drawPosText(text.text(), text.length(), pos, paint); } break; case DRAW_POS_TEXT_TOP_BOTTOM: { const SkPaint& paint = *fPictureData->getPaint(reader); TextContainer text; get_text(reader, &text); size_t points = reader->readInt(); const SkPoint* pos = (const SkPoint*)reader->skip(points * sizeof(SkPoint)); const SkScalar top = reader->readScalar(); const SkScalar bottom = reader->readScalar(); if (!canvas->quickRejectY(top, bottom)) { canvas->drawPosText(text.text(), text.length(), pos, paint); } } break; case DRAW_POS_TEXT_H: { const SkPaint& paint = *fPictureData->getPaint(reader); TextContainer text; get_text(reader, &text); size_t xCount = reader->readInt(); const SkScalar constY = reader->readScalar(); const SkScalar* xpos = (const SkScalar*)reader->skip(xCount * sizeof(SkScalar)); canvas->drawPosTextH(text.text(), text.length(), xpos, constY, paint); } break; case DRAW_POS_TEXT_H_TOP_BOTTOM: { const SkPaint& paint = *fPictureData->getPaint(reader); TextContainer text; get_text(reader, &text); size_t xCount = reader->readInt(); const SkScalar* xpos = (const SkScalar*)reader->skip((3 + xCount) * sizeof(SkScalar)); const SkScalar top = *xpos++; const SkScalar bottom = *xpos++; const SkScalar constY = *xpos++; if (!canvas->quickRejectY(top, bottom)) { canvas->drawPosTextH(text.text(), text.length(), xpos, constY, paint); } } break; case DRAW_RECT: { const SkPaint& paint = *fPictureData->getPaint(reader); canvas->drawRect(reader->skipT<SkRect>(), paint); } break; case DRAW_RRECT: { const SkPaint& paint = *fPictureData->getPaint(reader); SkRRect rrect; reader->readRRect(&rrect); canvas->drawRRect(rrect, paint); } break; case DRAW_SPRITE: { /* const SkPaint* paint = */ fPictureData->getPaint(reader); /* const SkBitmap bitmap = */ shallow_copy(fPictureData->getBitmap(reader)); /* int left = */ reader->readInt(); /* int top = */ reader->readInt(); // drawSprite removed dec-2015 } break; case DRAW_TEXT: { const SkPaint& paint = *fPictureData->getPaint(reader); TextContainer text; get_text(reader, &text); SkScalar x = reader->readScalar(); SkScalar y = reader->readScalar(); canvas->drawText(text.text(), text.length(), x, y, paint); } break; case DRAW_TEXT_BLOB: { const SkPaint& paint = *fPictureData->getPaint(reader); const SkTextBlob* blob = fPictureData->getTextBlob(reader); SkScalar x = reader->readScalar(); SkScalar y = reader->readScalar(); canvas->drawTextBlob(blob, x, y, paint); } break; case DRAW_TEXT_TOP_BOTTOM: { const SkPaint& paint = *fPictureData->getPaint(reader); TextContainer text; get_text(reader, &text); const SkScalar* ptr = (const SkScalar*)reader->skip(4 * sizeof(SkScalar)); // ptr[0] == x // ptr[1] == y // ptr[2] == top // ptr[3] == bottom if (!canvas->quickRejectY(ptr[2], ptr[3])) { canvas->drawText(text.text(), text.length(), ptr[0], ptr[1], paint); } } break; case DRAW_TEXT_ON_PATH: { const SkPaint& paint = *fPictureData->getPaint(reader); TextContainer text; get_text(reader, &text); const SkPath& path = fPictureData->getPath(reader); SkMatrix matrix; reader->readMatrix(&matrix); canvas->drawTextOnPath(text.text(), text.length(), path, &matrix, paint); } break; case DRAW_VERTICES: { SkAutoTUnref<SkXfermode> xfer; const SkPaint& paint = *fPictureData->getPaint(reader); DrawVertexFlags flags = (DrawVertexFlags)reader->readInt(); SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader->readInt(); int vCount = reader->readInt(); const SkPoint* verts = (const SkPoint*)reader->skip(vCount * sizeof(SkPoint)); const SkPoint* texs = nullptr; const SkColor* colors = nullptr; const uint16_t* indices = nullptr; int iCount = 0; if (flags & DRAW_VERTICES_HAS_TEXS) { texs = (const SkPoint*)reader->skip(vCount * sizeof(SkPoint)); } if (flags & DRAW_VERTICES_HAS_COLORS) { colors = (const SkColor*)reader->skip(vCount * sizeof(SkColor)); } if (flags & DRAW_VERTICES_HAS_INDICES) { iCount = reader->readInt(); indices = (const uint16_t*)reader->skip(iCount * sizeof(uint16_t)); } if (flags & DRAW_VERTICES_HAS_XFER) { int mode = reader->readInt(); if (mode < 0 || mode > SkXfermode::kLastMode) { mode = SkXfermode::kModulate_Mode; } xfer.reset(SkXfermode::Create((SkXfermode::Mode)mode)); } canvas->drawVertices(vmode, vCount, verts, texs, colors, xfer, indices, iCount, paint); } break; case RESTORE: canvas->restore(); break; case ROTATE: canvas->rotate(reader->readScalar()); break; case SAVE: // SKPs with version < 29 also store a SaveFlags param. if (size > 4) { SkASSERT(8 == size); reader->readInt(); } canvas->save(); break; case SAVE_LAYER_SAVEFLAGS_DEPRECATED: { const SkRect* boundsPtr = get_rect_ptr(reader); const SkPaint* paint = fPictureData->getPaint(reader); auto flags = SkCanvas::LegacySaveFlagsToSaveLayerFlags(reader->readInt()); canvas->saveLayer(SkCanvas::SaveLayerRec(boundsPtr, paint, flags)); } break; case SAVE_LAYER_SAVELAYERFLAGS_DEPRECATED_JAN_2016: { const SkRect* boundsPtr = get_rect_ptr(reader); const SkPaint* paint = fPictureData->getPaint(reader); canvas->saveLayer(SkCanvas::SaveLayerRec(boundsPtr, paint, reader->readInt())); } break; case SAVE_LAYER_SAVELAYERREC: { SkCanvas::SaveLayerRec rec(nullptr, nullptr, nullptr, 0); const uint32_t flatFlags = reader->readInt(); if (flatFlags & SAVELAYERREC_HAS_BOUNDS) { rec.fBounds = &reader->skipT<SkRect>(); } if (flatFlags & SAVELAYERREC_HAS_PAINT) { rec.fPaint = fPictureData->getPaint(reader); } if (flatFlags & SAVELAYERREC_HAS_BACKDROP) { const SkPaint* paint = fPictureData->getPaint(reader); rec.fBackdrop = paint->getImageFilter(); } if (flatFlags & SAVELAYERREC_HAS_FLAGS) { rec.fSaveLayerFlags = reader->readInt(); } canvas->saveLayer(rec); } break; case SCALE: { SkScalar sx = reader->readScalar(); SkScalar sy = reader->readScalar(); canvas->scale(sx, sy); } break; case SET_MATRIX: { SkMatrix matrix; reader->readMatrix(&matrix); matrix.postConcat(initialMatrix); canvas->setMatrix(matrix); } break; case SKEW: { SkScalar sx = reader->readScalar(); SkScalar sy = reader->readScalar(); canvas->skew(sx, sy); } break; case TRANSLATE: { SkScalar dx = reader->readScalar(); SkScalar dy = reader->readScalar(); canvas->translate(dx, dy); } break; default: SkASSERTF(false, "Unknown draw type: %d", op); } }
void WndSymbolButton::OnPaint(Canvas &canvas) { PixelRect rc = { PixelScalar(0), PixelScalar(0), PixelScalar(canvas.get_width()), PixelScalar(canvas.get_height()) }; bool pressed = is_down(); renderer.DrawButton(canvas, rc, HasFocus(), pressed); // If button has text on it tstring caption = get_text(); if (caption.empty()) return; rc = renderer.GetDrawingRect(rc, pressed); canvas.SelectNullPen(); if (!IsEnabled()) canvas.Select(look.button.disabled.brush); else if (HasFocus()) canvas.Select(look.button.focused.foreground_brush); else canvas.Select(look.button.standard.foreground_brush); const char ch = (char)caption[0]; // Draw arrow symbols instead of < and > if (ch == '<' || ch == '>') { int size = min(rc.right - rc.left, rc.bottom - rc.top) / 5; RasterPoint Arrow[3]; Arrow[0].x = (rc.left + rc.right) / 2 + (ch == '<' ? size : -size); Arrow[0].y = (rc.top + rc.bottom) / 2 + size; Arrow[1].x = (rc.left + rc.right) / 2 + (ch == '<' ? -size : size); Arrow[1].y = (rc.top + rc.bottom) / 2; Arrow[2].x = (rc.left + rc.right) / 2 + (ch == '<' ? size : -size); Arrow[2].y = (rc.top + rc.bottom) / 2 - size; canvas.DrawTriangleFan(Arrow, 3); } // Draw arrow symbols instead of v and ^ else if (ch == '^' || ch == 'v') { int size = min(rc.right - rc.left, rc.bottom - rc.top) / 5; RasterPoint Arrow[3]; Arrow[0].x = (rc.left + rc.right) / 2 + size; Arrow[0].y = (rc.top + rc.bottom) / 2 + (ch == '^' ? size : -size); Arrow[1].x = (rc.left + rc.right) / 2; Arrow[1].y = (rc.top + rc.bottom) / 2 + (ch == '^' ? -size : size); Arrow[2].x = (rc.left + rc.right) / 2 - size; Arrow[2].y = (rc.top + rc.bottom) / 2 + (ch == '^' ? size : -size); canvas.DrawTriangleFan(Arrow, 3); } // Draw symbols instead of + and - else if (ch == '+' || ch == '-') { int size = min(rc.right - rc.left, rc.bottom - rc.top) / 5; canvas.Rectangle((rc.left + rc.right) / 2 - size, (rc.top + rc.bottom) / 2 - size / 3, (rc.left + rc.right) / 2 + size, (rc.top + rc.bottom) / 2 + size / 3); if (ch == '+') canvas.Rectangle((rc.left + rc.right) / 2 - size / 3, (rc.top + rc.bottom) / 2 - size, (rc.left + rc.right) / 2 + size / 3, (rc.top + rc.bottom) / 2 + size); } // Draw Fly bitmap else if (caption == _T("Fly")) { Bitmap launcher1_bitmap(IDB_LAUNCHER1); canvas.ClearWhite(); if (is_down()) canvas.invert_stretch_transparent(launcher1_bitmap, COLOR_YELLOW); else canvas.stretch_transparent(launcher1_bitmap, COLOR_BLUE); } // Draw Simulator bitmap else if (caption == _T("Simulator")) { Bitmap launcher2_bitmap(IDB_LAUNCHER2); canvas.ClearWhite(); if (is_down()) canvas.invert_stretch_transparent(launcher2_bitmap, COLOR_YELLOW); else canvas.stretch_transparent(launcher2_bitmap, COLOR_BLUE); } else if (caption == _T("Green")) { InflateRect(&rc, -3, -3); canvas.DrawFilledRectangle(rc, Color(0x74, 0xFF, 0)); } else if (caption == _T("Blue")) { InflateRect(&rc, -3, -3); canvas.DrawFilledRectangle(rc, Color(0, 0x90, 0xFF)); } else if (caption == _T("Magenta")) { InflateRect(&rc, -3, -3); canvas.DrawFilledRectangle(rc, Color(0xFF, 0, 0xCB)); } else if (caption == _T("Yellow")) { InflateRect(&rc, -3, -3); canvas.DrawFilledRectangle(rc, Color(0xFF, 0xE8, 0)); } }
void Alpha::draw_section(clan::Canvas &canvas, clan::Font &font, int yoffset, const clan::Colorf &background, const clan::Colorf &vertex_colour, const clan::Colorf &image_colour) { // Draw the background without blending to set the specified RGBA canvas.set_blend_state(blend_disabled); const int outer_area_size = 32; const int outer_xoffset = 8; canvas.fill_rect( outer_xoffset, yoffset, outer_xoffset + outer_area_size, yoffset + outer_area_size, background); canvas.set_blend_state(blend_enabled); // Create the image clan::Image image = create_block(canvas, image_colour); // Draw the image image.set_color(vertex_colour); image.draw(canvas, outer_xoffset + (outer_area_size - image.get_width())/2, yoffset + (outer_area_size - image.get_height())/2); clan::Colorf output; // Get the composited pixel buffer clan::Rectf rect(outer_xoffset + outer_area_size / 2, (yoffset + outer_area_size / 2), clan::Sizef(64,64)); if (rect.is_inside(canvas.get_size())) { clan::PixelBuffer pbuff = canvas.get_pixeldata(rect, clan::tf_rgba8); pbuff.lock(canvas, clan::access_read_only); //clan::ImageProviderFactory::save(pbuff, "test.png"); clan::Colorf output = pbuff.get_pixel(0, 0); pbuff.unlock(); } // Create the information string std::string info(clan::string_format("Background = %1, %2, %3, %4", get_text(background.r), get_text(background.g), get_text(background.b), get_text(background.a))); int xpos = outer_xoffset + outer_area_size + 8; int ypos = yoffset + 12; font.draw_text(canvas, xpos, ypos, info, clan::Colorf::black); info = std::string(clan::string_format("Vertex = %1, %2, %3, %4", get_text(vertex_colour.r), get_text(vertex_colour.g), get_text(vertex_colour.b), get_text(vertex_colour.a))); font.draw_text(canvas, xpos + 250, ypos, info, clan::Colorf::black); info = std::string(clan::string_format("Image = %1, %2, %3, %4", get_text(image_colour.r), get_text(image_colour.g), get_text(image_colour.b), get_text(image_colour.a))); font.draw_text(canvas, xpos + 500, ypos, info, clan::Colorf::black); ypos += 20; clan::Colorf source(vertex_colour * image_colour); clan::Colorf calculated; calculated.r = source.a * source.r + (1.0f - source.a) * background.r; calculated.g = source.a * source.g + (1.0f - source.a) * background.g; calculated.b = source.a * source.b + (1.0f - source.a) * background.b; calculated.a = source.a + (1.0f - source.a) * background.a; info = std::string(clan::string_format("Source = %1, %2, %3, %4", get_text(source.r), get_text(source.g), get_text(source.b), get_text(source.a))); font.draw_text(canvas, xpos, ypos, info, clan::Colorf::black); info = std::string(clan::string_format("Calculated = %1, %2, %3, %4", get_text(calculated.r), get_text(calculated.g), get_text(calculated.b), get_text(calculated.a))); font.draw_text(canvas, xpos + 250, ypos, info, clan::Colorf::black); info = std::string(clan::string_format("Actual = %1, %2, %3, %4", get_text(output.r), get_text(output.g), get_text(output.b), get_text(output.a))); font.draw_text(canvas, xpos + 500, ypos, info, clan::Colorf::black); }
int run_daemon( mxml_node_t *tree ){ signal(SIGUSR1, receive_signal); mxml_node_t *current_node = tree; mxml_node_t *next_node; // Start X11 "display" display = XOpenDisplay(0); root = DefaultRootWindow(display); // For delay (10ms = 10000000ns) struct timespec t1, t2; t1.tv_sec = 0; t1.tv_nsec = 10000000; accepting_input = 0; while( 1 ) { while( !accepting_input ){ // Slight delay to not eat up too much cpu nanosleep(&t1, &t2); } while ( XPending(display) > 0 ){ XNextEvent(display, &event); KeySym keysym = XLookupKeysym(&event.xkey, 0); sprintf(input_char,"%s", XKeysymToString(keysym)); printf("unicode: %s len: %d\n", input_char, strlen(input_char) ); if ( event.type != KeyPress ){} else if ( XKeysymToKeycode(display, keysym) == ESC_CODE ){ set_accepting_input(0); current_node = tree; } else if (strlen(input_char)){ // send char next_node = send_char(current_node, tree, input_char); /* If execute */ if ( next_node == current_node ){ char* command = get_text(current_node); printf("\n~~ Execute: %s\n\n", command); // execute command int val = system(command); printf("command status: %d\n",val); // free the malloc'ed command char* in get_text free(command); // Set next_node to null, so current_node will be reset below next_node = NULL; } /* If command executed above or not valid keystroke combination, * reset current_node */ if (next_node == NULL){ printf("Reset node\n"); current_node = tree; set_accepting_input(0); } /* Continue traversing xml tree */ else{ current_node = next_node; printf("new current node is: "); print_node(current_node,tree); } } } } XCloseDisplay(display); free(input_char); return 0; }
int PitchSize::handle_event() { plugin->config.size = atoi(get_text()); plugin->send_configure_change(); return 1; }
int get_group ( Widget widget ) /************************************************************************ * * * This subroutione gets the frame selection for the * * specified group. * * * * GET_GROUP ( WIDGET ) * * * * Input parameters: * * WIDGET Widget parent widget * ** * * Log: * * T. Piper/SAIC 10/04 Changed MAX_PIXMAP to MAX_FRAME_GROUP * ***********************************************************************/ { int framecnt, ii, status; XmStringTable selectedframes; char text[40], message[256]; /*---------------------------------------------------------------------*/ get_text(group_nameW, &text[0]); if ( *text ) { strcpy( GroupList[GroupNo].groupname,text ); XtVaGetValues(gframe_listW, XmNselectedItemCount, &framecnt, XmNselectedItems, &selectedframes, NULL); if ( framecnt == 0 ) { NxmWarn_show( widget, "Please Select Frames." ); status = 0; } else { if ( framecnt > MAX_FRAME_GROUP ) { sprintf(message, "The number of frames in this group exceeds the limit of %d.", MAX_FRAME_GROUP); NxmWarn_show( widget, message ); status = 0; } else { GroupList[GroupNo].frame_num = framecnt; for ( ii = 0; ii < framecnt; ii++ ) { GroupList[GroupNo].frames[ii] = XmListItemPos(gframe_listW, selectedframes[ii]); } GroupNo ++; status = 1; add_grouplist(); } } } /* end of if */ else { status = 0; NxmWarn_show( widget, "Please Input the Group Name."); } return (status); }
int viewresults(void) { int k,kmenu; void * pscr = NULL; shortstr newname; int dirStat=checkDir("results"); if(dirStat==0){messanykey(10,15,"directory RESULTS is empty"); return 1;} kmenu = 1; label_1: menu1(10,10,"","\010" " View " " Delete " " Rename ","s_res",&pscr,&kmenu); switch (kmenu) { case 0: return 0; case 1: viewDir("results"); break; case 2: if(dirStat==2) { char mess[]="Can not clean dir 'results' because it contains the LOCK file"; if(blind) { printf("%s\n",mess); sortie(102);} else { messanykey(3,13,mess); break;} } if ( mess_y_n( 6,13," Delete files ") ) system("rm -r results; mkdir results"); put_text(&pscr); return 1; case 3: strcpy(newname," "); while(1) { void * pscr3; get_text(1,maxRow(),maxCol(),maxRow(),&pscr3); goto_xy(1,maxRow()); print("Enter new name: "); k = str_redact(newname,1,30); if (k == KB_ESC) { goto_xy(1,24); clr_eol(); goto label_1; } if (k == KB_ENTER) { trim(newname); if(rename("results",newname)==0) { mkdir("results",-1); put_text(&pscr); put_text(&pscr3); return 1; } else messanykey(10,15," Can't rename the directory"); } put_text(&pscr3); } } goto label_1; }
int BitsPopupText::handle_event() { *popup->output = File::strtobits(get_text()); return 1; }
int PrefsBRenderFragment::handle_event() { pwindow->thread->preferences->brender_fragment = atol(get_text()); return 1; }
// Get the edited value std::string TextSpecifierPanel::getValue() const { return get_text(); }
int PrefsBRenderPreroll::handle_event() { pwindow->thread->preferences->brender_preroll = atol(get_text()); return 1; }
int main (int argc, char *argv[]) { boolean dest_lan; char host_name[1024]; soc_host host_no; char port_name[256]; soc_port port_no; soc_token soc = init_soc; char buffer[1024]; int i, res, len; boolean interactive; /* Parse command line arguments */ /* Syntax is udp_send lan/host <dest>:<port> [ <message> ] */ if (argc < 3) error("Invalid number of arguments", ""); if (strcmp(argv[1], "host") == 0) { dest_lan = false; } else if (strcmp(argv[1], "lan") == 0) { dest_lan = true; } else { error("Invalid argument", argv[1]); } interactive = (isatty(0) == 1); /* Locate ':' in dest:port */ strcpy (host_name, argv[2]); res = -1; for (i = 0; i < (int) strlen(host_name); i++) { if (host_name[i] == ':') { if (res != -1) { error ("Invalid destination", host_name); } res = i; } } /* ':' must exist and not at beginning or end */ if ( (res == -1) || (res == 0) || (res == (int)strlen (host_name) - 1) ) { error ("Invalid destination", host_name); } host_name[res] = '\0'; strcpy (port_name, &host_name[res+1]); /* Create socket */ res = soc_open(&soc, udp_socket); if (res != SOC_OK) { error("Socket creation", soc_error(res)); } /* Set destination */ if (soc_str2host (host_name, &host_no) == SOC_OK) { if (soc_str2port (port_name, &port_no) == SOC_OK) { res = soc_set_dest_host_port(soc, &host_no, port_no); } else { res = soc_set_dest_host_service (soc, &host_no, port_name); } } else { if (soc_str2port (port_name, &port_no) == SOC_OK) { res = soc_set_dest_name_port(soc, host_name, dest_lan, port_no); } else { res = soc_set_dest_name_service(soc, host_name, dest_lan, port_name); } } if (res != SOC_OK) { error("Setting destination", soc_error(res)); } /* Link */ if (soc_str2port (port_name, &port_no) == SOC_OK) { res = soc_link_port(soc, port_no); } else { res = soc_link_service (soc, port_name); } if (res != SOC_OK) { error("Linking to port", soc_error(res)); } /* Build or read message */ message[0] = '\0'; if (argc > 3) { /* Concatenate arguments separated by spaces */ for (i = 3; i < argc; i++) { if (i != 3) { strcat (message, " "); } strcat (message, argv[i]); } len = strlen(message); } else { /* Read from stdin */ if (interactive) { printf ("Enter message to send (end with Ctrl-D): "); fflush (stdout); } len = 0; for (;;) { /* Read a buffer of data from stdin */ res = (int) get_text (NULL, buffer, sizeof(buffer)); if (res == 0) { /* End of input flow */ break; } /* Concatenate to message */ memmove (&message[len], buffer, res); len += res; } if (interactive) { printf ("\n"); } } /* Send */ res = soc_send (soc, message, (soc_length)len); if (res != SOC_OK) { error("Sending message", soc_error(res)); } /* Receive */ res = soc_set_blocking (soc, FALSE); sleep (1); for (;;) { res = soc_receive (soc, message, (soc_length)sizeof(message), TRUE); if (res > 0) { message[res] = '\0'; printf ("-->%s<\n", message); } else { break; } } exit (0); }
/* --------------------------------------------------------- */ void FC_FUNC_(varinfo_init, VARINFO_INIT) (STR_F_TYPE const fname STR_ARG1) { char line[256], *fname_c; FILE *in; var_type *lvar = NULL; opt_type *lopt; TO_C_STR1(fname, fname_c); in = fopen(fname_c, "r"); free(fname_c); if(!in) { return; } while(fgets(line, 256, in)){ if(strncasecmp("Variable", line, 8) == 0){ char *s; get_token(line+9, &s); if(s){ /* found a token */ if(!lvar){ lvar = (var_type *) malloc(sizeof(var_type)); vars = lvar; }else{ lvar->next = (var_type *) malloc(sizeof(var_type)); lvar = lvar->next; } lvar->name = s; lvar->desc = NULL; lvar->type = NULL; lvar->default_str = NULL; lvar->section = NULL; lvar->opt = NULL; lvar->next = NULL; lopt = NULL; } continue; } /* if no variable was found continue */ if(!lvar) continue; if(strncasecmp("Type", line, 4) == 0) get_token(line+5, &(lvar->type)); if(strncasecmp("Default", line, 7) == 0) get_token(line+8, &(lvar->default_str)); if(strncasecmp("Section", line, 7) == 0){ char *s = line+7; for(; *s!='\0' && isspace(*s); s++); lvar->section = strdup(s); } if(strncasecmp("Description", line, 11) == 0){ if(lvar->desc){ /* if repeated delete old description */ free(lvar->desc); lvar->desc = NULL; } get_text(in, &(lvar->desc)); } if(strncasecmp("Option", line, 6) == 0){ char *name, *value, *s; s = get_token(line+6, &name); if(name) get_token(s, &value); if(name){ /* found an option */ if(!lopt){ lopt = (opt_type *) malloc(sizeof(opt_type)); lvar->opt = lopt; }else{ lopt->next = (opt_type *) malloc(sizeof(var_type)); lopt = lopt->next; } lopt->name = name; lopt->value = value; lopt->desc = NULL; get_text(in, &(lopt->desc)); lopt->next = NULL; } } } fclose(in); }
String OptionButton::get_string() { return get_text(); }
int VocoderCarrier::handle_event() { plugin->config.carrier_track = atoi(get_text()); plugin->send_configure_change(); return 1; }
static void ME_InsertRowStart(ME_WrapContext *wc, const ME_DisplayItem *pEnd) { ME_DisplayItem *p, *row, *para; BOOL bSkippingSpaces = TRUE; int ascent = 0, descent = 0, width=0, shift = 0, align = 0; PARAFORMAT2 *pFmt; /* wrap text */ para = wc->pPara; pFmt = para->member.para.pFmt; for (p = pEnd->prev; p!=wc->pRowStart->prev; p = p->prev) { /* ENDPARA run shouldn't affect row height, except if it's the only run in the paragraph */ if (p->type==diRun && ((p==wc->pRowStart) || !(p->member.run.nFlags & MERF_ENDPARA))) { /* FIXME add more run types */ if (p->member.run.nAscent>ascent) ascent = p->member.run.nAscent; if (p->member.run.nDescent>descent) descent = p->member.run.nDescent; if (bSkippingSpaces) { /* Exclude space characters from run width. * Other whitespace or delimiters are not treated this way. */ int len = p->member.run.len; WCHAR *text = get_text( &p->member.run, len - 1 ); assert (len); if (~p->member.run.nFlags & MERF_GRAPHICS) while (len && *(text--) == ' ') len--; if (len) { if (len == p->member.run.len) width += p->member.run.nWidth; else width += ME_PointFromCharContext( wc->context, &p->member.run, len, FALSE ); } bSkippingSpaces = !len; } else if (!(p->member.run.nFlags & MERF_ENDPARA)) width += p->member.run.nWidth; } } para->member.para.nWidth = max(para->member.para.nWidth, width); row = ME_MakeRow(ascent+descent, ascent, width); if (wc->context->editor->bEmulateVersion10 && /* v1.0 - 3.0 */ pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE) { /* The text was shifted down in ME_BeginRow so move the wrap context * back to where it should be. */ wc->pt.y--; /* The height of the row is increased by the borders. */ row->member.row.nHeight += 2; } row->member.row.pt = wc->pt; row->member.row.nLMargin = (!wc->nRow ? wc->nFirstMargin : wc->nLeftMargin); row->member.row.nRMargin = wc->nRightMargin; assert(para->member.para.pFmt->dwMask & PFM_ALIGNMENT); align = para->member.para.pFmt->wAlignment; if (align == PFA_CENTER) shift = max((wc->nAvailWidth-width)/2, 0); if (align == PFA_RIGHT) shift = max(wc->nAvailWidth-width, 0); row->member.row.pt.x = row->member.row.nLMargin + shift; for (p = wc->pRowStart; p!=pEnd; p = p->next) { if (p->type==diRun) { /* FIXME add more run types */ p->member.run.pt.x += row->member.row.nLMargin+shift; } } ME_InsertBefore(wc->pRowStart, row); wc->nRow++; wc->pt.y += row->member.row.nHeight; ME_BeginRow(wc); }
void xlui::line_edit::key_press_event(xlui::key_event &event) { stop_timer(m_iTimerId); switch(event.get_key_val()) { case KV_BackSpace: { if(has_selected_text()) { remove_selected_text(); } else { remove_left_from_cursor(); } break; } case KV_Delete: { if(has_selected_text()) { remove_selected_text(); } else { remove_right_from_cursor(); } break; } case KV_Return: { enter.emit(get_text()); // xlui::signal_string sig(get_text()); // execute(ST_LineEdit_Enter, &sig); break; } case KV_Right: { int32_t x_start = 0; int32_t x_end = 0; //xlui::string_dimension dim(_font, this); xlui::font_metric dim(_font); if(event.get_modifiers() & xlui::KM_Shift) { if(!has_selected_text()) { _selection = true; m_iSelectionStart = m_iActualCursor; } } else { m_iSelectionStart = 0; _selection = false; } if(m_iActualCursor < _text.get_character_count()) { ++m_iActualCursor; } if(_selection) { if(m_iActualCursor == m_iSelectionStart) { m_iSelectionCount = 0; _selection = false; } else if(m_iActualCursor > m_iSelectionStart) { ++m_iSelectionCount; int32_t count = 0; xlui::string text = _text.mid(0, m_iSelectionStart); x_start = dim.get_width(text); text = _text.mid(m_iSelectionStart, m_iSelectionCount); x_end = dim.get_width(text); } else { --m_iSelectionCount; xlui::string text = _text.mid(0, m_iSelectionStart - m_iSelectionCount); x_start = dim.get_width(text); text = _text.mid(m_iSelectionStart - m_iSelectionCount, m_iSelectionCount); x_end = dim.get_width(text); } m_SelectionStart.set_x(x_start); m_SelectionStart.set_y(0); m_SelectionEnd.set_x(x_start + x_end); m_SelectionEnd.set_y(0); m_iTimerId = start_timer(500); set_cursor_position_from_actual_cursor(); update(); return; } break; } case KV_Left: { int32_t x_start = 0; int32_t x_end = 0; //xlui::string_dimension dim(_font, this); xlui::font_metric dim(_font); if(event.get_modifiers() & xlui::KM_Shift) { if(!has_selected_text()) { _selection = true; m_iSelectionStart = m_iActualCursor; } } else if(event.get_modifiers() & xlui::KM_Control) { _selection = false; } else { m_iSelectionStart = 0; _selection = false; } if(m_iActualCursor > 0) { --m_iActualCursor; } if(_selection) { if(m_iActualCursor == m_iSelectionStart) { m_iSelectionCount = 0; _selection = false; } else if(m_iActualCursor > m_iSelectionStart) { --m_iSelectionCount; xlui::string text = _text.mid(0, m_iSelectionStart); x_start = dim.get_width(text); text = _text.mid(m_iSelectionStart, m_iSelectionCount); x_end = dim.get_width(text); } else { ++m_iSelectionCount; xlui::string text = _text.mid(0, m_iSelectionStart - m_iSelectionCount); x_start = dim.get_width(text); text = _text.mid(m_iSelectionStart - m_iSelectionCount, m_iSelectionCount); x_end = dim.get_width(text); } m_SelectionStart.set_x(x_start); m_SelectionStart.set_y(0); m_SelectionEnd.set_x(x_start + x_end); m_SelectionEnd.set_y(0); m_iTimerId = start_timer(500); set_cursor_position_from_actual_cursor(); update(); return; } break; } case KV_Home: { m_iSelectionStart = 0; m_iSelectionCount = m_iActualCursor; if(event.get_modifiers() & xlui::KM_Shift) { _selection = true; int32_t x_start = 0; int32_t x_end = 0; // xlui::string_dimension dim(_font, this); xlui::font_metric dim(_font); x_start = 0; xlui::string text = _text.mid(0, m_iSelectionCount); x_end = dim.get_width(text); m_SelectionStart.set_x(x_start); m_SelectionStart.set_y(0); m_SelectionEnd.set_x(x_start + x_end); m_SelectionEnd.set_y(0); m_iTimerId = start_timer(500); set_cursor_position_from_actual_cursor(); update(); return; } m_iActualCursor = 0; break; } case KV_End: { m_iSelectionStart = m_iActualCursor; if(event.get_modifiers() & xlui::KM_Shift) { m_iSelectionCount = _text.get_character_count() - m_iSelectionStart; _selection = true; int32_t x_start = 0; int32_t x_end = 0; // xlui::string_dimension dim(_font, this); xlui::font_metric dim(_font); xlui::string text = _text.mid(0, m_iSelectionStart); x_start = dim.get_width(text); text = _text.mid(m_iSelectionStart, m_iSelectionCount); x_end = dim.get_width(text); m_SelectionStart.set_x(x_start); m_SelectionStart.set_y(0); m_SelectionEnd.set_x(x_start + x_end); m_SelectionEnd.set_y(0); m_iTimerId = start_timer(500); set_cursor_position_from_actual_cursor(); update(); return; } m_iActualCursor = _text.get_character_count(); break; } case KV_Tab: case KV_Pause: case KV_Scroll_Lock: case KV_Escape: case KV_Shift_L: case KV_Shift_R: case KV_Control_L: case KV_Control_R: case KV_Caps_Lock: case KV_Shift_Lock: case KV_Meta_L: case KV_Meta_R: case KV_Alt_L: case KV_Alt_R: case KV_Super_L: case KV_Super_R: case KV_Hyper_L: case KV_Hyper_R: case KV_ISO_Level3_Shift: case KV_ISO_Next_Group_Lock: case KV_Num_Lock: case KV_Page_Up: case KV_Page_Down: { return; } default: { if(has_selected_text()) { remove_selected_text(); } xlui::string text = event.get_key(); if(_text.get_character_count() > 0) { xlui::string temp; temp = _text.mid(0, m_iActualCursor); temp += text; if(m_iActualCursor < _text.get_character_count()) { temp += _text.mid(m_iActualCursor); } _text = temp; } else { _text += text; } if(!text.is_empty()) { ++m_iActualCursor; } break; } } m_SelectionStart.set_x(0); m_SelectionStart.set_y(0); m_SelectionEnd.set_x(0); m_SelectionEnd.set_y(0); m_iTimerId = start_timer(500); set_cursor_position_from_actual_cursor(); update(); }
static ME_DisplayItem *ME_SplitByBacktracking(ME_WrapContext *wc, ME_DisplayItem *p, int loc) { ME_DisplayItem *piter = p, *pp; int i, idesp, len; ME_Run *run = &p->member.run; idesp = i = find_split_point( wc->context, loc, run ); len = run->len; assert(len>0); assert(i<len); if (i) { /* don't split words */ i = reverse_find_whitespace( get_text( run, 0 ), i ); pp = ME_MaximizeSplit(wc, p, i); if (pp) return pp; } TRACE("Must backtrack to split at: %s\n", debugstr_run( &p->member.run )); if (wc->pLastSplittableRun) { if (wc->pLastSplittableRun->member.run.nFlags & (MERF_GRAPHICS|MERF_TAB)) { wc->pt = wc->pLastSplittableRun->member.run.pt; return wc->pLastSplittableRun; } else if (wc->pLastSplittableRun->member.run.nFlags & MERF_SPLITTABLE) { /* the following two lines are just to check if we forgot to call UpdateRunFlags earlier, they serve no other purpose */ ME_UpdateRunFlags(wc->context->editor, run); assert((wc->pLastSplittableRun->member.run.nFlags & MERF_SPLITTABLE)); piter = wc->pLastSplittableRun; run = &piter->member.run; len = run->len; /* don't split words */ i = reverse_find_whitespace( get_text( run, 0 ), len ); if (i == len) i = reverse_find_non_whitespace( get_text( run, 0 ), len ); if (i) { ME_DisplayItem *piter2 = split_run_extents(wc, piter, i); wc->pt = piter2->member.run.pt; return piter2; } /* splittable = must have whitespaces */ assert(0 == "Splittable, but no whitespaces"); } else { /* restart from the first run beginning with spaces */ wc->pt = wc->pLastSplittableRun->member.run.pt; return wc->pLastSplittableRun; } } TRACE("Backtracking failed, trying desperate: %s\n", debugstr_run( &p->member.run )); /* OK, no better idea, so assume we MAY split words if we can split at all*/ if (idesp) return split_run_extents(wc, piter, idesp); else if (wc->pRowStart && piter != wc->pRowStart) { /* don't need to break current run, because it's possible to split before this run */ wc->bOverflown = TRUE; return piter; } else { /* split point inside first character - no choice but split after that char */ if (len != 1) { /* the run is more than 1 char, so we may split */ return split_run_extents(wc, piter, 1); } /* the run is one char, can't split it */ return piter; } }
int DenoiseVideoThreshold::handle_event() { plugin->config.threshold = atof(get_text()); plugin->send_configure_change(); return 1; }
static ME_DisplayItem *ME_WrapHandleRun(ME_WrapContext *wc, ME_DisplayItem *p) { ME_DisplayItem *pp; ME_Run *run; int len; assert(p->type == diRun); if (!wc->pRowStart) wc->pRowStart = p; run = &p->member.run; run->pt.x = wc->pt.x; run->pt.y = wc->pt.y; ME_WrapSizeRun(wc, p); len = run->len; if (wc->bOverflown) /* just skipping final whitespaces */ { /* End paragraph run can't overflow to the next line by itself. */ if (run->nFlags & MERF_ENDPARA) return p->next; if (run->nFlags & MERF_WHITESPACE) { wc->pt.x += run->nWidth; /* skip runs consisting of only whitespaces */ return p->next; } if (run->nFlags & MERF_STARTWHITE) { /* try to split the run at the first non-white char */ int black; black = find_non_whitespace( get_text( run, 0 ), run->len, 0 ); if (black) { wc->bOverflown = FALSE; pp = split_run_extents(wc, p, black); calc_run_extent(wc->context, &wc->pPara->member.para, wc->nRow ? wc->nLeftMargin : wc->nFirstMargin, &pp->member.run); ME_InsertRowStart(wc, pp); return pp; } } /* black run: the row goes from pRowStart to the previous run */ ME_InsertRowStart(wc, p); return p; } /* simply end the current row and move on to next one */ if (run->nFlags & MERF_ENDROW) { p = p->next; ME_InsertRowStart(wc, p); return p; } /* will current run fit? */ if (wc->bWordWrap && wc->pt.x + run->nWidth - wc->context->pt.x > wc->nAvailWidth) { int loc = wc->context->pt.x + wc->nAvailWidth - wc->pt.x; /* total white run ? */ if (run->nFlags & MERF_WHITESPACE) { /* let the overflow logic handle it */ wc->bOverflown = TRUE; return p; } /* TAB: we can split before */ if (run->nFlags & MERF_TAB) { wc->bOverflown = TRUE; if (wc->pRowStart == p) /* Don't split before the start of the run, or we will get an * endless loop. */ return p->next; else return p; } /* graphics: we can split before, if run's width is smaller than row's width */ if ((run->nFlags & MERF_GRAPHICS) && run->nWidth <= wc->nAvailWidth) { wc->bOverflown = TRUE; return p; } /* can we separate out the last spaces ? (to use overflow logic later) */ if (run->nFlags & MERF_ENDWHITE) { /* we aren't sure if it's *really* necessary, it's a good start however */ int black = reverse_find_non_whitespace( get_text( run, 0 ), len ); split_run_extents(wc, p, black); /* handle both parts again */ return p; } /* determine the split point by backtracking */ pp = ME_SplitByBacktracking(wc, p, loc); if (pp == wc->pRowStart) { if (run->nFlags & MERF_STARTWHITE) { /* We had only spaces so far, so we must be on the first line of the * paragraph (or the first line after MERF_ENDROW forced the line * break within the paragraph), since no other lines of the paragraph * start with spaces. */ /* The lines will only contain spaces, and the rest of the run will * overflow onto the next line. */ wc->bOverflown = TRUE; return p; } /* Couldn't split the first run, possible because we have a large font * with a single character that caused an overflow. */ wc->pt.x += run->nWidth; return p->next; } if (p != pp) /* found a suitable split point */ { wc->bOverflown = TRUE; return pp; } /* we detected that it's best to split on start of this run */ if (wc->bOverflown) return pp; ERR("failure!\n"); /* not found anything - writing over margins is the only option left */ } if ((run->nFlags & (MERF_SPLITTABLE | MERF_STARTWHITE)) || ((run->nFlags & (MERF_GRAPHICS|MERF_TAB)) && (p != wc->pRowStart))) { wc->pLastSplittableRun = p; } wc->pt.x += run->nWidth; return p->next; }
const char* json_node::get_string(void) const { return get_text(); }
int ItemTextField::get_width() const { return static_cast<int>(Resources::normal_font->get_text_width(get_text()) + Resources::normal_font->get_text_width(*input) + 16.0f + static_cast<float>(flickw)); }
int Controls::get_int(string control_name){ string content = get_text(control_name); if(content.length()==0) return 0; return atoi(content.c_str()); }
int monte_carlo_menu(void) { static int r=0; int mode=1; void * pscr=NULL; void * pscr_mem=NULL; void (*quit)(int)=f3_key[7]; char menutxt[]="\030" " Subprocess " " IN state " " Model parameters " " Constraints " " QCD coupling " " Breit-Wigner " " Aliases " " Cuts " " Phase space mapping " " Monte Carlo simulation " " Easy "; if(nout_int!=2 ) menutxt[menutxt[0]*10+1]=0; if(nin_int==1) improveStr(menutxt,"Easy", "Total width"); else improveStr(menutxt,"Easy", "1D intergration"); get_text(1,10,80,24,&pscr_mem); wrtprc_(); for(;;) { infor(); f3_key[7]=quit; menu1(54,4,"",menutxt,"n_mc_*",&pscr, &mode); if(mode==1||mode==2||mode==3||mode==5||mode==7)f3_key[7]=NULL; switch (mode) { case 0: put_text(&pscr_mem); return 0; case 1: r=r|3*sub_men__(); break; case 2: r=r|in_setting(); break; case 3: r=r|change_parameter(54,7,0); break; case 4: { int modeC=1; for(;;) { char menuC[]="\030" " All Constraints " " Masses,Widths,Branching"; void * pscrC=NULL; menu1(54,6,"",menuC,"n_constr_*",&pscrC, &modeC); switch(modeC) { case 0: put_text(&pscr_mem); break; case 1: show_depend(54,7); break; case 2: show_spectrum(54,9); break; } if(!modeC) break; } break; } case 5: r=r|qcdmen_(); break; case 6: r=r|w_men__(); break; case 7: do r=r|(3*edittable(1,4,&compTab,1,"n_comp",0)); while (fillCompositeArray()); break; case 8: do r=r|(3*edittable(1,4,&cutTab,1,"n_cut",0)); while (fillCutArray()); break; case 9: r=r|mappingMenu(); break; case 10: if(nout_int==1 && !sf_num[0] && !sf_num[1] ) { if(blind) return 1; messanykey(15,15,"Phase space integration for 2->1 processes\n needs distribution functions."); break; } if(checkEnergy()) { if(blind) return 1; messanykey(15,15,"Energy is too small!"); break; } if(fillCutArray()) { if(blind) return 2; messanykey(15,15,"Can not evaluate cuts limlts"); break; } case 11: if(mode==11) { void (*f10_tmp)(int); w_sess__(NULL); f10_tmp=f3_key[7]; f3_key[7]=f10_key_prog_for22; if(nin_int==1) decay12(); else { REAL m1,m2, Pcm; pinf_int(Nsub,1,&m1,NULL); pinf_int(Nsub,2,&m2,NULL); incomkin(m1,m2,inP1,inP2,NULL,&Pcm,NULL); if(sf_num[0]||sf_num[1]||nCuts) messanykey(10,10,"Structure functions and cuts are ignored\n"); cs_numcalc(Pcm); } f3_key[7]= f10_tmp; r_sess__(NULL); break; } else if(fillRegArray()) { if(blind) return 3; messanykey(15,15, "Can not evaluate regularization paremeters"); break; } if(mode==10) runVegas(); r=0; break; } if(r) clearEventMax(); if(r&2) clearGrid(); if(r&1)newSession(); } }