void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
{
if (!m_context->isAcceleratedContext()) {
if (context == m_context) {
RefPtr<Image> copy = copyImage(CopyBackingStore); // Drawing into our own buffer, need to deep copy.
copy->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
} else {
RefPtr<Image> imageForRendering = copyImage(DontCopyBackingStore);
imageForRendering->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
}
} else {
RefPtr<Image> copy = copyImage(CopyBackingStore);
copy->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
}
}
void SystemTray::updateToolTip()
{
// return; /////////////////////////////////////////////////////
Basket *basket = Global::bnpView->currentBasket();
if (!basket)
return;
if (basket->icon().isEmpty() || basket->icon() == "basket" || ! Settings::showIconInSystray())
setPixmap(basket->isLocked() ? m_lockedIconPixmap : m_iconPixmap);
else {
// Code that comes from JuK:
QPixmap bgPix = loadIcon("basket");
QPixmap fgPix = SmallIcon(basket->icon());
QImage bgImage = bgPix.convertToImage(); // Probably 22x22
QImage fgImage = fgPix.convertToImage(); // Should be 16x16
QImage lockOverlayImage = loadIcon("lockoverlay").convertToImage();
KIconEffect::semiTransparent(bgImage);
copyImage(bgImage, fgImage, (bgImage.width() - fgImage.width()) / 2,
(bgImage.height() - fgImage.height()) / 2);
if (basket->isLocked())
KIconEffect::overlay(bgImage, lockOverlayImage);
bgPix.convertFromImage(bgImage);
setPixmap(bgPix);
}
//QTimer::singleShot( Container::c_delayTooltipTime, this, SLOT(updateToolTipDelayed()) );
// No need to delay: it's be called when notes are changed:
updateToolTipDelayed();
}
PROC *kfork(char *filename)
{
int j, segment;
PROC *p = dequeue(&freeList);
if (p == 0) {
printf("Failed to kfork()\n");
getc();
return(0);
}
p->status = READY;
p->priority = 1;
p->ppid = running->pid;
p->parent = running;
p->uss = segment = (p->pid + 1) * 0x1000;
/*
* INITIALIZE p's kstack to make it start from body() when it runs.
* To do this, PRETNED that the process called tswitch() from the
* the entry address of body() and executed the SAVE part of tswitch()
* to give up CPU before.
* Initialize its kstack[ ] and ksp to comform to these.
*/
for (j=1; j<10; j++) {
p->kstack[SSIZE - j] = 0; // all saved registers = 0
}
p->kstack[SSIZE-1]=(int)goUmode; // called tswitch() from body
p->ksp = &(p->kstack[SSIZE-9]); // ksp -> kstack top
//printf("Loading executable\n"); //FOR TESTING
if(filename)
{
load(filename, segment); // Load executable
//printf("Executable loaded\n"); //FOR TESTING
for (j=1; j<13; j++) {
put_word(0, segment, -j*2); // Set all registers to 0
}
put_word(0x0200, segment, -2); // Flag
p->usp = -24;
}
else
{
copyImage(segment);
p->usp = running->usp;
put_word(0, segment, p->usp+16);
}
put_word(segment, segment, p->usp+20); // CS
put_word(segment, segment, p->usp+2); // ES
put_word(segment, segment, p->usp); // DS
//printProc(p);
enqueue(&readyQueue, p);
printQueue(readyQueue, freeList, sleepList);
/*printf("Ready queue:\n");
print_queue(readyList);*/
return(p->pid);
}
void MainWidget::updateScreenshotLabel()
{
ui->imageLabel->setPixmap(originalPixmap.scaled(ui->imageLabel->size(),
Qt::KeepAspectRatio,
Qt::SmoothTransformation));
copyImage();
}
void MathDisplay::buildActions()
{
setContextMenuPolicy(Qt::ActionsContextMenu);
act_copyText = new QAction(tr("Copy text"), this);
connect(act_copyText, SIGNAL(triggered()), this, SLOT(copyText()));
this->addAction(act_copyText);
act_copyLatex = new QAction(tr("Copy LaTeX code"), this);
connect(act_copyLatex, SIGNAL(triggered()), this, SLOT(copyLatex()));
this->addAction(act_copyLatex);
act_copyMml = new QAction(tr("Copy MathML code"), this);
connect(act_copyMml, SIGNAL(triggered()), this, SLOT(copyMml()));
this->addAction(act_copyMml);
act_copyImage = new QAction(tr("Copy image"), this);
connect(act_copyImage, SIGNAL(triggered()), this, SLOT(copyImage()));
act_copyImage->setEnabled(false);
this->addAction(act_copyImage);
act_saveImage = new QAction(tr("Save image"), this);
connect(act_saveImage, SIGNAL(triggered()), this, SLOT(saveImage()));
act_saveImage->setEnabled(false);
this->addAction(act_saveImage);
}
void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
{
ASSERT(context);
RefPtr<Image> imageCopy = copyImage(CopyBackingStore);
imageCopy->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
}
void BitmapImage::drawPattern(GraphicsContext& ctxt, const FloatRect& tileRect, const AffineTransform& transform,
const FloatPoint& phase, const FloatSize& spacing, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
{
if (tileRect.isEmpty())
return;
if (!ctxt.drawLuminanceMask()) {
Image::drawPattern(ctxt, tileRect, transform, phase, spacing, op, destRect, blendMode);
return;
}
if (!m_cachedImage) {
auto buffer = ImageBuffer::createCompatibleBuffer(expandedIntSize(tileRect.size()), ctxt);
if (!buffer)
return;
ImageObserver* observer = imageObserver();
ASSERT(observer);
// Temporarily reset image observer, we don't want to receive any changeInRect() calls due to this relayout.
setImageObserver(nullptr);
draw(buffer->context(), tileRect, tileRect, op, blendMode, ImageOrientationDescription());
setImageObserver(observer);
buffer->convertToLuminanceMask();
m_cachedImage = buffer->copyImage(DontCopyBackingStore, Unscaled);
if (!m_cachedImage)
return;
}
ctxt.setDrawLuminanceMask(false);
m_cachedImage->drawPattern(ctxt, tileRect, transform, phase, spacing, op, destRect, blendMode);
}
void ImageBuffer::draw(GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator op, bool useLowQualityScale)
{
#if ENABLE(ACCELERATED_2D_CANVAS)
context->syncSoftwareCanvas();
#endif
RefPtr<Image> imageCopy = copyImage();
context->drawImage(imageCopy.get(), styleColorSpace, destRect, srcRect, op, useLowQualityScale);
}
void ImageBuffer::drawPattern(GraphicsContext* destContext, const FloatRect& srcRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
{
if (!m_accelerateRendering) {
if (destContext == context()) {
// We're drawing into our own buffer. In order for this to work, we need to copy the source buffer first.
RefPtr<Image> copy = copyImage();
copy->drawPattern(destContext, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
} else {
RefPtr<Image> imageForRendering = BitmapImage::create(cgImage(m_size, m_data));
imageForRendering->drawPattern(destContext, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
}
} else {
RefPtr<Image> copy = copyImage();
copy->drawPattern(destContext, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
}
}
/****************************************************************************
**
** Copyright (C) 2016 - 2017
**
** This file is generated by the Magus toolkit
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
****************************************************************************/
// Include
#include <float.h>
#include <QMessageBox>
#include <QSettings>
#include "constants.h"
#include "hlms_node_samplerblock.h"
#include "hlms_node_porttypes.h"
//****************************************************************************/
HlmsNodeSamplerblock::HlmsNodeSamplerblock(QString title, QGraphicsItem* parent) :
Magus::QtNode(title, parent),
mTextureType(0),
mTextureIndex(0),
mSamplerblockEnabled(true),
mTextureAddressingModeU(0),
mTextureAddressingModeV(0),
mTextureAddressingModeW(0),
mMipLodBias(0.0f),
mMaxAnisotropy(1.0f),
mCompareFunction(8),
mMinLod(-FLT_MAX),
mMaxLod(FLT_MAX),
mBorderColourRed(255.0f),
mBorderColourGreen(255.0f),
mBorderColourBlue(255.0f),
mUvSet(0),
mBlendMode(0),
mMapWeight(1.0f),
mEmissiveColourRed(0.0f),
mEmissiveColourGreen(0.0f),
mEmissiveColourBlue(0.0f),
mAnimationEnabled(false),
mSequenceNumber(-1)
{
mFileNameTexture = QString("");
mBaseNameTexture = QString("");
mPathTexture = QString("");
mOffset = QVector2D(0.0f, 0.0f);
mScale = QVector2D(1.0f, 1.0f);
mAnimationScale = QVector2D(1.0f, 1.0f);
mAnimationTranslate = QVector2D(0.0f, 0.0f);
// Define the connection policy
HlmsPbsDatablockSamplerblockPortType hlmsPbsDatablockSamplerblockPortType;
HlmsSamplerblockDatablockPortType hlmsSamplerblockDatablockPortType;
hlmsPbsDatablockSamplerblockPortType.addPortTypeToConnectionPolicy(hlmsSamplerblockDatablockPortType);
// Apply values from settings.cfg
QSettings settings(FILE_SETTINGS, QSettings::IniFormat);
mTextureMinFilter = settings.value(SETTINGS_SAMPLERBLOCK_FILTER_INDEX).toInt();
mTextureMagFilter = settings.value(SETTINGS_SAMPLERBLOCK_FILTER_INDEX).toInt();
mTextureMipFilter = settings.value(SETTINGS_SAMPLERBLOCK_FILTER_INDEX).toInt();
// Custome node settings
setTitleColor(Qt::white);
setHeaderTitleIcon(ICON_SAMPLERBLOCK);
setAction1Icon(ICON_MINMAX);
setAction2Icon(ICON_CLOSE);
alignTitle(Magus::ALIGNED_LEFT);
setHeaderColor(QColor("#874E96"));
mPort = createPort(PORT_ID_SAMPLERBLOCK,
PORT_DATABLOCK,
hlmsPbsDatablockSamplerblockPortType,
QColor("#874E96"),
Magus::PORT_SHAPE_CIRCLE,
Magus::ALIGNED_LEFT,
QColor("#874E96"));
setPortNameColor(Qt::white);
setZoom(0.9);
}
//****************************************************************************/
HlmsNodeSamplerblock::~HlmsNodeSamplerblock(void)
{
}
//****************************************************************************/
void HlmsNodeSamplerblock::setFileNameTexture(const QString fileNameTexture, const QPixmap* pixmap)
{
mFileNameTexture = fileNameTexture;
if (pixmap)
copyImage(pixmap);
else
setImage(fileNameTexture);
}
void ImageBuffer::drawPattern(GraphicsContext& destContext, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
{
FloatRect adjustedSrcRect = srcRect;
adjustedSrcRect.scale(m_resolutionScale, m_resolutionScale);
if (!context().isAcceleratedContext()) {
if (&destContext == &context() || destContext.isAcceleratedContext()) {
if (RefPtr<Image> copy = copyImage(CopyBackingStore)) // Drawing into our own buffer, need to deep copy.
copy->drawPattern(destContext, adjustedSrcRect, patternTransform, phase, spacing, styleColorSpace, op, destRect, blendMode);
} else {
if (RefPtr<Image> imageForRendering = copyImage(DontCopyBackingStore))
imageForRendering->drawPattern(destContext, adjustedSrcRect, patternTransform, phase, spacing, styleColorSpace, op, destRect, blendMode);
}
} else {
if (RefPtr<Image> copy = copyImage(CopyBackingStore))
copy->drawPattern(destContext, adjustedSrcRect, patternTransform, phase, spacing, styleColorSpace, op, destRect, blendMode);
}
}
void ImageBuffer::draw(GraphicsContext* destContext, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
CompositeOperator op, bool useLowQualityScale)
{
if (!m_accelerateRendering) {
if (destContext == context()) {
// We're drawing into our own buffer. In order for this to work, we need to copy the source buffer first.
RefPtr<Image> copy = copyImage();
destContext->drawImage(copy.get(), ColorSpaceDeviceRGB, destRect, srcRect, op, useLowQualityScale);
} else {
RefPtr<Image> imageForRendering = BitmapImage::create(cgImage(m_size, m_data));
destContext->drawImage(imageForRendering.get(), styleColorSpace, destRect, srcRect, op, useLowQualityScale);
}
} else {
RefPtr<Image> copy = copyImage();
ColorSpace colorSpace = (destContext == context()) ? ColorSpaceDeviceRGB : styleColorSpace;
destContext->drawImage(copy.get(), colorSpace, destRect, srcRect, op, useLowQualityScale);
}
}
LayerGraphics::~LayerGraphics ()
{
// Convert from premultiplied to normal.
//
unPremultiplyImage (m_fill);
// Extract the layer's RGB components as Image::RGB
//
Image fillImage (ChannelImageType::fromImage (m_fill, -1));
// Extract the layer's alpha mask as a single channel image.
//
Image maskImage (ChannelImageType::fromImage (m_fill, PixelARGB::indexA));
// Obtain bitmap data for mask and fill.
//
Pixels fillPixels (fillImage);
Pixels maskPixels (maskImage);
Pixels workPixels (m_work);
m_options.innerShadow (fillPixels, maskPixels);
m_options.dropShadow (m_work, maskImage);
if (m_options.general.groupInteriorEffects)
{
// satin
m_options.colourOverlay (fillPixels);
m_options.gradientOverlay (fillPixels);
m_options.patternOverlay (fillPixels);
m_options.innerGlow (fillPixels, maskPixels);
m_options.fill (m_work, m_fill);
}
else
{
m_options.fill (m_work, m_fill);
m_options.colourOverlay (workPixels);
m_options.gradientOverlay (workPixels);
m_options.patternOverlay (workPixels);
m_options.innerGlow (workPixels, maskPixels);
}
m_options.outerGlow (workPixels, maskPixels);
m_options.bevelEmboss (workPixels, maskPixels);
m_options.stroke (workPixels, maskPixels);
// Copy the work image onto the background layer
// using normal mode and the general opacity.
copyImage (
m_base,
m_workOrigin,
m_work,
m_work.getBounds (),
BlendMode::modeNormal,
m_options.general.opacity);
}
void ImageBuffer::drawPattern(GraphicsContext* destContext, const FloatRect& srcRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
{
if (destContext == context()) {
// We're drawing into our own buffer. In order for this to work, we need to copy the source buffer first.
RefPtr<Image> copy = copyImage(CopyBackingStore);
copy->drawPattern(destContext, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
} else
m_data.m_image->drawPattern(destContext, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
}
void ImageBuffer::draw(GraphicsContext* destContext, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
CompositeOperator op, BlendMode blendMode, bool useLowQualityScale)
{
if (destContext == context()) {
// We're drawing into our own buffer. In order for this to work, we need to copy the source buffer first.
RefPtr<Image> copy = copyImage(CopyBackingStore);
destContext->drawImage(copy.get(), ColorSpaceDeviceRGB, destRect, srcRect, op, blendMode, DoNotRespectImageOrientation, useLowQualityScale);
} else
destContext->drawImage(m_data.m_image.get(), styleColorSpace, destRect, srcRect, op, blendMode, DoNotRespectImageOrientation, useLowQualityScale);
}
void FillStyle::operator() (Image destImage, Image fillImage)
{
copyImage (
destImage,
Point <int> (0, 0),
fillImage,
fillImage.getBounds (),
mode,
opacity);
}
int fork()
{
PROC *p; int i, child, pid; u16 segment;
pid = kfork(0); // kfork() but do NOT load any Umode image for child
if (pid < 0){ // kfork failed
return -1;
}
p = &proc[pid]; // we can do this because of static pid
for (i=0; i<NFD; i++){
p->fd[i] = running->fd[i];
if (p->fd[i] != 0){
p->fd[i]->refCount++;
if (p->fd[i]->mode == READ_PIPE)
p->fd[i]->pipe_ptr->nreader++;
if (p->fd[i]->mode == WRITE_PIPE){
p->fd[i]->pipe_ptr->nwriter++;
}
}
}
segment = (pid+1)*0x2000;
copyImage(running->uss, segment, 32*1024);
p->uss = segment;
p->usp = 0x2000 - 24;
// YOUR CODE to make the child runnable in User mode
p->kstack[SSIZE -1] =(int)goUmode;
/**** ADD these : copy file descriptors ****/
// clean the registers and set flag and uCs and uDs to runnings values
for (i = 1; i < 13; i++) {
child = 0x2000 - i*2;
switch(i){
case 1: put_word(segment, segment, child); break;
case 2: put_word(segment, segment, child); break;
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10: put_word(0,segment, child); break;
case 11:
case 12: put_word(segment, segment, child); break;
}
}
return(p->pid);
}
QRImageWidget::QRImageWidget(QWidget *parent):
QLabel(parent), contextMenu(0)
{
contextMenu = new QMenu();
QAction *saveImageAction = new QAction(tr("&Save Image..."), this);
connect(saveImageAction, SIGNAL(triggered()), this, SLOT(saveImage()));
contextMenu->addAction(saveImageAction);
QAction *copyImageAction = new QAction(tr("&Copy Image"), this);
connect(copyImageAction, SIGNAL(triggered()), this, SLOT(copyImage()));
contextMenu->addAction(copyImageAction);
}
int main(int argc,char** argv)
{
AnalyzeImage imgin,imgout;
int x,y,z,labelsToChange,i;
int intstatus;
int inlabel,outlabel;
bool clobber = true;
bool status;
div_t divtmp;
if(argc < 5) {
cout << "Usage: relabel_analyze inputfile outputfile inlabel1 outlabel1" << endl;
return(1);
}
intstatus = readImage(argv[1],&imgin);
if(intstatus != 0) {
cout << "Could not read the file" << argv[1] << endl;
return(2);
}
status = copyImage(&imgin,&imgout);
divtmp = div(argc - 3,2);
if(divtmp.rem == 0) {
labelsToChange = divtmp.quot;
}
else {
cout << " wrong number of inputs" << endl;
return(3);
}
for(i = 0;i < labelsToChange;i++) {
inlabel = atoi(argv[2*i + 3]);
outlabel = atoi(argv[2*i + 4]);
cout << "Changing" << inlabel << "->" << outlabel << endl;
for(x = 0;x < imgin.header.x_dim;x++) {
for(y = 0;y < imgin.header.y_dim;y++) {
for(z = 0;z < imgin.header.z_dim;z++) {
if(fabs(getVoxelValue(&imgin,x,y,z) - inlabel) < 0.0001)
putVoxelValue(&imgout,x,y,z,outlabel);
}
}
}
}
intstatus = writeImage(argv[2],&imgout,clobber);
if(intstatus != 0) {
cout << "Could not write the file" << argv[2] << endl;
return(3);
}
return(0);
}
// Compute fitness =========================================================
double ObjFunc_nma_alignment::eval(Vector X, int *nerror) {
int dim = global_nma_prog->numberOfModes;
for (int i = 0; i < dim; i++) {
global_nma_prog->trial(i) = X[i];
}
int pyramidLevelDisc = 1;
int pyramidLevelCont = (global_nma_prog->currentStage == 1) ? 1 : 0;
FileName fnRandom = global_nma_prog->createDeformedPDB(pyramidLevelCont);
const char * randStr = fnRandom.c_str();
if (global_nma_prog->currentStage == 1) {
global_nma_prog->performCompleteSearch(fnRandom, pyramidLevelDisc);
} else {
double rot, tilt, psi, xshift, yshift;
MetaData DF;
rot = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 5);
tilt = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 4);
psi = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 3);
xshift = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 2);
yshift = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 1);
size_t objId = DF.addObject();
FileName fnDown = formatString("%s_downimg.xmp", randStr);
DF.setValue(MDL_IMAGE, fnDown, objId);
DF.setValue(MDL_ENABLED, 1, objId);
DF.setValue(MDL_ANGLE_ROT, rot, objId);
DF.setValue(MDL_ANGLE_TILT, tilt, objId);
DF.setValue(MDL_ANGLE_PSI, psi, objId);
DF.setValue(MDL_SHIFT_X, xshift, objId);
DF.setValue(MDL_SHIFT_Y, yshift, objId);
DF.write(formatString("%s_angledisc.xmd", randStr));
copyImage(global_nma_prog->currentImgName.c_str(), fnDown.c_str());
}
double fitness = global_nma_prog->performContinuousAssignment(fnRandom,
pyramidLevelCont);
runSystem("rm", formatString("-rf %s* &", randStr));
global_nma_prog->updateBestFit(fitness, dim);
return fitness;
}
PROC *kfork(char *filename)
{
int j;
// Get free proc, return if none
PROC *ptr = dequeue(&freeList);
if (ptr == 0) {
printf("Failed to kfork()\n");
getc();
return(0);
}
// Set basics
ptr->status = READY;
ptr->priority = 1;
ptr->ppid = running->pid;
ptr->parent = running;
ptr->uss = (ptr->pid + 1) * 0x1000;
// Configure kStack
for (j=1; j<10; j++) {
ptr->kstack[SSIZE - j] = 0; // all saved registers = 0
}
ptr->kstack[SSIZE-1]=(int)goUmode; // called tswitch() from body
ptr->ksp = &(ptr->kstack[SSIZE-9]); // ksp -> kstack top
// Configure uStack
if (filename) {
load(filename, ptr->uss); // Load executable
for (j=1; j<13; j++) {
put_word(0, ptr->uss, -j*2); // Registers to 0
}
put_word(0x0200, ptr->uss, -2); // Flag
ptr->usp = -24;
} else {
copyImage(ptr->uss);
ptr->usp = running->usp;
put_word(0, ptr->uss, ptr->usp + 16);
//printProc(running);
//getc();
//printProc(ptr);
//getc();
}
put_word(ptr->uss, ptr->uss, ptr->usp + 20); // CS
put_word(ptr->uss, ptr->uss, ptr->usp + 2); // ES
put_word(ptr->uss, ptr->uss, ptr->usp); // DS
// Put in readyList and return
enqueue(&readyList, ptr);
return(ptr);
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality, CoordinateSystem) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
// QImageWriter does not support mimetypes. It does support Qt image formats (png,
// gif, jpeg..., xpm) so skip the image/ to get the Qt image format used to encode
// the m_pixmap image.
RefPtr<Image> image = copyImage(DontCopyBackingStore);
QByteArray data;
if (!encodeImage(*image->nativeImageForCurrentFrame(), mimeType.substring(sizeof "image"), quality, data))
return "data:,";
return "data:" + mimeType + ";base64," + data.toBase64().data();
}
void runSelect(unsigned int * d_result)
{
switch(type)
{
case 1:
copyImage(h_img, d_result, width, height);
break;
case 2:
bilateralFilterRGBA(d_result, width, height, euclidean_delta, filter_radius, iterations, nthreads);
//bilateralFilterGold(h_img, h_temp, euclidean_delta, width, height, filter_radius);
//copyImage(h_temp, d_result, width, height);
break;
default:
break;
}
}
void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
{
bool is_set = false;
#ifdef _DEBUG
return;
#endif
#if 1 // no mipmap
if (level > 0)
return;
#endif
if (!GLImpl.tmus[GLImpl.current_tmu].boundtexture) {
printf("Not texture binded\n");
return;
}
GLImpl.device->SetTexture(0, NULL);
GLTexture * surf = NULL;
if (GLImpl.tmus[GLImpl.current_tmu].boundtexture && GLImpl.tmus[GLImpl.current_tmu].boundtexture->teximg ) {
surf = GLImpl.tmus[GLImpl.current_tmu].boundtexture->teximg;
}
if (surf) {
int srcbytes = src_format_to_bypp(format);
int dstbytes = dst_format_to_bypp(GLImpl.tmus[GLImpl.current_tmu].boundtexture->internalformat);
BYTE * surfbuf;
BYTE * srcdata = (BYTE*) pixels;
BYTE * dstdata;
surf->lockTexture(level);
srcdata = (BYTE*) pixels;
surfbuf = (BYTE*)surf->getData();
dstdata = (BYTE*)surf->getData();
check_format(srcbytes, dstbytes);
copyImage(xoffset, yoffset, width, height, srcdata, srcbytes, surfbuf, dstbytes);
surf->unlockTexture(level);
GLImpl.tmus[GLImpl.current_tmu].boundtexture->dirty = 1;
}
}
void ImageBuffer::draw(GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& dstRect, const FloatRect& srcRect,
CompositeOperator op, bool useLowQualityScale)
{
if (m_data.m_tiledImage && context != m_context.get()) {
FloatRect src = srcRect;
if (src.width() == -1)
src.setWidth(m_data.m_tiledImage->size().width());
if (src.height() == -1)
src.setHeight(m_data.m_tiledImage->size().height());
ASSERT(context->platformContext()->activePainter());
context->platformContext()->activePainter()->drawImage(m_data.m_tiledImage.get(), dstRect, src);
return;
}
RefPtr<Image> imageCopy = copyImage();
context->drawImage(imageCopy.get(), styleColorSpace, dstRect, srcRect, op, useLowQualityScale);
}
Theme::Theme(const QString& name)
: m_name(name)
{
if (m_name.isEmpty()) {
QString untitled;
int count = 0;
do {
count++;
untitled = tr("Untitled %1").arg(count);
} while (QFile::exists(filePath(untitled)));
m_name = untitled;
}
QSettings settings(filePath(m_name), QSettings::IniFormat);
// Load background settings
m_background_type = settings.value("Background/Type", 0).toInt();
m_background_color = settings.value("Background/Color", "#cccccc").toString();
m_background_path = settings.value("Background/Image").toString();
m_background_image = settings.value("Background/ImageFile").toString();
if (!m_background_path.isEmpty() && m_background_image.isEmpty()) {
setValue(m_background_image, copyImage(m_background_path));
}
// Load foreground settings
m_foreground_color = settings.value("Foreground/Color", "#cccccc").toString();
m_foreground_opacity = qBound(0, settings.value("Foreground/Opacity", 100).toInt(), 100);
m_foreground_width = qBound(500, settings.value("Foreground/Width", 700).toInt(), 2000);
m_foreground_rounding = qBound(0, settings.value("Foreground/Rounding", 0).toInt(), 100);
m_foreground_margin = qBound(0, settings.value("Foreground/Margin", 65).toInt(), 250);
m_foreground_padding = qBound(0, settings.value("Foreground/Padding", 0).toInt(), 250);
m_foreground_position = qBound(0, settings.value("Foreground/Position", 1).toInt(), 3);
// Load text settings
m_text_color = settings.value("Text/Color", "#000000").toString();
m_text_font.fromString(settings.value("Text/Font", QFont("Times New Roman").toString()).toString());
m_misspelled_color = settings.value("Text/Misspelled", "#ff0000").toString();
// Load spacings
m_indent_first_line = settings.value("Spacings/IndentFirstLine", false).toBool();
m_line_spacing = qBound(100, settings.value("Spacings/LineSpacing", 100).toInt(), 1000);
m_paragraph_spacing_above = qBound(0, settings.value("Spacings/ParagraphAbove", 0).toInt(), 1000);
m_paragraph_spacing_below = qBound(0, settings.value("Spacings/ParagraphBelow", 0).toInt(), 1000);
}
Label *createImageLabel(SDL_Surface *image, int x, int y)
{
Label *l;
l = malloc(sizeof(Label));
if (l == NULL)
{
showErrorAndExit("Failed to allocate %d bytes to create image Label", (int)sizeof(Label));
}
l->text = copyImage(image, 0, 0, image->w, image->h);
l->x = x;
l->y = y;
return l;
}
void Theme::copyBackgrounds()
{
QDir dir(path() + "/Images");
QStringList images;
// Copy images
QStringList themes = QDir(path(), "*.theme").entryList(QDir::Files);
foreach (const QString& theme, themes) {
QSettings settings(path() + "/" + theme, QSettings::IniFormat);
QString background_path = settings.value("Background/Image").toString();
QString background_image = settings.value("Background/ImageFile").toString();
if (background_path.isEmpty() && background_image.isEmpty()) {
continue;
}
if (!background_path.isEmpty() && (background_image.isEmpty() || !dir.exists(background_image))) {
background_image = copyImage(background_path);
settings.setValue("Background/ImageFile", background_image);
}
images.append(background_image);
}
void CrashTestPlugin3::domenu(const QString &menu_name, V3DPluginCallback &callback, QWidget *parent)
{
myCallback = &callback;
sourceWindow = callback.currentImageWindow();
sourceImage = callback.getImage(sourceWindow);
myDialog = new QDialog(parent);
QPushButton* processButton = new QPushButton("process a black image test");
QPushButton* restoreButton = new QPushButton("Restore");
QFormLayout *formLayout = new QFormLayout( myDialog );
formLayout->addRow( processButton , restoreButton );
myDialog->connect(processButton, SIGNAL(clicked()), this, SLOT( processBlackImage() ));
myDialog->connect(restoreButton, SIGNAL(clicked()), this, SLOT( restore() ));
copyImage();
myDialog->exec();
}
void VectorTexture::rasterizeGraphics(NSVGimage* svg, Filtering filtering, Wrap wrap, std::string filepath)
{
// TODO: Size depending on image scale. Better depend on rendering resolution
uint width = (uint)(svg->width);
uint height = (uint)(svg->height);
const uint channelCount = 4;
// Create rasterizer
NSVGrasterizer* rast = nsvgCreateRasterizer();
// Prepare memory for image
std::vector<uchar> image;
image.resize(width * height * channelCount);
// Rasterize
nsvgRasterize(rast, svg, 0, 0, 1, image.data(), width, height, width * channelCount);
// Flip image
std::vector<uchar> copyImage(image);
// Go over lines
for (uint i = 0; i < height; i++)
{
// Go over columns
for (uint j = 0; j < width; j++)
{
// Go over channels
for (uint k = 0; k < channelCount; k++)
{
image[i * width * channelCount + j * channelCount + k] = copyImage[(height - 1 - i) * width * channelCount + j * channelCount + k];
}
}
}
// Create OpenGL from image
createOpenGLTexture(image, filtering, wrap, width, height, channelCount, filepath);
// Delete NanoSVG stuff
nsvgDeleteRasterizer(rast);
}
