void FingerList::mousePressEvent(QMouseEvent *e)
{
int col = e->x() / ICONCHORD;
#if QT_VERSION < 300
int row = (e->y() + yOffset()) / ICONCHORD;
#else
int row = (e->y() + contentsY ()) / ICONCHORD;
#endif
int n = row * perRow + col;
if ((n >= 0) && (n < num)) {
curSel = row * perRow + col;
#if QT_VERSION < 300
repaint(oldCol * ICONCHORD, oldRow * ICONCHORD - yOffset(),
ICONCHORD, ICONCHORD);
repaint(col * ICONCHORD, row * ICONCHORD - yOffset(),
ICONCHORD, ICONCHORD);
#else
repaintCell(oldRow, oldCol);
repaintCell(row, col);
#endif
oldCol = col;
oldRow = row;
emit chordSelected(appl[curSel].f);
}
}
RGBMap RGBText::renderScrollingText(const QSize& size, uint rgb, int step) const
{
QImage image;
if (animationStyle() == Horizontal)
image = QImage(scrollingTextStepCount(), size.height(), QImage::Format_RGB32);
else
image = QImage(size.width(), scrollingTextStepCount(), QImage::Format_RGB32);
image.fill(QRgb(0));
QPainter p(&image);
p.setRenderHint(QPainter::TextAntialiasing, false);
p.setRenderHint(QPainter::Antialiasing, false);
p.setFont(m_font);
p.setPen(QColor(rgb));
if (animationStyle() == Vertical)
{
QFontMetrics fm(m_font);
QRect rect(0, 0, image.width(), image.height());
for (int i = 0; i < m_text.length(); i++)
{
rect.setY((i * fm.ascent()) + yOffset());
rect.setX(xOffset());
rect.setHeight(fm.ascent());
p.drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, m_text.mid(i, 1));
}
}
else
{
// Draw the whole text each time
QRect rect(xOffset(), yOffset(), image.width(), image.height());
p.drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, m_text);
}
p.end();
// Treat the RGBMap as a "window" on top of the fully-drawn text and pick the
// correct pixels according to $step.
RGBMap map(size.height());
for (int y = 0; y < size.height(); y++)
{
map[y].resize(size.width());
for (int x = 0; x < size.width(); x++)
{
if (animationStyle() == Horizontal)
{
if (step + x < image.width())
map[y][x] = image.pixel(step + x, y);
}
else
{
if (step + y < image.height())
map[y][x] = image.pixel(x, step + y);
}
}
}
return map;
}
void zoom(double passo) {
double xFactor = xOffset() * passo / 100.0;
if (xFactor > xOffset()) {
xFactor = xOffset();
}
double yFactor = yOffset() * passo / 100.0;
if (yFactor > yOffset()) {
yFactor = yOffset();
}
largura -= 2 * xFactor;
altura -= 2 * yFactor;
}
bool RGBText::saveXML(QDomDocument* doc, QDomElement* mtx_root) const
{
Q_ASSERT(doc != NULL);
Q_ASSERT(mtx_root != NULL);
QDomElement root = doc->createElement(KXMLQLCRGBAlgorithm);
root.setAttribute(KXMLQLCRGBAlgorithmType, KXMLQLCRGBText);
mtx_root->appendChild(root);
QDomElement content = doc->createElement(KXMLQLCRGBTextContent);
QDomText contentText = doc->createTextNode(m_text);
content.appendChild(contentText);
root.appendChild(content);
QDomElement font = doc->createElement(KXMLQLCRGBTextFont);
QDomText fontText = doc->createTextNode(m_font.toString());
font.appendChild(fontText);
root.appendChild(font);
QDomElement ani = doc->createElement(KXMLQLCRGBTextAnimationStyle);
QDomText aniText = doc->createTextNode(animationStyleToString(animationStyle()));
ani.appendChild(aniText);
root.appendChild(ani);
QDomElement offset = doc->createElement(KXMLQLCRGBTextOffset);
offset.setAttribute(KXMLQLCRGBTextOffsetX, xOffset());
offset.setAttribute(KXMLQLCRGBTextOffsetY, yOffset());
root.appendChild(offset);
return true;
}
RGBMap RGBText::renderStaticLetters(const QSize& size, uint rgb, int step) const
{
QImage image(size, QImage::Format_RGB32);
image.fill(QRgb(0));
QPainter p(&image);
p.setRenderHint(QPainter::TextAntialiasing, false);
p.setRenderHint(QPainter::Antialiasing, false);
p.setFont(m_font);
p.setPen(QColor(rgb));
// Draw one letter at a time
QRect rect(xOffset(), yOffset(), size.width(), size.height());
p.drawText(rect, Qt::AlignCenter, m_text.mid(step, 1));
p.end();
RGBMap map(size.height());
for (int y = 0; y < size.height(); y++)
{
map[y].resize(size.width());
for (int x = 0; x < size.width(); x++)
map[y][x] = image.pixel(x, y);
}
return map;
}
void Braces::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
// Draw left brace.
painter->setPen(style()->leftBracePen());
QFont fl(style()->leftBraceFont());
fl.setPixelSize(textSize_);
painter->setFont(fl);
painter->drawText(QPointF(xOffset(), yOffset()) + leftBraceOffset_, style()->leftBrace());
// Draw right brace.
painter->setPen(style()->rightBracePen());
QFont fr(style()->rightBraceFont());
fr.setPixelSize(textSize_);
painter->setFont(fr);
painter->drawText(QPointF(xOffset()+rightBraceLeft_, yOffset()) + rightBraceOffset_, style()->rightBrace());
}
bool RGBImage::saveXML(QDomDocument* doc, QDomElement* mtx_root) const
{
Q_ASSERT(doc != NULL);
Q_ASSERT(mtx_root != NULL);
QDomElement root = doc->createElement(KXMLQLCRGBAlgorithm);
root.setAttribute(KXMLQLCRGBAlgorithmType, KXMLQLCRGBImage);
mtx_root->appendChild(root);
QDomElement filename = doc->createElement(KXMLQLCRGBImageFilename);
QDomText filenameText =
doc->createTextNode(this->doc()->normalizeComponentPath(m_filename));
filename.appendChild(filenameText);
root.appendChild(filename);
QDomElement ani = doc->createElement(KXMLQLCRGBImageAnimationStyle);
QDomText aniText = doc->createTextNode(animationStyleToString(animationStyle()));
ani.appendChild(aniText);
root.appendChild(ani);
QDomElement offset = doc->createElement(KXMLQLCRGBImageOffset);
offset.setAttribute(KXMLQLCRGBImageOffsetX, xOffset());
offset.setAttribute(KXMLQLCRGBImageOffsetY, yOffset());
root.appendChild(offset);
return true;
}
//-----------------------------------------------------------------------------
void LineProfileCanvas::OnPaintCustom( wxPaintDC& dc )
//-----------------------------------------------------------------------------
{
wxCoord yOffset( 1 ), w( 0 ), h( 0 );
dc.GetSize( &w, &h );
const double scaleX = static_cast<double>( w - 2 * GetBorderWidth() ) / static_cast<double>( ( GetDataCount() == 0 ) ? 1 : GetDataCount() - 1 );
const double scaleY = GetScaleY( h );
DrawMarkerLines( dc, w, h, scaleX );
unsigned int from, to;
GetDrawRange( &from, &to );
const int borderWidth = GetBorderWidth();
const wxString YMarkerString( wxString::Format( wxT( "Draw Range(absolute): %d / %d, " ), from, to ) );
wxCoord xOffset;
dc.GetTextExtent( YMarkerString, &xOffset, 0 );
xOffset += borderWidth / 2;
dc.DrawText( YMarkerString, borderWidth / 2, yOffset );
if( m_boUnsupportedPixelFormat )
{
dc.SetTextForeground( *wxRED );
dc.DrawText( wxString( wxT( "Unsupported pixel format" ) ), xOffset, yOffset );
dc.SetTextForeground( *wxBLACK );
}
else if( m_ppData )
{
for( int channel = 0; channel < m_ChannelCount; channel++ )
{
DrawProfileLine( dc, h, borderWidth + 1, scaleX, scaleY, from, to, m_ppData[channel], GetDataCount(), *m_Pens[channel].pColour_ );
DrawInfoString( dc, wxString::Format( wxT( "%s%s: " ), ( channel != 0 ) ? wxT( ", " ) : wxT( "" ), m_Pens[channel].description_.c_str() ), xOffset, yOffset, *( m_Pens[channel].pColour_ ) );
}
}
}
void Board::updateField(int x, int y, bool erase)
{
QRect r(xOffset() + x * tiles.tileWidth(),
yOffset() + y * tiles.tileHeight(),
tiles.tileWidth(),
tiles.tileHeight());
repaint(r, erase);
}
void Braces::update()
{
if ( sizeSpecified() == InnerSize )
{
textSize_ = height();
if (textSize_ < style()->minHeight()) textSize_ = style()->minHeight();
QSize lb = getSizeOfBrace(style()->leftBrace(), style()->leftBraceFont(), textSize_, &leftBraceOffset_);
QSize rb = getSizeOfBrace(style()->rightBrace(), style()->rightBraceFont(), textSize_, &rightBraceOffset_);
while (lb.height() < height() && rb.height() < height())
{
textSize_++;
lb = getSizeOfBrace(style()->leftBrace(), style()->leftBraceFont(), textSize_, &leftBraceOffset_);
rb = getSizeOfBrace(style()->rightBrace(), style()->rightBraceFont(), textSize_, &rightBraceOffset_);
}
contentTop_ = (lb.height() - height() )/ 2;
contentLeft_ = lb.width();
rightBraceLeft_ = contentLeft_ + width();
setItemSize(xOffset() + lb.width()+width()+rb.width(), yOffset() + lb.height());
}
else
{
textSize_ = height();
if (textSize_ < style()->minHeight()) textSize_ = style()->minHeight();
QSize lb = getSizeOfBrace(style()->leftBrace(), style()->leftBraceFont(), textSize_, &leftBraceOffset_);
QSize rb = getSizeOfBrace(style()->rightBrace(), style()->rightBraceFont(), textSize_, &rightBraceOffset_);
while(textSize_ >= 0 && (lb.width() + rb.width() > width() || lb.height() + rb.height() > height()))
{
textSize_--;
lb = getSizeOfBrace(style()->leftBrace(), style()->leftBraceFont(), textSize_, &leftBraceOffset_);
rb = getSizeOfBrace(style()->rightBrace(), style()->rightBraceFont(), textSize_, &rightBraceOffset_);
}
contentTop_ = 0;
contentLeft_ = lb.width();
rightBraceLeft_ = width() - rb.width();
setItemSize(xOffset() + width(), yOffset() + height());
}
}
void FingerList::setFirstChord() {
if (!num) return;
oldCol = 0;
oldRow = 0;
curSel = 0;
#if QT_VERSION < 300
repaint(0, 0 - yOffset(), ICONCHORD, ICONCHORD);
#else
repaintCell(0, 0);
#endif
chordSelected(appl[0].f);
}
void WebKitBrowserExtension::saveState(QDataStream &stream)
{
// TODO: Save information such as form data from the current page.
QWebHistory* history = (view() ? view()->history() : 0);
const int historyIndex = (history ? history->currentItemIndex() : -1);
const KUrl historyUrl = (history ? KUrl(history->currentItem().url()) : m_part->url());
stream << historyUrl
<< static_cast<qint32>(xOffset())
<< static_cast<qint32>(yOffset())
<< historyIndex
<< m_historyData;
}
QPoint Board::midCoord(int x, int y) const
{
QPoint p;
int w = tiles.tileWidth();
int h = tiles.tileHeight();
if(x == -1)
p.setX(xOffset() - (w / 4));
else if(x == x_tiles())
p.setX(xOffset() + (w * x_tiles()) + (w / 4));
else
p.setX(xOffset() + (w * x) + (w / 2));
if(y == -1)
p.setY(yOffset() - (w / 4));
else if(y == y_tiles())
p.setY(yOffset() + (h * y_tiles()) + (w / 4));
else
p.setY(yOffset() + (h * y) + (h / 2));
return p;
}
RGBMap RGBImage::rgbMap(const QSize& size, uint rgb, int step)
{
Q_UNUSED(rgb);
QMutexLocker locker(&m_mutex);
if (m_animatedSource == false && (m_image.width() == 0 || m_image.height() == 0))
return RGBMap();
int xOffs = xOffset();
int yOffs = yOffset();
switch(animationStyle())
{
default:
case Static:
break;
case Horizontal:
xOffs += step;
break;
case Vertical:
yOffs += step;
break;
case Animation:
xOffs += step * size.width();
break;
}
if (m_animatedSource)
{
m_animatedPlayer.jumpToNextFrame();
m_image = m_animatedPlayer.currentImage().scaled(size);
}
RGBMap map(size.height());
for (int y = 0; y < size.height(); y++)
{
map[y].resize(size.width());
for (int x = 0; x < size.width(); x++)
{
int x1 = (x + xOffs) % m_image.width();
int y1 = (y + yOffs) % m_image.height();
map[y][x] = m_image.pixel(x1,y1);
if (qAlpha(map[y][x]) == 0)
map[y][x] = 0;
}
}
return map;
}
int QGraphicsDropShadowEffect::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QGraphicsEffect::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 10)
qt_static_metacall(this, _c, _id, _a);
_id -= 10;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QPointF*>(_v) = offset(); break;
case 1: *reinterpret_cast< qreal*>(_v) = xOffset(); break;
case 2: *reinterpret_cast< qreal*>(_v) = yOffset(); break;
case 3: *reinterpret_cast< qreal*>(_v) = blurRadius(); break;
case 4: *reinterpret_cast< QColor*>(_v) = color(); break;
}
_id -= 5;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setOffset(*reinterpret_cast< QPointF*>(_v)); break;
case 1: setXOffset(*reinterpret_cast< qreal*>(_v)); break;
case 2: setYOffset(*reinterpret_cast< qreal*>(_v)); break;
case 3: setBlurRadius(*reinterpret_cast< qreal*>(_v)); break;
case 4: setColor(*reinterpret_cast< QColor*>(_v)); break;
}
_id -= 5;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 5;
}
#endif // QT_NO_PROPERTIES
return _id;
}
RGBMap RGBImage::rgbMap(const QSize& size, uint rgb, int step)
{
Q_UNUSED(rgb);
if (m_image.width() == 0 || m_image.height() == 0)
return RGBMap();
int xOffs = xOffset();
int yOffs = yOffset();
switch(animationStyle())
{
default:
case Static:
break;
case Horizontal:
xOffs += step;
break;
case Vertical:
yOffs += step;
break;
case Animation:
xOffs += step * size.width();
break;
}
RGBMap map(size.height());
for (int y = 0; y < size.height(); y++)
{
map[y].resize(size.width());
for (int x = 0; x < size.width(); x++)
{
int x1 = (x + xOffs) % m_image.width();
int y1 = (y + yOffs) % m_image.height();
map[y][x] = m_image.pixel(x1,y1);
if (qAlpha(map[y][x]) == 0)
map[y][x] = 0;
}
}
return map;
}
void Board::paintEvent(QPaintEvent *e)
{
QRect ur = e->rect(); // rectangle to update
QPixmap pm(ur.size()); // Pixmap for double-buffering
pm.fill(this, ur.topLeft()); // fill with widget background
QPainter p(&pm);
p.translate(-ur.x(), -ur.y()); // use widget coordinate system
if(paused)
{
p.setFont(KGlobalSettings::largeFont());
p.drawText(rect(), Qt::AlignCenter, i18n("Game Paused"));
}
else
{
int w = tiles.tileWidth();
int h = tiles.tileHeight();
for(int i = 0; i < x_tiles(); i++)
{
for(int j = 0; j < y_tiles(); j++)
{
int tile = getField(i, j);
if(tile == EMPTY)
continue;
int xpos = xOffset() + i * w;
int ypos = yOffset() + j * h;
QRect r(xpos, ypos, w, h);
if(e->rect().intersects(r))
{
if(isTileHighlighted(i, j))
p.drawPixmap(xpos, ypos, tiles.highlightedTile(tile-1));
else
p.drawPixmap(xpos, ypos, tiles.tile(tile-1));
}
}
}
}
p.end();
bitBlt( this, ur.topLeft(), &pm );
}
void Animation::think()
{
if (SDL_GetTicks() - _frameTicks >= frames()->at(_currentFrame)->duration())
{
_frameTicks = SDL_GetTicks();
if (_currentFrame < frames()->size() - 1)
{
_currentFrame += 1;
}
else
{
_currentFrame = 0;
}
auto frame = frames()->at(_currentFrame);
setXOffset(frame->xOffset() - (int)std::floor(frame->width()*0.5));
setYOffset(frame->yOffset() - frame->height());
}
}
bool RGBImage::saveXML(QXmlStreamWriter *doc) const
{
Q_ASSERT(doc != NULL);
doc->writeStartElement(KXMLQLCRGBAlgorithm);
doc->writeAttribute(KXMLQLCRGBAlgorithmType, KXMLQLCRGBImage);
doc->writeTextElement(KXMLQLCRGBImageFilename, this->doc()->normalizeComponentPath(m_filename));
doc->writeTextElement(KXMLQLCRGBImageAnimationStyle, animationStyleToString(animationStyle()));
doc->writeStartElement(KXMLQLCRGBImageOffset);
doc->writeAttribute(KXMLQLCRGBImageOffsetX, QString::number(xOffset()));
doc->writeAttribute(KXMLQLCRGBImageOffsetY, QString::number(yOffset()));
doc->writeEndElement();
/* End the <Algorithm> tag */
doc->writeEndElement();
return true;
}
void KFinderWin::offsets( int &_xpos, int &_ypos )
{
_ypos = yOffset();
_xpos = xOffset();
}
bool EFX::saveXML(QXmlStreamWriter *doc)
{
Q_ASSERT(doc != NULL);
/* Function tag */
doc->writeStartElement(KXMLQLCFunction);
/* Common attributes */
saveXMLCommon(doc);
/* Fixtures */
QListIterator <EFXFixture*> it(m_fixtures);
while (it.hasNext() == true)
it.next()->saveXML(doc);
/* Propagation mode */
doc->writeTextElement(KXMLQLCEFXPropagationMode, propagationModeToString(m_propagationMode));
/* Speeds */
saveXMLSpeed(doc);
/* Direction */
saveXMLDirection(doc);
/* Run order */
saveXMLRunOrder(doc);
/* Algorithm */
doc->writeTextElement(KXMLQLCEFXAlgorithm, algorithmToString(algorithm()));
/* Width */
doc->writeTextElement(KXMLQLCEFXWidth, QString::number(width()));
/* Height */
doc->writeTextElement(KXMLQLCEFXHeight, QString::number(height()));
/* Rotation */
doc->writeTextElement(KXMLQLCEFXRotation, QString::number(rotation()));
/* StartOffset */
doc->writeTextElement(KXMLQLCEFXStartOffset, QString::number(startOffset()));
/* IsRelative */
doc->writeTextElement(KXMLQLCEFXIsRelative, QString::number(isRelative() ? 1 : 0));
/********************************************
* X-Axis
********************************************/
doc->writeStartElement(KXMLQLCEFXAxis);
doc->writeAttribute(KXMLQLCFunctionName, KXMLQLCEFXX);
/* Offset */
doc->writeTextElement(KXMLQLCEFXOffset, QString::number(xOffset()));
/* Frequency */
doc->writeTextElement(KXMLQLCEFXFrequency, QString::number(xFrequency()));
/* Phase */
doc->writeTextElement(KXMLQLCEFXPhase, QString::number(xPhase()));
/* End the (X) <Axis> tag */
doc->writeEndElement();
/********************************************
* Y-Axis
********************************************/
doc->writeStartElement(KXMLQLCEFXAxis);
doc->writeAttribute(KXMLQLCFunctionName, KXMLQLCEFXY);
/* Offset */
doc->writeTextElement(KXMLQLCEFXOffset, QString::number(yOffset()));
/* Frequency */
doc->writeTextElement(KXMLQLCEFXFrequency, QString::number(yFrequency()));
/* Phase */
doc->writeTextElement(KXMLQLCEFXPhase, QString::number(yPhase()));
/* End the (Y) <Axis> tag */
doc->writeEndElement();
/* End the <Function> tag */
doc->writeEndElement();
return true;
}
bool EFX::saveXML(QDomDocument* doc, QDomElement* wksp_root)
{
QDomElement root;
QDomElement tag;
QDomElement subtag;
QDomText text;
QString str;
Q_ASSERT(doc != NULL);
Q_ASSERT(wksp_root != NULL);
/* Function tag */
root = doc->createElement(KXMLQLCFunction);
wksp_root->appendChild(root);
/* Common attributes */
saveXMLCommon(&root);
/* Fixtures */
QListIterator <EFXFixture*> it(m_fixtures);
while (it.hasNext() == true)
it.next()->saveXML(doc, &root);
/* Propagation mode */
tag = doc->createElement(KXMLQLCEFXPropagationMode);
root.appendChild(tag);
text = doc->createTextNode(propagationModeToString(m_propagationMode));
tag.appendChild(text);
/* Speeds */
saveXMLSpeed(doc, &root);
/* Direction */
saveXMLDirection(doc, &root);
/* Run order */
saveXMLRunOrder(doc, &root);
/* Algorithm */
tag = doc->createElement(KXMLQLCEFXAlgorithm);
root.appendChild(tag);
text = doc->createTextNode(algorithmToString(algorithm()));
tag.appendChild(text);
/* Width */
tag = doc->createElement(KXMLQLCEFXWidth);
root.appendChild(tag);
str.setNum(width());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Height */
tag = doc->createElement(KXMLQLCEFXHeight);
root.appendChild(tag);
str.setNum(height());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Rotation */
tag = doc->createElement(KXMLQLCEFXRotation);
root.appendChild(tag);
str.setNum(rotation());
text = doc->createTextNode(str);
tag.appendChild(text);
/* StartOffset */
tag = doc->createElement(KXMLQLCEFXStartOffset);
root.appendChild(tag);
str.setNum(startOffset());
text = doc->createTextNode(str);
tag.appendChild(text);
/* IsRelative */
tag = doc->createElement(KXMLQLCEFXIsRelative);
root.appendChild(tag);
str.setNum(isRelative() ? 1 : 0);
text = doc->createTextNode(str);
tag.appendChild(text);
/********************************************
* X-Axis
********************************************/
tag = doc->createElement(KXMLQLCEFXAxis);
root.appendChild(tag);
tag.setAttribute(KXMLQLCFunctionName, KXMLQLCEFXX);
/* Offset */
subtag = doc->createElement(KXMLQLCEFXOffset);
tag.appendChild(subtag);
str.setNum(xOffset());
text = doc->createTextNode(str);
subtag.appendChild(text);
/* Frequency */
subtag = doc->createElement(KXMLQLCEFXFrequency);
tag.appendChild(subtag);
str.setNum(xFrequency());
text = doc->createTextNode(str);
subtag.appendChild(text);
/* Phase */
subtag = doc->createElement(KXMLQLCEFXPhase);
tag.appendChild(subtag);
str.setNum(xPhase());
text = doc->createTextNode(str);
subtag.appendChild(text);
/********************************************
* Y-Axis
********************************************/
tag = doc->createElement(KXMLQLCEFXAxis);
root.appendChild(tag);
tag.setAttribute(KXMLQLCFunctionName, KXMLQLCEFXY);
/* Offset */
subtag = doc->createElement(KXMLQLCEFXOffset);
tag.appendChild(subtag);
str.setNum(yOffset());
text = doc->createTextNode(str);
subtag.appendChild(text);
/* Frequency */
subtag = doc->createElement(KXMLQLCEFXFrequency);
tag.appendChild(subtag);
str.setNum(yFrequency());
text = doc->createTextNode(str);
subtag.appendChild(text);
/* Phase */
subtag = doc->createElement(KXMLQLCEFXPhase);
tag.appendChild(subtag);
str.setNum(yPhase());
text = doc->createTextNode(str);
subtag.appendChild(text);
return true;
}
void ScreenText::set_text(const std::string* text,
const GLfloat* x,
const GLfloat* y,
GLfloat xAnchor,
GLfloat yAnchor,
size_t n)
{
screenAnchor_=x[0]<0?(y[0]<0?SCREEN_ANCHOR_TOP_RIGHT:SCREEN_ANCHOR_BOTTOM_RIGHT):
(y[0]<0?SCREEN_ANCHOR_TOP_LEFT:SCREEN_ANCHOR_BOTTOM_LEFT);
GLfloat height(font_.charHeight);
const GLfloat* charWidth(font_.charWidth);
std::vector<GLfloat> buffer(0);
for(size_t i(0);i<n;++i)
{
GLfloat width(font_.string_width(text[i]));
GLfloat xOffset(-width*(xAnchor+0.5f));
GLfloat yOffset(-height*(yAnchor+0.5f));
GLfloat xLeft,xRight((x[i]+xOffset));
GLfloat yBottom(y[i]+yOffset),yTop(yBottom+height);
for(size_t j(0);j<text[i].length();++j)
{
xLeft = xRight;
xRight = xLeft+charWidth[GLubyte(text[i].at(j))];
buffer.push_back(xLeft);buffer.push_back(yTop);
buffer.push_back(xLeft);buffer.push_back(yBottom);
buffer.push_back(xRight);buffer.push_back(yTop);
buffer.push_back(xRight);buffer.push_back(yBottom);
buffer.push_back(xRight);buffer.push_back(yTop);
buffer.push_back(xLeft);buffer.push_back(yBottom);
}
}
unsigned char charOffset=font_.charOffset;
const GLfloat* charTextureWidth(font_.charTextureWidth);
GLfloat charTextureHeight(font_.charTextureHeight);
GLfloat charsPerRow(font_.charsPerRow);
GLfloat charsPerColumn(font_.charsPerColumn);
for(unsigned int i=0;i<n;++i)
{
for(unsigned int j=0;j<text[i].length();++j)
{
unsigned char c = GLubyte(text[i].at(j)-charOffset);
GLfloat uLeft = (c%GLubyte(charsPerRow))/charsPerRow;
GLfloat uRight = uLeft+charTextureWidth[c+charOffset];
GLfloat vTop = 1-(c/GLubyte(charsPerRow))/charsPerColumn;
GLfloat vBottom = vTop-charTextureHeight;
buffer.push_back(uLeft);buffer.push_back(vTop);
buffer.push_back(uLeft);buffer.push_back(vBottom);
buffer.push_back(uRight);buffer.push_back(vTop);
buffer.push_back(uRight);buffer.push_back(vBottom);
buffer.push_back(uRight);buffer.push_back(vTop);
buffer.push_back(uLeft);buffer.push_back(vBottom);
}
}
usedSize_=buffer.size();
if(!usedSize_)
return;
glBindBuffer(GL_ARRAY_BUFFER,glBuffer_);
if(usedSize_>bufferSize_)
{
bufferSize_=usedSize_;
glBufferData(GL_ARRAY_BUFFER,GLsizeiptr(bufferSize_*sizeof(GLfloat)),&buffer[0],GL_DYNAMIC_DRAW);
}
else
{
void* ptr(NULL);
while(!ptr)
ptr=glMapBuffer(GL_ARRAY_BUFFER,GL_READ_WRITE);
GLfloat* floatPtr=reinterpret_cast<GLfloat*>(ptr);
for(size_t i(0);i<usedSize_;++i)
floatPtr[i]=buffer[i];
if(!glUnmapBuffer(GL_ARRAY_BUFFER))
throw(std::string("could not unmap buffer for bitmap string"));
}
glBindBuffer(GL_ARRAY_BUFFER,0);
#ifdef SCIGMA_USE_OPENGL_3_2
glBindVertexArray(vertexArray_);
glBindBuffer(GL_ARRAY_BUFFER,glBuffer_);
prepare_attributes();
glBindBuffer(GL_ARRAY_BUFFER,0);
glBindVertexArray(0);
#endif
GLERR;
}
void Board::mousePressEvent(QMouseEvent *e)
{
// Calculate field position
int pos_x = (e->pos().x() - xOffset()) / tiles.tileWidth();
int pos_y = (e->pos().y() - yOffset()) / tiles.tileHeight();
if(e->pos().x() < xOffset() || e->pos().y() < yOffset() ||
pos_x >= x_tiles() || pos_y >= y_tiles())
{
pos_x = -1;
pos_y = -1;
}
// Mark tile
if(e->button() == LeftButton)
{
clearHighlight();
if(pos_x != -1)
marked(pos_x, pos_y);
}
// Assist by highlighting all tiles of same type
if(e->button() == RightButton)
{
int clicked_tile = getField(pos_x, pos_y);
// Clear marked tile
if(mark_x != -1 && getField(mark_x, mark_y) != clicked_tile)
{
// We need to set mark_x and mark_y to -1 before calling
// updateField() to ensure the tile is redrawn as unmarked.
int oldmarkx = mark_x;
int oldmarky = mark_y;
mark_x = -1;
mark_y = -1;
updateField(oldmarkx, oldmarky, false);
}
else
{
mark_x = -1;
mark_y = -1;
}
// Perform highlighting
if(clicked_tile != highlighted_tile)
{
int old_highlighted = highlighted_tile;
highlighted_tile = clicked_tile;
for(int i = 0; i < x_tiles(); i++)
{
for(int j = 0; j < y_tiles(); j++)
{
const int field_tile = getField(i, j);
if(field_tile != EMPTY)
{
if(field_tile == old_highlighted)
updateField(i, j, false);
else if(field_tile == clicked_tile)
updateField(i, j, false);
}
}
}
}
}
}
void SVGIcon::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Icon::paint(painter, option, widget);
style()->paint(painter, xOffset(), yOffset() );
}
/**
* Save the function's contents to an XML document
*
* @param doc The QDomDocument to save to
*/
bool EFX::saveXML(QDomDocument* doc, QDomElement* wksp_root)
{
QDomElement root;
QDomElement tag;
QDomElement subtag;
QDomText text;
QString str;
Q_ASSERT(doc != NULL);
Q_ASSERT(wksp_root != NULL);
/* Function tag */
root = doc->createElement(KXMLQLCFunction);
wksp_root->appendChild(root);
root.setAttribute(KXMLQLCFunctionID, id());
root.setAttribute(KXMLQLCFunctionType, Function::typeToString(m_type));
root.setAttribute(KXMLQLCFunctionName, name());
/* Fixtures */
QListIterator <EFXFixture*> it(m_fixtures);
while (it.hasNext() == true)
it.next()->saveXML(doc, &root);
/* Propagation mode */
tag = doc->createElement(KXMLQLCEFXPropagationMode);
root.appendChild(tag);
text = doc->createTextNode(propagationModeToString(m_propagationMode));
tag.appendChild(text);
/* Speed bus */
tag = doc->createElement(KXMLQLCBus);
root.appendChild(tag);
tag.setAttribute(KXMLQLCBusRole, KXMLQLCBusFade);
str.setNum(busID());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Direction */
tag = doc->createElement(KXMLQLCFunctionDirection);
root.appendChild(tag);
text = doc->createTextNode(Function::directionToString(m_direction));
tag.appendChild(text);
/* Run order */
tag = doc->createElement(KXMLQLCFunctionRunOrder);
root.appendChild(tag);
text = doc->createTextNode(Function::runOrderToString(m_runOrder));
tag.appendChild(text);
/* Algorithm */
tag = doc->createElement(KXMLQLCEFXAlgorithm);
root.appendChild(tag);
text = doc->createTextNode(algorithm());
tag.appendChild(text);
/* Width */
tag = doc->createElement(KXMLQLCEFXWidth);
root.appendChild(tag);
str.setNum(width());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Height */
tag = doc->createElement(KXMLQLCEFXHeight);
root.appendChild(tag);
str.setNum(height());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Rotation */
tag = doc->createElement(KXMLQLCEFXRotation);
root.appendChild(tag);
str.setNum(rotation());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Start function */
tag = doc->createElement(KXMLQLCEFXStartScene);
root.appendChild(tag);
str.setNum(startScene());
text = doc->createTextNode(str);
tag.appendChild(text);
if (startSceneEnabled() == true)
tag.setAttribute(KXMLQLCFunctionEnabled, KXMLQLCTrue);
else
tag.setAttribute(KXMLQLCFunctionEnabled, KXMLQLCFalse);
/* Stop function */
tag = doc->createElement(KXMLQLCEFXStopScene);
root.appendChild(tag);
str.setNum(stopScene());
text = doc->createTextNode(str);
tag.appendChild(text);
if (stopSceneEnabled() == true)
tag.setAttribute(KXMLQLCFunctionEnabled, KXMLQLCTrue);
else
tag.setAttribute(KXMLQLCFunctionEnabled, KXMLQLCFalse);
/********************************************
* X-Axis
********************************************/
tag = doc->createElement(KXMLQLCEFXAxis);
root.appendChild(tag);
tag.setAttribute(KXMLQLCFunctionName, KXMLQLCEFXX);
/* Offset */
subtag = doc->createElement(KXMLQLCEFXOffset);
tag.appendChild(subtag);
str.setNum(xOffset());
text = doc->createTextNode(str);
subtag.appendChild(text);
/* Frequency */
subtag = doc->createElement(KXMLQLCEFXFrequency);
tag.appendChild(subtag);
str.setNum(xFrequency());
text = doc->createTextNode(str);
subtag.appendChild(text);
/* Phase */
subtag = doc->createElement(KXMLQLCEFXPhase);
tag.appendChild(subtag);
str.setNum(xPhase());
text = doc->createTextNode(str);
subtag.appendChild(text);
/********************************************
* Y-Axis
********************************************/
tag = doc->createElement(KXMLQLCEFXAxis);
root.appendChild(tag);
tag.setAttribute(KXMLQLCFunctionName, KXMLQLCEFXY);
/* Offset */
subtag = doc->createElement(KXMLQLCEFXOffset);
tag.appendChild(subtag);
str.setNum(yOffset());
text = doc->createTextNode(str);
subtag.appendChild(text);
/* Frequency */
subtag = doc->createElement(KXMLQLCEFXFrequency);
tag.appendChild(subtag);
str.setNum(yFrequency());
text = doc->createTextNode(str);
subtag.appendChild(text);
/* Phase */
subtag = doc->createElement(KXMLQLCEFXPhase);
tag.appendChild(subtag);
str.setNum(yPhase());
text = doc->createTextNode(str);
subtag.appendChild(text);
return true;
}
int Braces::contentTop()
{
return yOffset() + contentTop_;
}
void GameCritterObject::onMovementAnimationEnded(Event* event)
{
auto hexagon = movementQueue()->back();
movementQueue()->pop_back();
Game::getInstance()->locationState()->moveObjectToHexagon(this, hexagon);
auto animation = dynamic_cast<Animation*>(ui());
if (movementQueue()->size() == 0)
{
_moving = false;
animation->stop();
setActionAnimation("aa");
return;
}
auto newHexagon = movementQueue()->back();
auto newOrientation = this->hexagon()->orientationTo(newHexagon);
if (event->name() == "animationEnded" || (int)newOrientation != orientation())
{
_orientation = newOrientation;
auto newAnimation = _generateMovementAnimation();
if (event->name() == "actionFrame")
{
newAnimation->setCurrentFrame(animation->currentFrame());
newAnimation->setActionFrame(animation->actionFrame());
}
else
{
newAnimation->setActionFrame(_running ? 2 : 4);
}
newAnimation->addEventHandler("actionFrame", std::bind(&GameCritterObject::onMovementAnimationEnded, this, std::placeholders::_1));
newAnimation->addEventHandler("animationEnded", std::bind(&GameCritterObject::onMovementAnimationEnded, this, std::placeholders::_1));
newAnimation->play();
delete _ui;
_ui = animation = newAnimation;
}
if (event->name() == "actionFrame")
{
// at each action frame critter switches to the next hex and frame positions are offset relative to the action frame offsets
auto actionFrame = animation->frames()->at(animation->actionFrame());
for (auto it = animation->frames()->rbegin(); it != animation->frames()->rend(); ++it)
{
auto frame = (*it);
frame->setXOffset(frame->xOffset() - actionFrame->xOffset());
frame->setYOffset(frame->yOffset() - actionFrame->yOffset());
if (frame == actionFrame) break;
}
if (_running)
{
switch (animation->actionFrame())
{
// those frame numbers were guessed to make seamless running animation
case 2:
animation->setActionFrame(4);
break;
case 4:
animation->setActionFrame(6);
break;
case 5:
animation->setActionFrame(7);
break;
}
}
}
}
void RWinColorPalette::OnPaint( )
{
CPaintDC dc( this );
RDcDrawingSurface ds;
ds.Initialize( (HDC) dc ) ;
CRect rcWindow;
GetClientRect( rcWindow );
RIntRect rcClient( rcWindow );
RBitmapImage& biPalette = GetPaletteBitmapImage();
biPalette.LockImage( );
biPalette.Render( ds, rcClient );
biPalette.UnlockImage( );
ds.DetachDCs();
CClientDC dcClient( this );
ds.Initialize( (HDC) dcClient ) ;
RColor crOldFill = ds.GetFillColor();
RColor crOldPen = ds.GetPenColor();
if (m_ptSelected.m_x >= 0 && m_ptSelected.m_y >= 0)
{
//
// Draw selected cell
RIntRect rcSelected(
m_ptSelected.m_x + 1,
m_ptSelected.m_y + 1,
m_ptSelected.m_x + kCellSize.m_dx - 1,
m_ptSelected.m_y + kCellSize.m_dy - 1 );
RSolidColor crBlack( kBlack );
RSolidColor crHilight( GetSysColor( COLOR_BTNHILIGHT ) );
ds.Draw3dRect( rcSelected, crBlack, crHilight );
RSolidColor crShadow( GetSysColor( COLOR_BTNSHADOW ) );
rcSelected.m_Top -= 1; rcSelected.m_Left -= 1;
ds.Draw3dRect( rcSelected, crShadow, crHilight );
if (GetFocus() == this)
{
RSolidColor rSolid = GetSysColor( COLOR_HIGHLIGHT );
RColor rSelected( rSolid );
rcSelected.Inflate( RIntSize( 1, 1 ), RIntSize( 2, 2 ) );
ds.SetPenColor( RColor( rSelected ) );
ds.FrameRectangle( rcSelected );
}
}
if (m_crHilited != (COLORREF) -1L)
{
// Draw color chip
m_rcColorChip = RIntRect(
m_ptHilited.m_x,
m_ptHilited.m_y,
m_ptHilited.m_x + 2 * kCellSize.m_dx,
m_ptHilited.m_y + 2 * kCellSize.m_dy );
YIntDimension xOffset( 2 * kCellSize.m_dx );
YIntDimension yOffset( 2 * kCellSize.m_dy );
if (m_rcColorChip.m_Right + xOffset > rcWindow.right)
{
xOffset = -3 * kCellSize.m_dx;
}
if (m_rcColorChip.m_Bottom + yOffset > rcWindow.bottom)
{
yOffset = -3 * kCellSize.m_dy;
}
m_rcColorChip.Offset( RIntSize( xOffset, yOffset ) );
RColor crFill = RSolidColor( m_crHilited );
RColor crPen = RSolidColor( kWhite );
ds.SetPenColor( crPen );
ds.SetFillColor( crFill );
ds.FillRectangle( m_rcColorChip );
ds.FrameRectangle( m_rcColorChip );
}
else
{
m_rcColorChip = RIntRect( 0, 0, 1, 1 );
}
ds.SetPenColor( crOldPen );
ds.SetFillColor( crOldFill );
ds.DetachDCs();
}
// -----------------------------------------------------------------------------
// Writes the texture list in TEXTUREX format to [texturex], using [patch_table]
// for patch information.
// Returns true on success, false otherwise
// -----------------------------------------------------------------------------
bool TextureXList::writeTEXTUREXData(ArchiveEntry* texturex, const PatchTable& patch_table)
{
// Check entry was given
if (!texturex)
return false;
if (texturex->isLocked())
return false;
Log::info("Writing " + textureXFormatString() + " format TEXTUREx entry");
/* Total size of a TEXTUREx lump, in bytes:
Header: 4 + (4 * numtextures)
Textures:
22 * numtextures (normal format)
14 * numtextures (nameless format)
18 * numtextures (Strife 1.1 format)
Patches:
10 * sum of patchcounts (normal and nameless formats)
6 * sum of patchcounts (Strife 1.1 format)
*/
size_t numpatchrefs = 0;
size_t numtextures = textures_.size();
for (size_t i = 0; i < numtextures; ++i)
{
numpatchrefs += textures_[i]->nPatches();
}
Log::info("{} patch references in {} textures", numpatchrefs, numtextures);
size_t datasize = 0;
size_t headersize = 4 + (4 * numtextures);
switch (txformat_)
{
case Format::Normal: datasize = 4 + (26 * numtextures) + (10 * numpatchrefs); break;
case Format::Nameless: datasize = 4 + (18 * numtextures) + (10 * numpatchrefs); break;
case Format::Strife11:
datasize = 4 + (22 * numtextures) + (6 * numpatchrefs);
break;
// Some compilers insist on having default cases.
default: return false;
}
MemChunk txdata(datasize);
vector<int32_t> offsets(numtextures);
int32_t foo = wxINT32_SWAP_ON_BE((signed)numtextures);
// Write header
txdata.seek(0, SEEK_SET);
SAFEFUNC(txdata.write(&foo, 4));
// Go to beginning of texture definitions
SAFEFUNC(txdata.seek(4 + (numtextures * 4), SEEK_SET));
// Write texture entries
for (size_t i = 0; i < numtextures; ++i)
{
// Get texture to write
auto tex = textures_[i].get();
// Set offset
offsets[i] = (signed)txdata.currentPos();
// Write texture entry
switch (txformat_)
{
case Format::Normal:
{
// Create 'normal' doom format texture definition
FullTexDef txdef;
memset(txdef.name, 0, 8); // Set texture name to all 0's (to ensure compatibility with XWE)
strncpy(txdef.name, tex->name().data(), tex->name().size());
for (auto& c : txdef.name)
c = toupper(c);
txdef.flags = 0;
txdef.scale[0] = (tex->scaleX() * 8);
txdef.scale[1] = (tex->scaleY() * 8);
txdef.width = tex->width();
txdef.height = tex->height();
txdef.columndir[0] = 0;
txdef.columndir[1] = 0;
txdef.patchcount = tex->nPatches();
// Check for WorldPanning flag
if (tex->world_panning_)
txdef.flags |= Flags::WorldPanning;
// Write texture definition
SAFEFUNC(txdata.write(&txdef, 22));
break;
}
case Format::Nameless:
{
// Create nameless texture definition
NamelessTexDef txdef;
txdef.flags = 0;
txdef.scale[0] = (tex->scaleX() * 8);
txdef.scale[1] = (tex->scaleY() * 8);
txdef.width = tex->width();
txdef.height = tex->height();
txdef.columndir[0] = 0;
txdef.columndir[1] = 0;
txdef.patchcount = tex->nPatches();
// Write texture definition
SAFEFUNC(txdata.write(&txdef, 8));
break;
}
case Format::Strife11:
{
// Create strife format texture definition
StrifeTexDef txdef;
memset(txdef.name, 0, 8); // Set texture name to all 0's (to ensure compatibility with XWE)
strncpy(txdef.name, tex->name().data(), tex->name().size());
for (auto& c : txdef.name)
c = toupper(c);
txdef.flags = 0;
txdef.scale[0] = (tex->scaleX() * 8);
txdef.scale[1] = (tex->scaleY() * 8);
txdef.width = tex->width();
txdef.height = tex->height();
txdef.patchcount = tex->nPatches();
// Check for WorldPanning flag
if (tex->world_panning_)
txdef.flags |= Flags::WorldPanning;
// Write texture definition
SAFEFUNC(txdata.write(&txdef, 18));
break;
}
default: return false;
}
// Write patch references
for (size_t k = 0; k < tex->nPatches(); ++k)
{
// Get patch to write
auto patch = tex->patch(k);
// Create patch definition
Patch pdef;
pdef.left = patch->xOffset();
pdef.top = patch->yOffset();
// Check for 'invalid' patch
if (StrUtil::startsWith(patch->name(), "INVPATCH"))
{
// Get raw patch index from name
std::string_view number = patch->name();
number.remove_prefix(8);
pdef.patch = StrUtil::asInt(number);
}
else
pdef.patch = patch_table.patchIndex(
patch->name()); // Note this will be -1 if the patch doesn't exist in the patch table. This
// should never happen with the texture editor, though.
// Write common data
SAFEFUNC(txdata.write(&pdef, 6));
// In non-Strife formats, there's some added rubbish
if (txformat_ != Format::Strife11)
{
foo = 0;
SAFEFUNC(txdata.write(&foo, 4));
}
}
}
// Write offsets
SAFEFUNC(txdata.seek(4, SEEK_SET));
SAFEFUNC(txdata.write(offsets.data(), 4 * numtextures));
// Write data to the TEXTUREx entry
texturex->importMemChunk(txdata);
// Update entry type
EntryType::detectEntryType(texturex);
return true;
}
