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();
}
}
