int checkDepth(TreeNode *node) {
if (node == nullptr) return 0;
int left = checkDepth(node->left),
right = checkDepth(node->right);
if (left < 0 || right < 0) return -1;
int diff = abs(left - right);
if (diff > 1) return -1;
return 1 + max(left, right);
}
bool
XWindow::CreateAtomsAndWindow(GC gc,
int x,
int y,
int windowWidth,
int windowHeight)
{
XSetWindowAttributes xswattributes;
// initialize atoms
WM_DELETE_WINDOW = XInternAtom (_display, "WM_DELETE_WINDOW", False);
XA_WIN_PROTOCOLS = XInternAtom (_display, "_WIN_PROTOCOLS", False);
XA_NET_SUPPORTED = XInternAtom (_display, "_NET_SUPPORTED", False);
XA_NET_WM_STATE = XInternAtom (_display, "_NET_WM_STATE", False);
XA_NET_WM_STATE_FULLSCREEN = XInternAtom (_display, "_NET_WM_STATE_FULLSCREEN", False);
XA_NET_WM_STATE_ABOVE = XInternAtom (_display, "_NET_WM_STATE_ABOVE", False);
XA_NET_WM_STATE_STAYS_ON_TOP = XInternAtom (_display, "_NET_WM_STATE_STAYS_ON_TOP", False);
XA_NET_WM_STATE_BELOW = XInternAtom (_display, "_NET_WM_STATE_BELOW", False);
XSync (_display, False);
if (!checkDepth())
return false;
// define window properties and create the window
xswattributes.colormap = XCreateColormap (_display, _rootWindow, _XVInfo.visual, AllocNone);
xswattributes.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask | ButtonPressMask;
xswattributes.background_pixel = WhitePixel (_display, DefaultScreen (_display));
xswattributes.border_pixel = WhitePixel (_display, DefaultScreen (_display));
_XWindow = XCreateWindow (_display, _rootWindow, x, y, windowWidth, windowHeight,
0, _XVInfo.depth, InputOutput, _XVInfo.visual,
CWBackPixel | CWBorderPixel | CWColormap | CWEventMask, &xswattributes);
PTRACE(4, "X11\tCreated Window with ID " << _XWindow);
SetSizeHints (DEFAULT_X,DEFAULT_Y, _imageWidth, _imageHeight, windowWidth, windowHeight);
// map the window
XMapWindow (_display, _XWindow);
XSetWMProtocols (_display, _XWindow, &WM_DELETE_WINDOW, 1);
// Checking if we are going embedded or not
if (gc) {
_gc = gc;
_embedded = true;
}
else {
_gc = XCreateGC (_display, _XWindow, 0, 0);
_embedded = false;
}
return true;
}
///////////////////////////////////////////////////////////////////////////////
// runOne: Run a single test case
///////////////////////////////////////////////////////////////////////////////
void
ReadPixSanityTest::runOne(ReadPixSanityResult& r, GLEAN::Window& w) {
// Many (if not most) other tests need to read the contents of
// the framebuffer to determine if the correct image has been
// drawn. Obviously this is a waste of time if the basic
// functionality of glReadPixels isn't working.
//
// This test does a "sanity" check of glReadPixels. Using as
// little of the GL as practicable, it writes a random value
// in the framebuffer, reads it, and compares the value read
// with the value written.
glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
glPixelTransferi(GL_MAP_STENCIL, GL_FALSE);
glPixelTransferi(GL_INDEX_SHIFT, 0);
glPixelTransferi(GL_INDEX_OFFSET, 0);
glPixelTransferf(GL_RED_SCALE, 1.0);
glPixelTransferf(GL_GREEN_SCALE, 1.0);
glPixelTransferf(GL_BLUE_SCALE, 1.0);
glPixelTransferf(GL_ALPHA_SCALE, 1.0);
glPixelTransferf(GL_DEPTH_SCALE, 1.0);
glPixelTransferf(GL_RED_BIAS, 0.0);
glPixelTransferf(GL_GREEN_BIAS, 0.0);
glPixelTransferf(GL_BLUE_BIAS, 0.0);
glPixelTransferf(GL_ALPHA_BIAS, 0.0);
glPixelTransferf(GL_DEPTH_BIAS, 0.0);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_DITHER);
glIndexMask(~0);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDepthMask(GL_TRUE);
glStencilMask(~0);
if (r.config->canRGBA)
checkRGBA(r, w);
if (r.config->z)
checkDepth(r, w);
if (r.config->s)
checkStencil(r, w);
r.pass = r.passRGBA & r.passDepth & r.passStencil & r.passIndex;
} // ReadPixSanityTest::runOne
// update the dive and return the notes field, stripped of the HTML junk
void QMLManager::commitChanges(QString diveId, QString date, QString location, QString gps, QString duration, QString depth,
QString airtemp, QString watertemp, QString suit, QString buddy, QString diveMaster, QString weight, QString notes,
QString startpressure, QString endpressure, QString gasmix)
{
struct dive *d = get_dive_by_uniq_id(diveId.toInt());
DiveObjectHelper *myDive = new DiveObjectHelper(d);
// notes comes back as rich text - let's convert this into plain text
QTextDocument doc;
doc.setHtml(notes);
notes = doc.toPlainText();
if (!d) {
qDebug() << "don't touch this... no dive";
return;
}
bool diveChanged = false;
bool needResort = false;
diveChanged = needResort = checkDate(myDive, d, date);
diveChanged |= checkLocation(myDive, d, location, gps);
diveChanged |= checkDuration(myDive, d, duration);
diveChanged |= checkDepth(myDive, d, depth);
if (myDive->airTemp() != airtemp) {
diveChanged = true;
d->airtemp.mkelvin = parseTemperatureToMkelvin(airtemp);
}
if (myDive->waterTemp() != watertemp) {
diveChanged = true;
d->watertemp.mkelvin = parseTemperatureToMkelvin(watertemp);
}
// not sure what we'd do if there was more than one weight system
// defined - for now just ignore that case
if (weightsystem_none((void *)&d->weightsystem[1])) {
if (myDive->sumWeight() != weight) {
diveChanged = true;
d->weightsystem[0].weight.grams = parseWeightToGrams(weight);
}
}
// start and end pressures for first cylinder only
if (myDive->startPressure() != startpressure || myDive->endPressure() != endpressure) {
diveChanged = true;
d->cylinder[0].start.mbar = parsePressureToMbar(startpressure);
d->cylinder[0].end.mbar = parsePressureToMbar(endpressure);
if (d->cylinder[0].end.mbar > d->cylinder[0].start.mbar)
d->cylinder[0].end.mbar = d->cylinder[0].start.mbar;
}
// gasmix for first cylinder
if (myDive->firstGas() != gasmix) {
int o2 = parseGasMixO2(gasmix);
int he = parseGasMixHE(gasmix);
// the QML code SHOULD only accept valid gas mixes, but just to make sure
if (o2 >= 0 && o2 <= 1000 &&
he >= 0 && he <= 1000 &&
o2 + he <= 1000) {
diveChanged = true;
d->cylinder[0].gasmix.o2.permille = o2;
d->cylinder[0].gasmix.he.permille = he;
}
}
if (myDive->suit() != suit) {
diveChanged = true;
free(d->suit);
d->suit = strdup(qPrintable(suit));
}
if (myDive->buddy() != buddy) {
diveChanged = true;
free(d->buddy);
d->buddy = strdup(qPrintable(buddy));
}
if (myDive->divemaster() != diveMaster) {
diveChanged = true;
free(d->divemaster);
d->divemaster = strdup(qPrintable(diveMaster));
}
if (myDive->notes() != notes) {
diveChanged = true;
free(d->notes);
d->notes = strdup(qPrintable(notes));
}
// now that we have it all figured out, let's see what we need
// to update
DiveListModel *dm = DiveListModel::instance();
int oldModelIdx = dm->getDiveIdx(d->id);
int oldIdx = get_idx_by_uniq_id(d->id);
if (needResort) {
// we know that the only thing that might happen in a resort is that
// this one dive moves to a different spot in the dive list
sort_table(&dive_table);
int newIdx = get_idx_by_uniq_id(d->id);
if (newIdx != oldIdx) {
DiveListModel::instance()->removeDive(oldModelIdx);
DiveListModel::instance()->insertDive(oldModelIdx - (newIdx - oldIdx), myDive);
diveChanged = false; // because we already modified things
}
}
if (diveChanged) {
if (d->maxdepth.mm == d->dc.maxdepth.mm &&
d->maxdepth.mm > 0 &&
same_string(d->dc.model, "manually added dive") &&
d->dc.samples == 0) {
// so we have depth > 0, a manually added dive and no samples
// let's create an actual profile so the desktop version can work it
// first clear out the mean depth (or the fake_dc() function tries
// to be too clever
d->meandepth.mm = d->dc.meandepth.mm = 0;
d->dc = *fake_dc(&d->dc, true);
}
DiveListModel::instance()->updateDive(oldModelIdx, d);
invalidate_dive_cache(d);
mark_divelist_changed(true);
}
if (diveChanged || needResort)
changesNeedSaving();
}
bool isBalanced(TreeNode * root) {
if (root == nullptr)
return true;
return checkDepth(root) > 0;
}
