void MainWindow::play(int row1, int col1 , int row2 , int col2)
{
if(isNear(row1,col1,row2,col2))
{
if(gobj.arr[row1][col1] != gobj.arr[row2][col2])
{
gobj.swap(gobj.arr[row1][col1],gobj.arr[row2][col2]);
if(gobj.arr[row1][col1]<7 && gobj.arr[row2][col2]<7)
{
if(!(gobj.checkLine(row1,col1)||gobj.checkLine(row2,col2)))
gobj.swap(gobj.arr[row1][col1],gobj.arr[row2][col2]);
}
else if (gobj.arr[row1][col1] > 6 && gobj.arr[row2][col2]<7)
{
gobj.checkLine(row2,col2);
gobj.typeBomb(gobj.arr[row1][col1],row1,col1,gobj.arr[row2][col2]);
}
else if (gobj.arr[row2][col2] > 6 && gobj.arr[row1][col1]<7)
{
gobj.checkLine(row1,col1);
gobj.typeBomb(gobj.arr[row2][col2],row2,col2,gobj.arr[row1][col1]);
}
gobj.moveDown();
resetImage();
step++;
ui->lcdNumber->display(gobj.score);
ui->lcdNumber_2->display(step);
checkWin();
}
}
}
void ColorVolumeWidget::setColor(const QColor &color)
{
if (this->color != color)
resetImage();
ColorSelectionControl::setColor(color);
}
void ColorSelectionControl::resizeEvent(QResizeEvent *event)
{
ColorControl::resizeEvent(event);
resetImage();
updateColorPoint();
}
WoWItemBase::WoWItemBase(QQuickItem *parent) :
QQuickPaintedItem(parent),
reply(NULL),
m_itemClass(WoWItemBase::Consumable),
m_itemSubClass(0)
{
resetImage();
setOpaquePainting(true);
am = new QNetworkAccessManager(this);
}
void Resistor::setResistance(QString resistance, QString pinSpacing, bool force) {
QString tolerance = prop("tolerance");
if (resistance.endsWith(OhmSymbol)) {
resistance.chop(1);
}
switch (this->m_viewIdentifier) {
case ViewIdentifierClass::BreadboardView:
if (force || resistance.compare(m_ohms) != 0) {
QString svg = makeSvg(resistance, m_viewLayerID);
//DebugDialog::debug(svg);
loadExtraRenderer(svg.toUtf8());
}
break;
case ViewIdentifierClass::PCBView:
if (force || pinSpacing.compare(m_pinSpacing) != 0) {
InfoGraphicsView * infoGraphicsView = InfoGraphicsView::getInfoGraphicsView(this);
if (infoGraphicsView == NULL) break;
if (moduleID().compare(ModuleIDNames::ResistorModuleIDName) != 0) break;
QDomElement element = LayerAttributes::getSvgElementLayers(modelPart()->domDocument(), m_viewIdentifier);
if (element.isNull()) break;
// hack the dom element and call setUpImage
FSvgRenderer::removeFromHash(moduleID(), "");
QString filename = PinSpacings.value(pinSpacing, "");
if (filename.isEmpty()) break;
element.setAttribute("image", filename);
m_changingPinSpacing = true;
resetImage(infoGraphicsView);
m_changingPinSpacing = false;
updateConnections();
}
break;
default:
break;
}
m_ohms = resistance;
m_pinSpacing = pinSpacing;
modelPart()->setProp("resistance", resistance);
modelPart()->setProp("pin spacing", pinSpacing);
modelPart()->setProp("tolerance", tolerance);
updateResistances(m_ohms);
if (m_partLabel) m_partLabel->displayTextsIf();
}
void ColorVolumeWidget::setMode(Mode mode)
{
if (this->mode == mode)
return;
this->mode = mode;
resetImage();
updateColorPoint();
update();
}
void ColorVolumeWidget::setDirection(Direction direction)
{
if (this->direction == direction)
return;
this->direction = direction;
resetImage();
updateColorPoint();
update();
}
NixNotifyPlugin::NixNotifyPlugin()
{
resetImage();
QDBusConnection::sessionBus().connect("org.freedesktop.Notifications",
"/org/freedesktop/Notifications",
"org.freedesktop.Notifications",
"ActionInvoked",
this,SLOT(sendActData(uint,QString)));
QDBusConnection::sessionBus().connect("org.freedesktop.Notifications",
"/org/freedesktop/Notifications",
"org.freedesktop.Notifications",
"NotificationClosed",
this,SLOT(notifIsClosed(uint)));
}
void mouse(int button, int state, int x, int y)
{
if(button == GLUT_RIGHT_BUTTON && state== GLUT_DOWN && dof)
{
int pixelX = renderCam->resolution.x -1 - x;
int index = pixelX + renderCam->resolution.x*y;
float pixelDist = renderCam->image[index].w;
iterations = 0;
renderCam->focalDist = pixelDist;
resetImage(renderCam);
}
else if(button == GLUT_LEFT_BUTTON && state== GLUT_DOWN)
{
int pixelX = renderCam->resolution.x -1 - x;
int index = pixelX + renderCam->resolution.x*y;
currentSelectedObjId = renderCam->objIdBuffer[index];
}
}
void RuneItem::chooseRune()
{
bool ok;
QString item = QInputDialog::getItem(NULL, tr("Choose a rune"), tr("Rune:"),
runeEngine_.getUserRuneList(), 0, false, &ok);
if (ok && !item.isEmpty())
{
int ind = runeEngine_.getUserRuneIndexByNaturalName(item);
if (ind != -1)
{
spell_->setRune(ind);
resetImage();
}
else
image_.setPixmap(QPixmap());
emit(changedSpell());
}
}
int main()
{
int numFractals;
scanf("%d", &numFractals);
int depth;
double angle, heading;
char axiom[MAX_CHARS];
bmp = bmp_create(300 * numFractals, 300, 32);
resetImage(300 * numFractals, 300);
int i;
for (i = 0; i < numFractals; i++)
{
scanf("%d", &depth);
scanf("%lf", &angle);
scanf("%lf", &heading);
angle = degreesToRadians(angle);
currH = degreesToRadians(heading);
scanf("%s", axiom);
scanf("%d", &numRules);
int j;
for (j = 0; j < numRules; j++)
{
char tmp[2];
scanf("%s -> %s\n", tmp, rules[j]);
codes[j] = tmp[0];
}
drawFractal(axiom, heading, angle, depth, i);
}
bmp_save(bmp, "output.bmp");
bmp_destroy(bmp);
}
void WebImageView::setUrl(const QUrl url) {
if(url != mUrl){
resetImage();
mUrl = url;
QIODevice *temp = diskCache->data(url);
if(temp){
setImage(Image(temp->readAll()));
mLoading = 1;
emit loadingChanged();
} else{
mLoading = 0.01;
emit loadingChanged();
if(defaultImageUrl!=QUrl(""))
setImage(Image(defaultImageUrl));
urls.push_back(url);
replies.push_back(mNetManager->get(QNetworkRequest(url)));
connect(replies.back(),SIGNAL(finished()), this, SLOT(imageLoaded()));
connect(replies.back(),SIGNAL(downloadProgress ( qint64 , qint64 )), this, SLOT(downloadProgressed(qint64,qint64)));
}
emit urlChanged();
}
}
void
Engine::drawLargeView() {
const bool saving = ( state >= SAVEPGM && state <= SAVEPNG );
const int buildWidth = saving ? imageSavedWidth : w();
const int buildHeight = saving ? imageSavedHeight : h();
Zoom zoom( skel.findFrame( pointsForFraming, _x, _y, _color ),
buildWidth, buildHeight, skel.getZoomFunction() );
int xcenter = 0;
int ycenter = 0;
if ( saving ) {
// at least one point will be in the center when we save:
zoom.toScreen( _x, _y );
xcenter = w()/2 - zoom.screenX;
ycenter = h()/2 - zoom.screenY;
if ( xcenter + imageSavedWidth < w() ) {
xcenter = w() - imageSavedWidth;
}
if ( xcenter > 0 ) {
xcenter = 0;
}
if ( ycenter + imageSavedHeight < h() ) {
ycenter = h() - imageSavedHeight;
}
if ( ycenter > 0 ) {
ycenter = 0;
}
}
resetImage( buildWidth, buildHeight, w(), h(), xcenter + ycenter*imageSavedWidth );
unsigned long timer = clock();
while ( state == LARGEVIEW || ( SAVEPGM <= state && state <= SAVEPNG ) ) {
if ( clockNumber ) {
drawPoints( skel, zoom, *imageLarge, timer );
} else {
drawPoints( skel, zoom, *imageLarge, pointsPerFrame );
}
}
}
void RuneItem::drawSpell()
{
if (parent_ == NULL)
{
cout << "ERROR : RuneItems must have a parent" << endl;
abort();
}
this->setParentItem(parent_);
this->setPen(this->getDefaultPen());
this->setBrush(QBrush(colorBackground()));
// Empty spell : only display the inner circle
// If the spell isn't empty
if (spell_->getRune() != -1)
{
// Setting the text
text_.setParentItem(this);
RuneDescriptor* rd = NULL;
if (runeEngine_.isMasterMode())
rd = &runes_->at(spell_->getRune())->descriptor_;
else
rd = &userRunes_->at(spell_->getRune());
text_.setText(rd->naturalName_);
text_.setPos(-text_.boundingRect().width() / 2, -text_.boundingRect().height() / 2);
text_.hide();
// Displaying the rune
image_.setParentItem(this);
resetImage();
image_.setPos(-_GRAPHICS_SPELLITEM_RUNE_IMAGERADIUS, -_GRAPHICS_SPELLITEM_RUNE_IMAGERADIUS);
}
this->setRect(-_GRAPHICS_SPELLITEM_RUNE_IMAGERADIUS, -_GRAPHICS_SPELLITEM_RUNE_IMAGERADIUS,
_GRAPHICS_SPELLITEM_RUNE_IMAGERADIUS * 2, _GRAPHICS_SPELLITEM_RUNE_IMAGERADIUS * 2);
}
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case(27):
exit(1);
break;
case 'w':
iterations = 0;
resetImage(renderCam);
renderCam->positions[targetFrame].z-=0.2f;
break;
case 's':
iterations = 0;
resetImage(renderCam);
renderCam->positions[targetFrame].z+= 0.2f;
break;
case 'a':
iterations = 0;
resetImage(renderCam);
renderCam->positions[targetFrame].x+=0.2f;
break;
case 'd':
iterations = 0;
resetImage(renderCam);
renderCam->positions[targetFrame].x-=0.2f;
break;
case 'x':
if(currentSelectedObjId != -1)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
g.translations[targetFrame].x+=0.2;
glm::mat4 transform = utilityCore::buildTransformationMatrix(g.translations[targetFrame],g.rotations[targetFrame],g.scales[targetFrame]);
g.transforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(transform);
g.inverseTransforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(glm::inverse(transform));
}
break;
case 'X':
if(currentSelectedObjId != -1)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
g.translations[targetFrame].x-=0.2;
glm::mat4 transform = utilityCore::buildTransformationMatrix(g.translations[targetFrame],g.rotations[targetFrame],g.scales[targetFrame]);
g.transforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(transform);
g.inverseTransforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(glm::inverse(transform));
}
break;
case 'y':
if(currentSelectedObjId != -1)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
g.translations[targetFrame].y+=0.2;
glm::mat4 transform = utilityCore::buildTransformationMatrix(g.translations[targetFrame],g.rotations[targetFrame],g.scales[targetFrame]);
g.transforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(transform);
g.inverseTransforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(glm::inverse(transform));
}
break;
case 'Y':
if(currentSelectedObjId != -1)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
g.translations[targetFrame].y-=0.2;
glm::mat4 transform = utilityCore::buildTransformationMatrix(g.translations[targetFrame],g.rotations[targetFrame],g.scales[targetFrame]);
g.transforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(transform);
g.inverseTransforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(glm::inverse(transform));
}
break;
case 'z':
if(currentSelectedObjId != -1)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
g.translations[targetFrame].z+=0.2;
glm::mat4 transform = utilityCore::buildTransformationMatrix(g.translations[targetFrame],g.rotations[targetFrame],g.scales[targetFrame]);
g.transforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(transform);
g.inverseTransforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(glm::inverse(transform));
}
break;
case 'Z':
if(currentSelectedObjId != -1)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
g.translations[targetFrame].z-=0.2;
glm::mat4 transform = utilityCore::buildTransformationMatrix(g.translations[targetFrame],g.rotations[targetFrame],g.scales[targetFrame]);
g.transforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(transform);
g.inverseTransforms[targetFrame] = utilityCore::glmMat4ToCudaMat4(glm::inverse(transform));
}
break;
case 't':
textureMode = !textureMode;
iterations = 0;
resetImage(renderCam);
break;
case 'h':
if(currentSelectedObjId != -1 && textureMode)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
material mtl = renderScene->materials[g.materialid];
if ( (renderScene->maps[mtl.mapID].width1+0.1f) > 0);
renderScene->maps[mtl.mapID].width1+=0.1f; }
break;
case 'j':
if(currentSelectedObjId != -1 && textureMode)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
material mtl = renderScene->materials[g.materialid];
if ( (renderScene->maps[mtl.mapID].width1-0.1f) > 0);
renderScene->maps[mtl.mapID].width1-=0.1f;
}
break;
case 'k':
if(currentSelectedObjId != -1 && textureMode)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
material mtl = renderScene->materials[g.materialid];
if ( (renderScene->maps[mtl.mapID].width2+0.1f) > 0);
renderScene->maps[mtl.mapID].width2+=0.1f;
}
break;
case 'l':
if(currentSelectedObjId != -1 && textureMode)
{
iterations = 0;
resetImage(renderCam);
geom g = renderScene->objects[currentSelectedObjId];
material mtl = renderScene->materials[g.materialid];
if ( (renderScene->maps[mtl.mapID].width2-0.1f) > 0);
renderScene->maps[mtl.mapID].width2-=0.1f;
}
break;
}
}
