void MeshWarpWidget::mousePressEvent(QMouseEvent *event)
{
int x = 0, y = 0;
m_transform.inverted().map(event->x(), event->y(), &x, &y);
m_has_active_cp = m_mesh.findPoint(x, y, m_active_cp_x, m_active_cp_y,
CONTROL_POINT_SIZE / 2);
if (m_has_active_cp)
{
DBGM("Found: [" << m_active_cp_x << "," << m_active_cp_y << "]");
m_panning = false;
emit activeCPChanged(m_active_cp_x, m_active_cp_y);
}
else
{
DBGM("Panning enabled");
m_origin_x = event->x();
m_origin_y = event->y();
m_panning = true;
emit activeCPDeactivated();
}
update();
return QWidget::mousePressEvent(event);
}
//Interrupt handler for tx worker interrupts
void TXWORK_TMR_IRQH(void) {
if (TXWORK_TMR->SR & ISO_TMR_CCIF) {
TIM_ITConfig(TXWORK_TMR, ISO_TMR_CC_IT, DISABLE);
#ifndef DISABLE_ISO
iso_work();
#endif
} else {
DBGM("bad TXW int", TXWORK_TMR->SR);
}
return;
}
BOOL os2Printers::ShowProperties(ULONG printerNdx)
{
DBGNX();
LONG devrc = FALSE;
PDRIVDATA pOldDrivData;
PDRIVDATA pNewDrivData = 0;
LONG buflen;
if (printerNdx >= mQueueCount)
return FALSE;
// check size of buffer required for job properties
buflen = DevPostDeviceModes(0,
0,
mPQBuf[printerNdx]->DriverName(),
mPQBuf[printerNdx]->DeviceName(),
mPQBuf[printerNdx]->PrinterName(),
DPDM_POSTJOBPROP);
// return error to caller */
if (buflen <= 0)
return FALSE;
// see if the new driver data is bigger than the existing buffer;
// if so, alloc a new buffer and copy over old data so driver can
// use the old job properties to init the job properties dialog
pOldDrivData = mPQBuf[printerNdx]->DriverData();
if (buflen > pOldDrivData->cb) {
DBGM("Allocating new memory for driver data");
pNewDrivData = (PDRIVDATA)malloc(buflen);
if (!pNewDrivData)
return FALSE;
memcpy(pNewDrivData, pOldDrivData, pOldDrivData->cb);
mPQBuf[printerNdx]->SetDriverData(pNewDrivData);
}
// display job properties dialog and get updated
// job properties from driver
devrc = DevPostDeviceModes(0,
mPQBuf[printerNdx]->DriverData(),
mPQBuf[printerNdx]->DriverName(),
mPQBuf[printerNdx]->DeviceName(),
mPQBuf[printerNdx]->PrinterName(),
DPDM_POSTJOBPROP);
return (devrc != DPDM_ERROR);
}
void MeshWarpWidget::wheelEvent(QWheelEvent *event)
{
if (event->delta() > 0)
{
m_scale += 0.1;
}
else
{
m_scale -= 0.1;
}
if (m_scale > 5.0f) m_scale = 5.0f;
if (m_scale <= 0.0f) m_scale = 0.01f;
DBGM("m_scale: " << m_scale);
update();
return QWidget::wheelEvent(event);
}
void MeshWarpWidget::mouseReleaseEvent(QMouseEvent *event)
{
if (m_has_active_cp)
{
if (m_show_warped)
{
m_img = warp(m_orig_img, m_orig_mesh, m_mesh);
}
update();
}
else if (m_panning)
{
m_vect_x += (event->x() - m_origin_x);
m_vect_y += (event->y() - m_origin_y);
m_panning = false;
DBGM("Panning DISabled");
}
return QWidget::mouseReleaseEvent(event);
}
/************************************************************************
* int checksol(eqn,sols,reltverr) *
* plugs the solution values in sols into the equation eqn. *
* compares descrepancy with expection using relative err reltverr *
* returns *
* 0 if seems within error bars *
* 1 if within 100 * error bars *
* 2 if not within 100 * error bars *
* 3 floating point error (really, really not ok) *
* NOTE: currently the error bar calculation has faults *
************************************************************************/
int checksol(const binopexp* const eqn, const vector<double>* const sols,
const double reltverr) {
DBG(cout << "entered checksol" << endl);
#ifdef WITHDBG // for debugging
recall=0;
#endif
answitherr* value;
expr* eqexpr = copyexpr(eqn); // g++ refused this without copyexpr
try {
value = evalexpr(eqexpr, sols, reltverr);
}
catch (string &err) {
// don't delete value, it has never been assigned.
eqexpr->destroy();
DBG(cout << " ERROR " << err << endl);
if(FPE_handler==err.substr(0,FPE_handler.length())) //if beginning matches
return(3);
else {
throw(err);
}
}
eqexpr->destroy();
DBGM(cout << "Eqn " << eqn->getInfix() <<
" balenced with discrepancy " << value->value
<< " and absolute error " << value->abserr << endl);
if ((fabs(value->value) <= value->abserr)) {
DBG(cout << " seems OK" << endl);
delete value;
return(0);
} else if ((fabs(value->value) <= 100 * value->abserr)) {
DBG(cout << " NOT REALLY OK" << endl);
delete value;
return(1);
} else {
DBG(cout << " seems VERY NOT OK on" << endl; cout << eqn->getInfix()
<< endl);
delete value;
return(2);
}
}
bool flatten(expr * & e) // flattens expr e wrt n_ops
{
int k, q;
expr * tempexp;
EQCHK(e);
#if WITHDBG
unsigned long thisdbg = ++dbgnum; // recursive calls for debug
#endif
DBG(cout << "flatten " << thisdbg << " called for "
<< e->getInfix() << endl);
if ((e->etype == unknown) ||
(e->etype == fake))
throw(string("flatten called on unknown or fake expr"));
if ( (e->etype == numval) || (e->etype == physvart)) return(false);
bool answer = false;
if (e->etype == function) // top level is function
{
functexp * efunct = (functexp *) e;
answer = flatten(efunct->arg);
if (efunct->f->opty == sqrte)
{ // sqrt of product
if ( (efunct->arg->etype == n_op) &&
(((n_opexp *)efunct->arg)->op->opty == multe))
{
n_opexp * fargnop = (n_opexp *) efunct->arg;
if (fargnop->args->size() < 2)
{
// this can't happen if we guarantee all n_ops flatten
// returns always have at least two args:
unnop(efunct->arg);
DBGM(cout << "flatten " << thisdbg << ": returns "
<< e->getInfix()<< endl);
return(true);
}
DBG(cout << "flatten " << thisdbg <<
" called sqrt of product " << endl;
// e->dbgprint(0)
);
n_opexp * rootdone = new n_opexp(&mult); // holds part of prod
for (k = 0; k < fargnop->args->size(); k++) // extracted frm sqrt
if (isnonneg((*fargnop->args)[k]))
{
tempexp = (expr *) new functexp(&sqrtff,
(*fargnop->args)[k]);
fargnop->MKS += ((*fargnop->args)[k])->MKS * -1.;//9/29/01
e->MKS += ((*fargnop->args)[k])->MKS * -0.5;//9/29/01
flatten(tempexp);
rootdone->addarg(tempexp);
for (q = k; q+1 < fargnop->args->size(); q++)
(*fargnop->args)[q] = (*fargnop->args)[q+1];
fargnop->args->pop_back();
k--;
}
if (fargnop->args->size() == 1)
{
unnop(efunct->arg);
eqnumsimp(e,true);
answer = true;
}
else if (fargnop->args->size() == 0)
{
e->destroy(); e = rootdone;
DBG(cout << "flatten " << thisdbg << ": returns "
<< e->getInfix()<< endl);
return(true);
}
if (rootdone->args->size() == 0)
{
delete rootdone;
DBG({cout << "flatten " << thisdbg
<< " return false from sqrt of product" << endl; });
