void GR_CocoaImage::cairoSetSource(cairo_t *cr)
{
UT_return_if_fail(m_surface);
double scaleX = (double)getDisplayWidth() / (double)cairo_image_surface_get_width(m_surface);
double scaleY = (double)getDisplayHeight() / (double)cairo_image_surface_get_height(m_surface);
cairo_scale(cr, scaleX, scaleY);
cairo_set_source_surface(cr, m_surface, 0, 0);
}
void relocate_targets(){
for (int i=0; i<max_targets; i++) {
targets[i].x=rand_range(100,getDisplayWidth()-100);
targets[i].y=rand_range(100,getDisplayHeight()-100);
}
reassign_flares();
}
/**
* Resize the buffer size (either normal or fullscreen)
*/
void ChameleonMScreen::setBufferSize(BufferSize newSize)
{
if (newSize == fullScreenSize) {
qpixmap.resize(getDisplayFullWidth(), getDisplayFullHeight());
} else {
qpixmap.resize(getDisplayWidth(), getDisplayHeight());
}
}
/*!
* Scale our image to rectangle given by rec. The dimensions of rec
* are calculated in logical units.
*/
void GR_UnixImage::scaleImageTo(GR_Graphics * pG, const UT_Rect & rec)
{
UT_sint32 width = pG->tdu(rec.width);
UT_sint32 height = pG->tdu(rec.height);
if((width == getDisplayWidth()) && (height == getDisplayHeight()))
{
return;
}
scale(width,height);
// UT_ASSERT(G_OBJECT(m_image)->ref_count == 1);
}
/**
* Resize the buffer size (either normal or fullscreen)
*/
void ChameleonMScreen::setBufferSize(BufferSize newSize)
{
if (newSize == fullScreenSize) {
if (gc->isActive()) {
gc->end();
}
qpixmap.resize(getDisplayFullWidth(), getDisplayFullHeight());
} else {
qpixmap.resize(getDisplayWidth(), getDisplayHeight());
}
// Whether current Displayable won't repaint the entire screen on
// resize event, the artefacts from the old screen content can appear.
// That's why the buffer content is not preserved.
qpixmap.fill(Qt::black);
}
/*!
* Generate an outline of an image with transparency. This is a collection
* of (x,y) points marking the first non-transparent point from the left
* and right side of the image.
* This outline is used by GetOffsetFromLeft and facitates "tight"
* text wrapping
* around objects.
*/
void GR_Image::GenerateOutline(void)
{
DestroyOutline();
UT_sint32 width = getDisplayWidth();
UT_sint32 height = getDisplayHeight();
UT_sint32 i,j=0;
//
// Generate from left
//
for(i=0; i< height;i++)
{
for(j =0; j< width;j++)
{
if(!isTransparentAt(j,i))
{
break;
}
}
if( j < width)
{
GR_Image_Point * pXY = new GR_Image_Point();
pXY->m_iX = j;
pXY->m_iY = i;
m_vecOutLine.addItem(pXY);
}
}
//
// Generate from Right
//
for(i=0; i< height;i++)
{
for(j =width-1; j>= 0;j--)
{
if(!isTransparentAt(j,i))
{
break;
}
}
if( j >= 0)
{
GR_Image_Point * pXY = new GR_Image_Point();
pXY->m_iX = j;
pXY->m_iY = i;
m_vecOutLine.addItem(pXY);
}
}
}
void Platform::setMouseCaptured(bool captured)
{
if (captured != __mouseCaptured)
{
if (captured)
{
// Hide the cursor and warp it to the center of the screen
__mouseCapturePoint.x = getDisplayWidth() / 2;
__mouseCapturePoint.y = getDisplayHeight() / 2;
ShowCursor(FALSE);
WarpMouse(__mouseCapturePoint.x, __mouseCapturePoint.y);
}
else
{
// Restore cursor
WarpMouse(__mouseCapturePoint.x, __mouseCapturePoint.y);
ShowCursor(TRUE);
}
__mouseCaptured = captured;
}
}
void init_graphic()
{
memset(&ctx, 0, sizeof(DrawCtx));
// alloc VSH Menu graphic buffers, generic based on canvas constants
buf[0].addr = mem_alloc(CANVAS_W * CANVAS_H * sizeof(uint32_t)); // canvas buffer
buf[1].addr = mem_alloc(CANVAS_W * CANVAS_H * sizeof(uint32_t)); // background buffer
#ifdef HAVE_PNG_FONT
// load font png
Buffer font = load_png(PNG_FONT_PATH);
ctx.font = font.addr;
#endif
// set drawing context
ctx.canvas = buf[0].addr;
ctx.bg = buf[1].addr;
ctx.bg_color = 0xFF000000; // black, opaque
ctx.fg_color = 0xFFFFFFFF; // white, opaque
// get current display values
offset = *(uint32_t*)0x60201104; // start offset of current framebuffer
getDisplayPitch(&pitch, &unk1); // framebuffer pitch size
h = getDisplayHeight(); // display height
w = getDisplayWidth(); // display width
// get x/y start coordinates for our canvas, always center
canvas_x = (w - CANVAS_W) /2;
canvas_y = (h - CANVAS_H) /2;
// dump background, for alpha blending
dump_bg();
// init first frame with background dump
memcpy((uint8_t *)ctx.canvas, (uint8_t *)ctx.bg, CANVAS_W * CANVAS_H * sizeof(uint32_t));
}
// --------------------------------------------------
// This changes your app's window size to the correct output size
void ofxProjectorBlend::setWindowToDisplaySize()
{
ofSetWindowShape(getDisplayWidth(), getDisplayHeight());
}
bool PageView::paintPage(cairo_t * cr, GdkRectangle * rect) {
XOJ_CHECK_TYPE(PageView);
double zoom = xournal->getZoom();
g_mutex_lock(this->drawingMutex);
int dispWidth = getDisplayWidth();
int dispHeight = getDisplayHeight();
if (this->crBuffer == NULL) {
this->crBuffer = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, dispWidth, dispHeight);
cairo_t * cr2 = cairo_create(this->crBuffer);
cairo_set_source_rgb(cr2, 1, 1, 1);
cairo_rectangle(cr2, 0, 0, dispWidth, dispHeight);
cairo_fill(cr2);
cairo_scale(cr2, zoom, zoom);
const char * txtLoading = _("Loading...");
cairo_text_extents_t ex;
cairo_set_source_rgb(cr2, 0.5, 0.5, 0.5);
cairo_select_font_face(cr2, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size(cr2, 32.0);
cairo_text_extents(cr2, txtLoading, &ex);
cairo_move_to(cr2, (page.getWidth() - ex.width) / 2 - ex.x_bearing, (page.getHeight() - ex.height) / 2 - ex.y_bearing);
cairo_show_text(cr2, txtLoading);
cairo_destroy(cr2);
rerenderPage();
}
cairo_save(cr);
double width = cairo_image_surface_get_width(this->crBuffer);
if (width != dispWidth) {
double scale = ((double) dispWidth) / ((double) width);
// Scale current image to fit the zoom level
cairo_scale(cr, scale, scale);
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_FAST);
cairo_set_source_surface(cr, this->crBuffer, 0, 0);
rerenderPage();
rect = NULL;
} else {
cairo_set_source_surface(cr, this->crBuffer, 0, 0);
}
if (rect) {
cairo_rectangle(cr, rect->x, rect->y, rect->width, rect->height);
cairo_fill(cr);
#ifdef SHOW_PAINT_BOUNDS
cairo_set_source_rgb(cr, 1.0, 0.5, 1.0);
cairo_set_line_width(cr, 1. / zoom);
cairo_rectangle(cr, rect->x, rect->y, rect->width, rect->height);
cairo_stroke(cr);
#endif
} else {
cairo_paint(cr);
}
cairo_restore(cr);
// don't paint this with scale, because it needs a 1:1 zoom
if (this->verticalSpace) {
this->verticalSpace->paint(cr, rect, zoom);
}
cairo_scale(cr, zoom, zoom);
if (this->textEditor) {
this->textEditor->paint(cr, rect, zoom);
}
if (this->selection) {
this->selection->paint(cr, rect, zoom);
}
if (this->search) {
this->search->paint(cr, rect, zoom, getSelectionColor());
}
this->inputHandler->draw(cr, zoom);
g_mutex_unlock(this->drawingMutex);
return true;
}
/*!
* Return the distance from the left side of the image that is "pad" distance
* to the nearest point in the transparent outline from the line segment
* start at Y and running for distance Height below it.
* All distances are in logical units.
* -----------------
* | |
* | * |
* | ***** |
* |||||| *** |
* | | ** |
* |---------------|
* | |
* | |
*
* This case would give a -ve distance.
* The input yTop is in logical units as measured from the top of the image.
* If y is above the image it should be negative.
* The returned value is in logical units.
*/
UT_sint32 GR_Image::GetOffsetFromLeft(GR_Graphics * pG, UT_sint32 pad, UT_sint32 yTop, UT_sint32 height)
{
if(!hasAlpha())
{
return pad;
}
if(!isOutLinePresent())
{
GenerateOutline();
}
double maxDist = -10000000.0;
double d = 0.0;
UT_uint32 i = 0;
double ddPad = static_cast<double>(pG->tdu(pad));
UT_sint32 diTop = pG->tdu(yTop);
UT_sint32 diHeight = pG->tdu(height);
double ddTop = static_cast<double>(diTop);
double ddHeight = static_cast<double>(diHeight);
GR_Image_Point * pPoint = NULL;
UT_uint32 nPts = m_vecOutLine.getItemCount()/2;
for(i=0; i < nPts;i++)
{
pPoint = m_vecOutLine.getNthItem(i);
if((pPoint->m_iY >= diTop) && (pPoint->m_iY <= (yTop + diHeight)))
{
d = ddPad - static_cast<double>(pPoint->m_iX);
}
else
{
double y = ddTop + ddHeight;
if(abs(pPoint->m_iY - diTop) < abs(pPoint->m_iY - (diTop + diHeight)))
{
//
// Calculate from top point.
//
y = ddTop;
}
double dYP = static_cast<double>(pPoint->m_iY);
double root = ddPad*ddPad - (y - dYP)*(y - dYP);
if(root < 0.0)
{
//
// This point doesn't overlap at all
//
d = -10000000.0;
}
else
{
d = -static_cast<double>(pPoint->m_iX) - sqrt(root);
}
}
if(d > maxDist)
{
maxDist = d;
}
}
if(maxDist < -9999999.)
{
maxDist = static_cast<double>(-getDisplayWidth());
}
return pG->tlu(static_cast<UT_sint32>(maxDist));
}
/*!
* The idea is to create a
* new image from the rectangular segment in device units defined by
* UT_Rect rec. The Image should be deleted by the calling routine.
*/
GR_Image * GR_Win32Image::createImageSegment(GR_Graphics * pG,const UT_Rect & rec)
{
// this code assumes 24 bit RGB bitmaps ...
UT_return_val_if_fail(pG && m_pDIB && m_pDIB->bmiHeader.biBitCount == 24, NULL);
// the ration of x and y coords for the graphics class
double fXYRatio = ((GR_Win32Graphics *)pG)->getXYRatio();
// We have three different coordinate systems here:
//
// rec: the requested segment size, in layout units
//
// m_pDIB->bmiHeader.biHeight/Width(): physical size of the bitmap
//
// getDisplayWidth()/Height() : size in device units for which this image was to be
// rendered
//
// From these we need to work out the size/offset of the segment in the DIB
// coordinaces
// these are the DIB physical dimensions of the original
UT_sint32 dH = m_pDIB->bmiHeader.biHeight;
UT_sint32 dW = m_pDIB->bmiHeader.biWidth;
// this is the internal scaling of the orginal DIB, which we need to workout
// relationship between display units and DIB units; we need to use separate factors
// for x and y axis, since the proportions of the DIB have no formal relationship to
// the dimensions of the displayed rectangle (e.g., the display image could be
// cropped).
double fDibScaleFactorX = (double) dW / (double)getDisplayWidth();
double fDibScaleFactorY = (double) dH / (double)getDisplayHeight();
// these are the requested dimensions in device units
UT_sint32 widthDU = (UT_sint32)((double)pG->tdu(rec.width) * fXYRatio);
UT_sint32 heightDU = pG->tdu(rec.height);
UT_sint32 xDU = (UT_sint32)((double)pG->tdu(rec.left) * fXYRatio);
UT_sint32 yDU = pG->tdu(rec.top);
// now convert the DUs into DIB units -- these are the values we need to work with
// when copying the image segment
UT_sint32 widthDIB = (UT_sint32)((double)widthDU * fDibScaleFactorX);
UT_sint32 heightDIB = (UT_sint32)((double)heightDU * fDibScaleFactorY);
UT_sint32 xDIB = (UT_sint32)((double)xDU * fDibScaleFactorX);
UT_sint32 yDIB = (UT_sint32)((double)yDU * fDibScaleFactorY);
if(xDIB < 0)
{
xDIB = 0;
}
if(yDIB < 0)
{
yDIB = 0;
}
if(heightDIB > dH)
{
heightDIB = dH;
}
if(widthDIB > dW)
{
widthDIB = dW;
}
if(xDIB + widthDIB > dW)
{
widthDIB = dW - xDIB;
}
if(yDIB + heightDIB > dH)
{
heightDIB = dH - yDIB;
}
if(widthDIB < 0)
{
xDIB = dW -1;
widthDIB = 1;
}
if(heightDIB < 0)
{
yDIB = dH -1;
heightDIB = 1;
}
UT_String sName("");
getName(sName);
UT_String sSub("");
UT_String_sprintf(sSub,"_segment_%d_%d_%d_%d",xDIB,yDIB,widthDIB,heightDIB);
sName += sSub;
GR_Win32Image * pImage = new GR_Win32Image(sName.c_str());
UT_return_val_if_fail( pImage, NULL );
// now allocate memory -- mostly copied from convertFromBuffer()
UT_uint32 iBytesInRow = widthDIB * 3;
if (iBytesInRow % 4)
{
iBytesInRow += (4 - (iBytesInRow % 4));
}
pImage->m_pDIB = (BITMAPINFO*) g_try_malloc(sizeof(BITMAPINFOHEADER) + heightDIB * iBytesInRow);
UT_return_val_if_fail( pImage->m_pDIB, NULL );
// simply copy the whole header
memcpy(pImage->m_pDIB, m_pDIB, sizeof(BITMAPINFOHEADER));
// now set the image size ...
pImage->setDisplaySize(widthDU, heightDU);
pImage->m_pDIB->bmiHeader.biWidth = widthDIB;
pImage->m_pDIB->bmiHeader.biHeight = heightDIB;
pImage->m_pDIB->bmiHeader.biSizeImage = 0;
// now copy the bitmap bits
// the rows in both maps are/need to be padded to 4-bytes
// NB: in the DIB lines are numbered from bottom up, while in our coord system y goes
// from top to bottom
// how wide is a row in the orignal ?
UT_uint32 iOrigRowBytes = m_pDIB->bmiHeader.biWidth*3;
if(iOrigRowBytes%4)
iOrigRowBytes += (4 - iOrigRowBytes%4);
// what are the coords in the orginal we want?
UT_uint32 iByteWidth = widthDIB*3;
UT_uint32 iLeft = xDIB*3;
UT_uint32 iRight = iLeft + iByteWidth;
UT_uint32 iTop = m_pDIB->bmiHeader.biHeight - yDIB;
UT_uint32 iBottom = iTop - heightDIB;
UT_uint32 iRightPadded = iRight + (iBytesInRow - iByteWidth);
UT_Byte * pBits1 = ((UT_Byte*)m_pDIB) + sizeof(BITMAPINFOHEADER);
UT_Byte * pBits2 = ((UT_Byte*)pImage->m_pDIB) + sizeof(BITMAPINFOHEADER);
UT_uint32 iRow;
for(iRow = iBottom; iRow < iTop; iRow++)
{
memcpy(pBits2, pBits1 + iRow * iOrigRowBytes + iLeft, iByteWidth);
pBits2 += iByteWidth;
// now the padding ...
for(UT_uint32 iPad = iRight; iPad < iRightPadded; iPad++, pBits2++)
{
*pBits2 = 0;
}
}
return static_cast<GR_Image *>(pImage);
}
int
main(int argc, char* argv[])
{
Collectors = NULL;
#ifdef HAVE_EXT_POSTGRESQL
HistorySnapshot *historySnapshot;
SQLQuery queryhor;
SQLQuery queryver;
QuillErrCode st;
bool remotequill=false;
char *quillName=NULL;
AttrList *ad=0;
int flag = 1;
void **parameters;
char *dbconn=NULL;
char *completedsince = NULL;
char *dbIpAddr=NULL, *dbName=NULL,*queryPassword=NULL;
bool remoteread = false;
#endif /* HAVE_EXT_POSTGRESQL */
const char *owner=NULL;
bool readfromfile = true;
bool fileisuserlog = false;
char* JobHistoryFileName=NULL;
const char * pcolon=NULL;
GenericQuery constraint; // used to build a complex constraint.
ExprTree *constraintExpr=NULL;
std::string tmp;
int i;
myDistro->Init( argc, argv );
config();
#ifdef HAVE_EXT_POSTGRESQL
parameters = (void **) malloc(NUM_PARAMETERS * sizeof(void *));
queryhor.setQuery(HISTORY_ALL_HOR, NULL);
queryver.setQuery(HISTORY_ALL_VER, NULL);
#endif /* HAVE_EXT_POSTGRESQL */
for(i=1; i<argc; i++) {
if (is_dash_arg_prefix(argv[i],"long",1)) {
longformat=TRUE;
}
else if (is_dash_arg_prefix(argv[i],"xml",3)) {
use_xml = true;
longformat = true;
}
else if (is_dash_arg_prefix(argv[i],"backwards",1)) {
backwards=TRUE;
}
// must be at least -forw to avoid conflict with -f (for file) and -format
else if (is_dash_arg_prefix(argv[i],"nobackwards",3) ||
is_dash_arg_prefix(argv[i],"forwards",4)) {
backwards=FALSE;
}
else if (is_dash_arg_colon_prefix(argv[i],"wide", &pcolon, 1)) {
wide_format=TRUE;
if (pcolon) {
wide_format_width = atoi(++pcolon);
if ( ! mask.IsEmpty()) mask.SetOverallWidth(getDisplayWidth()-1);
if (wide_format_width <= 80) wide_format = FALSE;
}
}
else if (is_dash_arg_prefix(argv[i],"match",1) || is_dash_arg_prefix(argv[i],"limit",3)) {
i++;
if (argc <= i) {
fprintf(stderr,
"Error: Argument -match requires a number value "
" as a parameter.\n");
exit(1);
}
specifiedMatch = atoi(argv[i]);
}
#ifdef HAVE_EXT_POSTGRESQL
else if(is_dash_arg_prefix(argv[i], "dbname",1)) {
i++;
if (argc <= i) {
fprintf( stderr,
"Error: Argument -dbname requires the name of a quilld as a parameter\n" );
exit(1);
}
/*
if( !(quillName = get_daemon_name(argv[i])) ) {
fprintf( stderr, "Error: unknown host %s\n",
get_host_part(argv[i]) );
printf("\n");
print_wrapped_text("Extra Info: The name given with the -dbname "
"should be the name of a condor_quilld process. "
"Normally it is either a hostname, or "
"\"name@hostname\". "
"In either case, the hostname should be the "
"Internet host name, but it appears that it "
"wasn't.",
stderr);
exit(1);
}
sprintf (tmp, "%s == \"%s\"", ATTR_NAME, quillName);
quillQuery.addORConstraint (tmp);
*/
quillName = argv[i];
sprintf (tmp, "%s == \"%s\"", ATTR_SCHEDD_NAME, quillName);
quillQuery.addORConstraint (tmp.c_str());
remotequill = false;
readfromfile = false;
}
#endif /* HAVE_EXT_POSTGRESQL */
else if (is_dash_arg_prefix(argv[i],"file",2)) {
if (i+1==argc || JobHistoryFileName) break;
i++;
JobHistoryFileName=argv[i];
readfromfile = true;
}
else if (is_dash_arg_prefix(argv[i],"userlog",1)) {
if (i+1==argc || JobHistoryFileName) break;
i++;
JobHistoryFileName=argv[i];
readfromfile = true;
fileisuserlog = true;
}
else if (is_dash_arg_prefix(argv[i],"help",1)) {
Usage(argv[0],0);
}
else if (is_dash_arg_prefix(argv[i],"format",1)) {
if (argc <= i + 2) {
fprintf(stderr,
"Error: Argument -format requires a spec and "
"classad attribute name as parameters.\n");
fprintf(stderr,
"\t\te.g. condor_history -format '%%d' ClusterId\n");
exit(1);
}
mask.registerFormat(argv[i + 1], argv[i + 2]);
customFormat = true;
i += 2;
}
else if (*(argv[i]) == '-' &&
(is_arg_colon_prefix(argv[i]+1,"af", &pcolon, 2) ||
is_arg_colon_prefix(argv[i]+1,"autoformat", &pcolon, 5))) {
// make sure we have at least one argument to autoformat
if (argc <= i+1 || *(argv[i+1]) == '-') {
fprintf (stderr, "Error: Argument %s requires at last one attribute parameter\n", argv[i]);
fprintf(stderr, "\t\te.g. condor_history %s ClusterId\n", argv[i]);
exit(1);
}
if (pcolon) ++pcolon; // if there are options, skip over the colon to the options.
int ixNext = parse_autoformat_args(argc, argv, i+1, pcolon, mask, diagnostic);
if (ixNext > i)
i = ixNext-1;
customFormat = true;
}
else if (is_dash_arg_colon_prefix(argv[i], "print-format", &pcolon, 2)) {
if ( (argc <= i+1) || (*(argv[i+1]) == '-' && (argv[i+1])[1] != 0)) {
fprintf( stderr, "Error: Argument -print-format requires a filename argument\n");
exit( 1 );
}
// hack allow -pr ! to disable use of user-default print format files.
if (MATCH == strcmp(argv[i+1], "!")) {
++i;
disable_user_print_files = true;
continue;
}
if ( ! wide_format) mask.SetOverallWidth(getDisplayWidth()-1);
customFormat = true;
++i;
std::string where_expr;
if (set_print_mask_from_stream(mask, where_expr, argv[i], true) < 0) {
fprintf(stderr, "Error: cannot execute print-format file %s\n", argv[i]);
exit (1);
}
if ( ! where_expr.empty()) {
constraint.addCustomAND(where_expr.c_str());
}
}
else if (is_dash_arg_prefix(argv[i],"constraint",1)) {
// make sure we have at least one more argument
if (argc <= i+1) {
fprintf( stderr, "Error: Argument %s requires another parameter\n", argv[i]);
exit(1);
}
i++;
constraint.addCustomAND(argv[i]);
}
#ifdef HAVE_EXT_POSTGRESQL
else if (is_dash_arg_prefix(argv[i],"completedsince",3)) {
i++;
if (argc <= i) {
fprintf(stderr,
"Error: Argument -completedsince requires a date and "
"optional timestamp as a parameter.\n");
fprintf(stderr,
"\t\te.g. condor_history -completedsince \"2004-10-19 10:23:54\"\n");
exit(1);
}
if (constraint!="") break;
completedsince = strdup(argv[i]);
parameters[0] = completedsince;
queryhor.setQuery(HISTORY_COMPLETEDSINCE_HOR,parameters);
queryver.setQuery(HISTORY_COMPLETEDSINCE_VER,parameters);
}
#endif /* HAVE_EXT_POSTGRESQL */
else if (sscanf (argv[i], "%d.%d", &cluster, &proc) == 2) {
std::string jobconst;
formatstr (jobconst, "%s == %d && %s == %d",
ATTR_CLUSTER_ID, cluster,ATTR_PROC_ID, proc);
constraint.addCustomOR(jobconst.c_str());
#ifdef HAVE_EXT_POSTGRESQL
parameters[0] = &cluster;
parameters[1] = &proc;
queryhor.setQuery(HISTORY_CLUSTER_PROC_HOR, parameters);
queryver.setQuery(HISTORY_CLUSTER_PROC_VER, parameters);
#endif /* HAVE_EXT_POSTGRESQL */
}
else if (sscanf (argv[i], "%d", &cluster) == 1) {
std::string jobconst;
formatstr (jobconst, "%s == %d", ATTR_CLUSTER_ID, cluster);
constraint.addCustomOR(jobconst.c_str());
#ifdef HAVE_EXT_POSTGRESQL
parameters[0] = &cluster;
queryhor.setQuery(HISTORY_CLUSTER_HOR, parameters);
queryver.setQuery(HISTORY_CLUSTER_VER, parameters);
#endif /* HAVE_EXT_POSTGRESQL */
}
else if (is_dash_arg_prefix(argv[i],"debug",1)) {
// dprintf to console
dprintf_set_tool_debug("TOOL", 0);
}
else if (is_dash_arg_prefix(argv[i],"diagnostic",4)) {
// dprintf to console
diagnostic = true;
}
else if (is_dash_arg_prefix(argv[i], "name", 1)) {
i++;
if (argc <= i)
{
fprintf(stderr,
"Error: Argument -name requires name of a remote schedd\n");
fprintf(stderr,
"\t\te.g. condor_history -name submit.example.com \n");
exit(1);
}
g_name = argv[i];
readfromfile = false;
#ifdef HAVE_EXT_POSTGRESQL
remoteread = true;
#endif
}
else if (is_dash_arg_prefix(argv[i], "pool", 1)) {
i++;
if (argc <= i)
{
fprintf(stderr,
"Error: Argument -name requires name of a remote schedd\n");
fprintf(stderr,
"\t\te.g. condor_history -name submit.example.com \n");
exit(1);
}
g_pool = argv[i];
readfromfile = false;
#ifdef HAVE_EXT_POSTGRESQL
remoteread = true;
#endif
}
else {
std::string ownerconst;
owner = argv[i];
formatstr(ownerconst, "%s == \"%s\"", ATTR_OWNER, owner);
constraint.addCustomOR(ownerconst.c_str());
#ifdef HAVE_EXT_POSTGRESQL
parameters[0] = owner;
queryhor.setQuery(HISTORY_OWNER_HOR, parameters);
queryver.setQuery(HISTORY_OWNER_VER, parameters);
#endif /* HAVE_EXT_POSTGRESQL */
}
}
if (i<argc) Usage(argv[0]);
MyString my_constraint;
constraint.makeQuery(my_constraint);
if (diagnostic) {
fprintf(stderr, "Using effective constraint: %s\n", my_constraint.c_str());
}
if ( ! my_constraint.empty() && ParseClassAdRvalExpr( my_constraint.c_str(), constraintExpr ) ) {
fprintf( stderr, "Error: could not parse constraint %s\n", my_constraint.c_str() );
exit( 1 );
}
#ifdef HAVE_EXT_POSTGRESQL
/* This call must happen AFTER config() is called */
if (checkDBconfig() == true && !readfromfile) {
readfromfile = false;
} else {
readfromfile = true;
}
#endif /* HAVE_EXT_POSTGRESQL */
#ifdef HAVE_EXT_POSTGRESQL
if(!readfromfile && !remoteread) {
if(remotequill) {
if (Collectors == NULL) {
Collectors = CollectorList::create();
if(Collectors == NULL ) {
printf("Error: Unable to get list of known collectors\n");
exit(1);
}
}
result = Collectors->query ( quillQuery, quillList );
if(result != Q_OK) {
printf("Fatal Error querying collectors\n");
exit(1);
}
if(quillList.MyLength() == 0) {
printf("Error: Unknown quill server %s\n", quillName);
exit(1);
}
quillList.Open();
while ((ad = quillList.Next())) {
// get the address of the database
dbIpAddr = dbName = queryPassword = NULL;
if (!ad->LookupString(ATTR_QUILL_DB_IP_ADDR, &dbIpAddr) ||
!ad->LookupString(ATTR_QUILL_DB_NAME, &dbName) ||
!ad->LookupString(ATTR_QUILL_DB_QUERY_PASSWORD, &queryPassword) ||
(ad->LookupBool(ATTR_QUILL_IS_REMOTELY_QUERYABLE,flag) && !flag)) {
printf("Error: The quill daemon \"%s\" is not set up "
"for database queries\n",
quillName);
exit(1);
}
}
} else {
// they just typed 'condor_history' on the command line and want
// to use quill, so get the schedd ad for the local machine if
// we can, figure out the name of the schedd and the
// jobqueuebirthdate
Daemon schedd( DT_SCHEDD, 0, 0 );
if ( schedd.locate(Daemon::LOCATE_FULL) ) {
char *scheddname = quillName;
if (scheddname == NULL) {
// none set explictly, look it up in the daemon ad
scheddname = schedd.name();
ClassAd *daemonAd = schedd.daemonAd();
int scheddbirthdate;
if(daemonAd) {
if(daemonAd->LookupInteger( ATTR_JOB_QUEUE_BIRTHDATE,
scheddbirthdate) ) {
queryhor.setJobqueuebirthdate( (time_t)scheddbirthdate);
queryver.setJobqueuebirthdate( (time_t)scheddbirthdate);
}
}
} else {
queryhor.setJobqueuebirthdate(0);
queryver.setJobqueuebirthdate(0);
}
queryhor.setScheddname(scheddname);
queryver.setScheddname(scheddname);
}
}
dbconn = getDBConnStr(quillName,dbIpAddr,dbName,queryPassword);
historySnapshot = new HistorySnapshot(dbconn);
if (!customFormat) {
printf ("\n\n-- Quill: %s : %s : %s\n", quillName,
dbIpAddr, dbName);
}
queryhor.prepareQuery(); // create the query strings before sending off to historySnapshot
queryver.prepareQuery();
st = historySnapshot->sendQuery(&queryhor, &queryver, longformat,
false, customFormat, &mask, constraint.c_str());
//if there's a failure here and if we're not posing a query on a
//remote quill daemon, we should instead query the local file
if(st == QUILL_FAILURE) {
printf( "-- Database at %s not reachable\n", dbIpAddr);
if(!remotequill) {
char *tmp_hist = param("HISTORY");
if (!customFormat) {
printf( "--Failing over to the history file at %s instead --\n",
tmp_hist ? tmp_hist : "(null)" );
}
if(!tmp_hist) {
free(tmp_hist);
}
readfromfile = true;
}
}
// query history table
if (historySnapshot->isHistoryEmpty()) {
printf("No historical jobs in the database match your query\n");
}
historySnapshot->release();
delete(historySnapshot);
}
#endif /* HAVE_EXT_POSTGRESQL */
if(readfromfile == true) {
readHistoryFromFiles(fileisuserlog, JobHistoryFileName, my_constraint.c_str(), constraintExpr);
}
else {
readHistoryRemote(constraintExpr);
}
#ifdef HAVE_EXT_POSTGRESQL
if(completedsince) free(completedsince);
if(parameters) free(parameters);
if(dbIpAddr) free(dbIpAddr);
if(dbName) free(dbName);
if(queryPassword) free(queryPassword);
if(dbconn) free(dbconn);
#endif
return 0;
}
int main()
{
lightDir.x=0.5;
lightDir.y=.7;
lightDir.z=-0.5;
kmVec3Normalize(&lightDir,&lightDir);
// creates a window and GLES context
if (makeContext() != 0)
exit(-1);
// all the shaders have at least texture unit 0 active so
// activate it now and leave it active
glActiveTexture(GL_TEXTURE0);
// The obj shapes and their textures are loaded
cubeTex = loadPNG("resources/textures/dice.png");
loadObj(&cubeObj, "resources/models/cube.gbo",
"resources/shaders/textured.vert", "resources/shaders/textured.frag");
shipTex = loadPNG("resources/textures/shipv2.png");
loadObjCopyShader(&shipObj,"resources/models/ship.gbo",&cubeObj);
alienTex = loadPNG("resources/textures/alien.png");
loadObjCopyShader(&alienObj, "resources/models/alien.gbo", &cubeObj);
shotTex = loadPNG("resources/textures/shot.png");
loadObjCopyShader(&shotObj, "resources/models/shot.gbo", &cubeObj);
expTex = loadPNG("resources/textures/explosion.png");
playerPos.x = 0;
playerPos.y = 0;
playerPos.z = 0;
kmMat4Identity(&view);
pEye.x = 0;
pEye.y = 2;
pEye.z = 4;
pCenter.x = 0;
pCenter.y = 0;
pCenter.z = -5;
pUp.x = 0;
pUp.y = 1;
pUp.z = 0;
kmMat4LookAt(&view, &pEye, &pCenter, &pUp);
// projection matrix, as distance increases
// the way the model is drawn is effected
kmMat4Identity(&projection);
kmMat4PerspectiveProjection(&projection, 45,
(float)getDisplayWidth() / getDisplayHeight(), 0.1, 100);
glViewport(0, 0, getDisplayWidth(), getDisplayHeight());
// these two matrices are pre combined for use with each model render
kmMat4Assign(&vp, &projection);
kmMat4Multiply(&vp, &vp, &view);
// initialises glprint's matrix shader and texture
initGlPrint(getDisplayWidth(), getDisplayHeight());
font1=createFont("resources/textures/font.png",0,256,16,16,16);
font2=createFont("resources/textures/bigfont.png",32,512,9.5,32,48);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_BLEND); // only used by glprintf
glEnable(GL_DEPTH_TEST);
struct timeval t, ta, t1, t2; // fps stuff
gettimeofday(&t1, NULL);
int num_frames = 0;
bool quit = false;
mouse = getMouse();
keys = getKeys();
resetAliens();
for (int n = 0; n < MAX_PLAYER_SHOTS; n++) {
playerShots[n].alive = false;
}
initPointClouds("resources/shaders/particle.vert",
"resources/shaders/particle.frag",(float)getDisplayWidth()/24.0);
for (int n = 0; n < MAX_ALIENS; n++) {
aliens[n].explosion=createPointCloud(40);
resetExposion(aliens[n].explosion); // sets initials positions
}
while (!quit) { // the main loop
doEvents(); // update mouse and key arrays
// mask of 4 is right mouse
if (keys[KEY_ESC])
quit = true;
glClearColor(0, .5, 1, 1);
// render between two gettimeofday calls so
// we can sleep long enough to roughly sync
// to ~60fps but not on the pi!
// TODO find something a tad more elegent
long i;
gettimeofday(&t, NULL);
i = t.tv_sec * 1e6 + t.tv_usec;
// render();
float rad; // radians rotation based on frame counter
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
frame++;
rad = frame * (0.0175f * 2);
kmMat4Identity(&model);
kmMat4Translation(&model, playerPos.x, playerPos.y, playerPos.z);
playerCroll +=
(PIDcal(playerRoll, playerCroll, &playerPre_error, &playerIntegral)
/ 2);
kmMat4RotationPitchYawRoll(&model, 0, 3.1416, playerCroll * 3); //
kmMat4Assign(&mvp, &vp);
kmMat4Multiply(&mvp, &mvp, &model);
kmMat4Assign(&mv, &view);
kmMat4Multiply(&mv, &mv, &model);
glBindTexture(GL_TEXTURE_2D, shipTex);
drawObj(&shipObj, &mvp, &mv, lightDir, viewDir);
glPrintf(50 + sinf(rad) * 16, 240 + cosf(rad) * 16,
font2,"frame=%i fps=%3.2f", frame, lfps);
kmVec3 tmp;
playerFireCount--;
if (keys[KEY_LCTRL] && playerFireCount < 0) {
struct playerShot_t *freeShot;
freeShot = getFreeShot();
if (freeShot != 0) {
playerFireCount = 15;
freeShot->alive = true;
kmVec3Assign(&freeShot->pos, &playerPos);
}
}
for (int n = 0; n < MAX_PLAYER_SHOTS; n++) {
if (playerShots[n].alive) {
playerShots[n].pos.z -= .08;
if (playerShots[n].pos.z < -10)
playerShots[n].alive = false;
kmMat4Identity(&model);
kmMat4Translation(&model, playerShots[n].pos.x,
playerShots[n].pos.y,
playerShots[n].pos.z);
kmMat4RotationPitchYawRoll(&model, rad * 4, 0,
-rad * 4);
kmMat4Assign(&mvp, &vp);
kmMat4Multiply(&mvp, &mvp, &model);
kmMat4Assign(&mv, &view);
kmMat4Multiply(&mv, &mv, &model);
glBindTexture(GL_TEXTURE_2D, shotTex);
drawObj(&shotObj, &mvp, &mv, lightDir, viewDir);
}
}
playerRoll = 0;
if (keys[KEY_CURSL] && playerPos.x > -10) {
playerPos.x -= 0.1;
playerRoll = .2;
}
if (keys[KEY_CURSR] && playerPos.x < 10) {
playerPos.x += 0.1;
playerRoll = -.2;
}
pEye.x = playerPos.x * 1.25;
pCenter.x = playerPos.x;
pCenter.y = playerPos.y + 1;
pCenter.z = playerPos.z;
int deadAliens;
deadAliens = 0;
for (int n = 0; n < MAX_ALIENS; n++) {
if (aliens[n].alive == true) {
kmMat4Identity(&model);
kmMat4Translation(&model, aliens[n].pos.x,
aliens[n].pos.y, aliens[n].pos.z);
kmMat4RotationPitchYawRoll(&model, -.4, 0, 0);
kmMat4Assign(&mvp, &vp);
kmMat4Multiply(&mvp, &mvp, &model);
kmMat4Assign(&mv, &view);
kmMat4Multiply(&mv, &mv, &model);
glBindTexture(GL_TEXTURE_2D, alienTex);
drawObj(&alienObj, &mvp, &mv, lightDir, viewDir);
kmVec3 d;
for (int i = 0; i < MAX_PLAYER_SHOTS; i++) {
kmVec3Subtract(&d, &aliens[n].pos,
&playerShots[i].pos);
if (kmVec3Length(&d) < .7
&& playerShots[i].alive) {
aliens[n].alive = false;
playerShots[i].alive = false;
aliens[n].exploding = true;
resetExposion(aliens[n].explosion);
}
}
}
if (aliens[n].alive != true && aliens[n].exploding != true) {
deadAliens++;
}
}
if (deadAliens == MAX_ALIENS) {
resetAliens();
}
// draw explosions after ALL aliens
for (int n = 0; n < MAX_ALIENS; n++) {
if (aliens[n].exploding==true) {
kmMat4Identity(&model);
kmMat4Translation(&model, aliens[n].pos.x,
aliens[n].pos.y, aliens[n].pos.z);
kmMat4Assign(&mvp, &vp);
kmMat4Multiply(&mvp, &mvp, &model);
glBindTexture(GL_TEXTURE_2D, expTex);
drawPointCloud(aliens[n].explosion, &mvp);
aliens[n].explosion->tick=aliens[n].explosion->tick+0.05;
if (aliens[n].explosion->tick>1.25) {
aliens[n].exploding=false;
} else {
// update the explosion
for (int i=0; i<aliens[n].explosion->totalPoints; i++) {
float t;
t=aliens[n].explosion->tick;
if (i>aliens[n].explosion->totalPoints/2) t=t/2.0;
aliens[n].explosion->pos[i*3]=aliens[n].explosion->vel[i*3] * t;
aliens[n].explosion->pos[i*3+1]=aliens[n].explosion->vel[i*3+1] * t;
aliens[n].explosion->pos[i*3+2]=aliens[n].explosion->vel[i*3+2] * t;
}
}
}
}
// move camera
kmMat4LookAt(&view, &pEye, &pCenter, &pUp);
kmMat4Assign(&vp, &projection);
kmMat4Multiply(&vp, &vp, &view);
kmVec3Subtract(&viewDir,&pEye,&pCenter);
kmVec3Normalize(&viewDir,&viewDir);
// dump values
glPrintf(100, 280, font1,"eye %3.2f %3.2f %3.2f ", pEye.x, pEye.y, pEye.z);
glPrintf(100, 296, font1,"centre %3.2f %3.2f %3.2f ", pCenter.x, pCenter.y,
pCenter.z);
glPrintf(100, 320, font1,"mouse %i,%i %i ", mouse[0], mouse[1], mouse[2]);
glPrintf(100, 340, font1,"frame %i %i ", frame, frame % 20);
swapBuffers();
gettimeofday(&ta, NULL);
long j = (ta.tv_sec * 1e6 + ta.tv_usec);
i = j - i;
if (i < 0)
i = 1000000; // pass through - slower that 60fps
if (i < 16000)
usleep(16000 - i);
// every 10 frames average the time taken and store
// fps value for later printing with glprintf
if (++num_frames % 10 == 0) {
gettimeofday(&t2, NULL);
float dtf =
t2.tv_sec - t1.tv_sec + (t2.tv_usec -
t1.tv_usec) * 1e-6;
lfps = num_frames / dtf;
num_frames = 0;
t1 = t2;
}
}
closeContext();
return 0;
}
int main()
{
// creates a window and GLES context
if (makeContext() != 0)
exit(-1);
// all the shaders have at least texture unit 0 active so
// activate it now and leave it active
glActiveTexture(GL_TEXTURE0);
flareTex = loadPNG("resources/textures/cloud.png");
width = getDisplayWidth();
height = getDisplayHeight();
glViewport(0, 0, getDisplayWidth(), getDisplayHeight());
// initialises glprint's matrix, shader and texture
initGlPrint(getDisplayWidth(), getDisplayHeight());
font1=createFont("resources/textures/font.png",0,256,16,16,16);
initSprite(getDisplayWidth(), getDisplayHeight());
fileid = 0;
loadfile();
for (int i=0; i<max_flares; i++) {
flares[i].x=rand_range(0,getDisplayWidth());
flares[i].y=rand_range(0,getDisplayHeight());
flares[i].vx=rand_range(0,10)-5;
flares[i].vy=rand_range(0,10)-5;
}
/*for (int i=0; i<max_targets; i++) {
targets[i].x=rand_range(0,getDisplayWidth());
targets[i].y=rand_range(0,getDisplayHeight());
targets[i].flares = 0;
}*/
/*for (int i=0; i<max_flares; i++) {
flares[i].x=rand_range(0,getDisplayWidth());
flares[i].y=rand_range(0,getDisplayHeight());
flares[i].vx=rand_range(0,10)-5;
flares[i].vy=rand_range(0,10)-5;
flares[i].target = (int)rand_range(0,max_targets);
targets[flares[i].target].flares ++;
}*/
// we don't want to draw the back of triangles
// the blending is set up for glprint but disabled
// while not in use
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glClearColor(0, 0.5, 1, 1);
// count each frame
int num_frames = 0;
// set to true to leave main loop
bool quit = false;
// get a pointer to the key down array
keys = getKeys();
int* mouse = getMouse();
while (!quit) { // the main loop
doEvents(); // update mouse and key arrays
if (keys[KEY_ESC])
quit = true; // exit if escape key pressed
if (keys[KEY_SPACE])
relocate_targets(); // exit if escape key pressed
if (keys[KEY_RETURN])
reassign_flares(); // exit if escape key pressed
if (keys[KEY_S] && !lastkeys[KEY_S])
save(); // exit if escape key pressed
if (keys[KEY_CURSL] && !lastkeys[KEY_CURSL]){
fileid--;
if (fileid <0) fileid = 0;
loadfile(); // exit if escape key pressed
}
if (keys[KEY_CURSR] && !lastkeys[KEY_CURSR]){
fileid++;
loadfile(); // exit if escape key pressed
}
if (keys[KEY_C]){
max_targets = 1; // exit if escape key pressed
reassign_flares();
}
lastkeys[KEY_S] = keys[KEY_S];
lastkeys[KEY_CURSL] = keys[KEY_CURSL];
lastkeys[KEY_CURSR] = keys[KEY_CURSR];
mx = mouse[0];
my = mouse[1];
if(mouse[2] != 0){
spawn_target(mx,my);
}
for (int i=0; i<RE_MULTIPLY; i++){
random_events();
}
think();
render(); // the render loop
usleep(1600); // no need to run cpu/gpu full tilt
}
closeContext(); // tidy up
return 0;
}
void setPPwidth () {
if (wide_display || forced_display_width) {
pm.SetOverallWidth(getDisplayWidth()-1);
}
}
DisplayConfigPtr DisplayConfigFactory::create(OSVR_ClientContext ctx) {
DisplayConfigPtr cfg(new DisplayConfig);
try {
auto const descriptorString = ctx->getStringParameter("/display");
auto desc = display_schema_1::DisplayDescriptor(descriptorString);
cfg->m_viewers.container().emplace_back(Viewer(ctx, HEAD_PATH));
auto &viewer = cfg->m_viewers.container().front();
auto eyesDesc = desc.getEyes();
/// Set up stereo vs mono
std::vector<uint8_t> eyeIndices;
Eigen::Vector3d offset;
if (eyesDesc.size() == 2) {
// stereo
offset = desc.getIPDMeters() / 2. * Eigen::Vector3d::UnitX();
eyeIndices = {0, 1};
} else {
// if (eyesDesc.size() == 1)
// mono
offset = Eigen::Vector3d::Zero();
eyeIndices = {0};
}
/// Handle radial distortion parameters
boost::optional<OSVR_RadialDistortionParameters> distort;
auto k1 = desc.getDistortion();
if (k1.k1_red != 0 || k1.k1_green != 0 || k1.k1_blue != 0) {
OSVR_RadialDistortionParameters params;
params.k1.data[0] = k1.k1_red;
params.k1.data[1] = k1.k1_green;
params.k1.data[2] = k1.k1_blue;
distort = params;
}
/// Compute angular offset about Y of the optical (view) axis
util::Angle axisOffset = 0. * util::radians;
{
auto overlapPct = desc.getOverlapPercent();
if (overlapPct < 1.) {
const auto hfov = desc.getHorizontalFOV();
const auto angularOverlap = hfov * overlapPct;
axisOffset = (hfov - angularOverlap) / 2.;
}
}
/// Infer the number of display inputs and their association with
/// eyes (actually surfaces) based on the descriptor.
std::vector<OSVR_DisplayInputCount> displayInputIndices;
if (eyesDesc.size() == 2 &&
display_schema_1::DisplayDescriptor::FULL_SCREEN ==
desc.getDisplayMode()) {
// two eyes, full screen - that means two screens.
displayInputIndices = {0, 1};
cfg->m_displayInputs.push_back(DisplayInput(
desc.getDisplayWidth(), desc.getDisplayHeight()));
cfg->m_displayInputs.push_back(DisplayInput(
desc.getDisplayWidth(), desc.getDisplayHeight()));
} else {
// everything else, assume 1 screen.
// Note that it's OK that displayInputIndices.size() >=
// eyesDesc.size(), we'll just not end up using the second
// entry.
displayInputIndices = {0, 0};
cfg->m_displayInputs.push_back(DisplayInput(
desc.getDisplayWidth(), desc.getDisplayHeight()));
}
BOOST_ASSERT_MSG(displayInputIndices.size() >= eyesDesc.size(),
"Must have at least as many indices as eyes");
/// Create the actual eye (with implied surface) objects
for (auto eye : eyeIndices) {
// This little computation turns 0 into -1 and 1 into 1, used as
// a coefficient to make the two eyes do opposite things.
// Doesn't affect mono, which has a zero offset vector.
double offsetFactor = (2. * eye) - 1.;
// Set up per-eye distortion parameters, if needed
boost::optional<OSVR_RadialDistortionParameters> distortEye(
distort);
if (distortEye) {
distortEye->centerOfProjection.data[0] =
eyesDesc[eye].m_CenterProjX;
distortEye->centerOfProjection.data[1] =
eyesDesc[eye].m_CenterProjY;
}
// precompute translation offset for this eye
auto xlateOffset = (offsetFactor * offset).eval();
// precompute the optical axis rotation for this eye
// here, the left eye should get a positive offset since it's a
// positive rotation about y, hence the -1 factor.
auto eyeAxisOffset = axisOffset * -1. * offsetFactor;
// Look up the display index for this eye.
auto displayInputIdx = displayInputIndices[eye];
/// Create the ViewerEye[Surface] and add it to the container.
viewer.container().emplace_back(ViewerEye(
ctx, xlateOffset, HEAD_PATH, computeViewport(eye, desc),
computeRect(desc), eyesDesc[eye].m_rotate180,
desc.getPitchTilt().value(), distortEye, displayInputIdx,
eyeAxisOffset));
}
OSVR_DEV_VERBOSE("Display: " << desc.getHumanReadableDescription());
return cfg;
} catch (std::exception const &e) {
OSVR_DEV_VERBOSE(
"Couldn't create a display config internally! Exception: "
<< e.what());
return DisplayConfigPtr{};
} catch (...) {
OSVR_DEV_VERBOSE("Couldn't create a display config internally! "
"Unknown exception!");
return DisplayConfigPtr{};
}
}
