Пример #1
0
Furnace::Furnace(furnaceData *data_)
{

  data = data_;
  uint8_t block;
  uint8_t meta;
  Mineserver::get()->map(data->map)->getBlock(data->x, data->y, data->z, &block, &meta);
  if(!configIsRead)
  {
    readConfig();
    configIsRead=true;
  }

  // Check if this is a burning block
  if(block == BLOCK_BURNING_FURNACE)
  {
    m_burning = true;
  }
  else
  {
    m_burning = false;
  }

  // Make sure we're the right kind of block based on our current status
  updateBlock();
}
Пример #2
0
void Furnace::consumeFuel()
{
  // Check that we have fuel
  if(m_slots[SLOT_FUEL].count == 0)
    return;

  // Increment the fuel burning time based on fuel type
  // http://www.minecraftwiki.net/wiki/Furnace#Fuel_efficiency
  Slot fuelSlot = m_slots[SLOT_FUEL];
  m_initialBurningTime = 0;
  if(fuelSlot.id == ITEM_COAL)           { m_initialBurningTime += 80; }
  if(fuelSlot.id == BLOCK_PLANK)          { m_initialBurningTime += 15; }
  if(fuelSlot.id == ITEM_STICK)          { m_initialBurningTime += 5; }
  if(fuelSlot.id == BLOCK_WOOD)           { m_initialBurningTime += 15; }
  if(fuelSlot.id == BLOCK_WORKBENCH)     { m_initialBurningTime += 15; }
  if(fuelSlot.id == BLOCK_CHEST)         { m_initialBurningTime += 15; }
  if(fuelSlot.id == BLOCK_BOOKSHELF)     { m_initialBurningTime += 15; }
  if(fuelSlot.id == BLOCK_JUKEBOX)       { m_initialBurningTime += 15; }
  if(fuelSlot.id == BLOCK_FENCE)         { m_initialBurningTime += 15; }
  if(fuelSlot.id == BLOCK_WOODEN_STAIRS) { m_initialBurningTime += 15; }
  if(fuelSlot.id == ITEM_LAVA_BUCKET)    { m_initialBurningTime += 1000; }
  m_fuelBurningTime += m_initialBurningTime;

  // Now decrement the fuel & reset
  m_slots[SLOT_FUEL].count--;
  if(m_slots[SLOT_FUEL].count < 0)
    m_slots[SLOT_FUEL].count = 0;

  // Update our block type if need be
  updateBlock();
}
double AnimationControllerPrivate::updateAnimations(SetChanged callSetChanged/* = DoNotCallSetChanged*/)
{
    AnimationPrivateUpdateBlock updateBlock(*this);
    double timeToNextService = -1;
    bool calledSetChanged = false;

    for (auto& compositeAnimation : m_compositeAnimations) {
        CompositeAnimation& animation = *compositeAnimation.value;
        if (!animation.isSuspended() && animation.hasAnimations()) {
            double t = animation.timeToNextService();
            if (t != -1 && (t < timeToNextService || timeToNextService == -1))
                timeToNextService = t;
            if (!timeToNextService) {
                if (callSetChanged != CallSetChanged)
                    break;
                Element* element = compositeAnimation.key->element();
                ASSERT(element);
                ASSERT(!element->document().inPageCache());
                element->setNeedsStyleRecalc(SyntheticStyleChange);
                calledSetChanged = true;
            }
        }
    }

    if (calledSetChanged)
        m_frame.document()->updateStyleIfNeeded();

    return timeToNextService;
}
Пример #4
0
void DocBlock::addLink(QUrl url)
{
    myTextItem->setTextInteractionFlags(Qt::TextSelectableByKeyboard);
    docType = Link;
    path = url.toString();
    QString str = path;

    // add file icon
    QTextCursor cursor = QTextCursor(myTextItem->document());
    QFileInfo info(url.toLocalFile());
    QFileIconProvider *provider = new QFileIconProvider();
    QImage image(provider->icon(info).pixmap(16, 16).toImage());
    cursor.document()->setPlainText(" ");
    cursor.insertImage(image);
	
    if (str.lastIndexOf("/") > -1)
        str = str.right(str.size() - str.lastIndexOf("/") - 1);

    QString html = "<a href=\""+path+"\">"+str+"</a>";
    cursor.insertHtml(html);
	
    if (arrow != 0) arrow->setColor(getHoverColor());

    updateBlock(false);
}
Пример #5
0
Furnace::Furnace(furnaceDataPtr data)
  : m_data(data)
{
  uint8_t block;
  uint8_t meta;

  ServerInstance->map(m_data->map)->getBlock(m_data->x, m_data->y, m_data->z, &block, &meta);

  if (!configIsRead)
  {
    readConfig();
    configIsRead = true;
  }

  // Check if this is a burning block
  if (block == BLOCK_BURNING_FURNACE)
  {
    m_burning = true;
  }
  else
  {
    m_burning = false;
  }

  // Make sure we're the right kind of block based on our current status
  updateBlock();
}
Пример #6
0
void TextDocument::lowlight(int block)
{
    if (block == -1)
        block = totalCount() - 1;
    if (d.lowlight != block) {
        d.lowlight = block;
        updateBlock(block);
    }
}
Пример #7
0
/**
 * Overview:
 * myRIO main function. This template contains basic code to open the myRIO
 * FPGA session. You can remove this code if you only need to use the UART.
 *
 * Code in myRIO example projects is designed for reuse. You can copy source
 * files from the example project to use in this template.
 *
 * Note:
 * The Eclipse project defines the preprocessor symbol for the myRIO-1900.
 * Change the preprocessor symbol to use this example with the myRIO-1950.
 */
int main(int argc, char **argv)
{
    NiFpga_Status status;

    /*
     * Open the myRIO NiFpga Session.
     * This function MUST be called before all other functions. After this call
     * is complete the myRIO target will be ready to be used.
     */
    status = MyRio_Open();
    if (MyRio_IsNotSuccess(status))
    {
        return status;
    }

    /*
     * Your application code goes here.
     */

    //we're gonna need lots of ram boss
    //layout of memory:
    //0-MEM_WIDTH: memory blocks of MEM_DEPTH size
    //MEM_ITER = MEM_WIDTH+1: a table of current indexes for each block
    //MEM_VAL = MEM_WIDTH+2: a table of current averages for each block
    
    double  reference[MEM_WIDTH] = [0,1,5,2,7,8,2,6,7,3]; //something to test with
    double* memory[MEM_WIDTH+2];
    initializeMemory(memory);

    int keepGoing = 1;
    int index = getIndex(0);
    double Kp = 1;
    double Ki = 1;
    double lastError[MEM_WIDTH] = {0};
    while(keepGoing) {
    	index = getIndex(index);
	double toSet = (Kp*lastError[index])+(Ki*MEM_VAL[index])+reference[index];
    	setOutput(outputHandle, toSet);
	//wait for a bit (outputs aren't instantaneous!)
	double result = measureFeedback(feedbackHandle); //some sort of unit conversion needs to take place here
	lastError[index] = result-reference[index];
	updateBlock(memory, index, lastError[index]);
	
    }

    /*
     * Close the myRIO NiFpga Session.
     * This function MUST be called after all other functions.
     */
    freeTheMemory(memory);
    status = MyRio_Close();

    return status;
}
void AnimationControllerPrivate::resumeAnimationsForDocument(Document* document)
{
    AnimationPrivateUpdateBlock updateBlock(*this);

    for (auto& animation : m_compositeAnimations) {
        if (&animation.key->document() == document)
            animation.value->resumeAnimations();
    }

    updateAnimationTimer();
}
Пример #9
0
void TextDocument::addHighlight(int block)
{
    const int max = totalCount() - 1;
    if (block == -1)
        block = max;
    if (block >= 0 && block <= max) {
        QList<int>::iterator it = qLowerBound(d.highlights.begin(), d.highlights.end(), block);
        d.highlights.insert(it, block);
        updateBlock(block);
    }
}
Пример #10
0
void DocBlock::addText(QString text)
{
    myTextItem->setTextInteractionFlags(Qt::TextEditable | Qt::TextSelectableByKeyboard);
    myTextItem->setPlainText(text);
    docType = Text;

    if (arrow != 0)
        arrow->setColor(getHoverColor());

    path = "";
    updateBlock(false);
}
Пример #11
0
void DocBlock::addImage(const QImage &image, QString imagePath)
{
    myTextItem->setTextInteractionFlags(Qt::TextSelectableByKeyboard);
    docType = Image;
    QTextCursor cursor = QTextCursor(myTextItem->document());
    cursor.document()->setPlainText("");
    cursor.insertImage(image);
    path = imagePath;

    if (arrow != 0) arrow->setColor(getHoverColor());

    updateBlock(false);
}
Пример #12
0
Motogame::Motogame(bool LowQ, bool OGL3, bool Fullscreen, CWallet* pWallet, QObject *parent) :
    QObject(parent), m_Motogame(this), m_pWallet(pWallet), m_ReserveKey(pWallet), m_pPrevBest(nullptr)
{
    m_Motogame.setWorkingDirectory(QCoreApplication::applicationDirPath());
    m_Motogame.start(getMotogame(LowQ, OGL3, Fullscreen));

    connect(&m_Motogame, SIGNAL(readyReadStandardOutput()), this, SLOT(onReadAvailable()));
    connect(&m_Motogame, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(onGameFinished(int, QProcess::ExitStatus)));
    connect(&m_Motogame, SIGNAL(error(QProcess::ProcessError)), this, SLOT(onError(QProcess::ProcessError)));

    updateBlock();
    startTimer(500);
}
Пример #13
0
Furnace::Furnace(NBT_Value* entity, uint8_t blockType)
{
  // Setup this furnace
  m_x = (int32_t)(*(*entity)["x"]);
  m_y = (int32_t)(*(*entity)["y"]);
  m_z = (int32_t)(*(*entity)["z"]);
  //m_fuelBurningTime = (int16_t)(*(*entity)["BurnTime"]);

  // Clean out the slots
  m_slots[SLOT_INPUT].count  = 0;
  m_slots[SLOT_INPUT].damage = 0;
  m_slots[SLOT_INPUT].id     = 0;
  m_slots[SLOT_FUEL].count   = 0;
  m_slots[SLOT_FUEL].damage  = 0;
  m_slots[SLOT_FUEL].id      = 0;
  m_slots[SLOT_OUTPUT].count = 0;
  m_slots[SLOT_OUTPUT].damage= 0;
  m_slots[SLOT_OUTPUT].id    = 0;


  // Set the cooking time based on input type (currently all smelting takes 10 secs but this gives us flexivibility in future)
  Slot inputSlot = m_slots[SLOT_INPUT];
  m_cookingTime = 0;
  if(inputSlot.id == BLOCK_IRON_ORE)     { m_cookingTime = 10; }
  if(inputSlot.id == BLOCK_GOLD_ORE)     { m_cookingTime = 10; }
  if(inputSlot.id == BLOCK_SAND)         { m_cookingTime = 10; }
  if(inputSlot.id == BLOCK_COBBLESTONE)  { m_cookingTime = 10; }
  if(inputSlot.id == ITEM_PORK)          { m_cookingTime = 10; }
  if(inputSlot.id == ITEM_CLAY_BALLS)    { m_cookingTime = 10; }
  if(inputSlot.id == ITEM_RAW_FISH)      { m_cookingTime = 10; }

  // Reset our active duration
  m_fuelBurningTime = 0;
  m_activeCookDuration = 0;

  // Check if this is a burning block
  if(blockType == BLOCK_BURNING_FURNACE)
  {
    m_burning = true;
  }
  else
  {
    m_burning = false;
  }

  // Make sure we're the right kind of block based on our current status
  updateBlock();
}
void AnimationControllerPrivate::animationTimerFired()
{
    // We need to keep the frame alive, since it owns us.
    Ref<Frame> protector(m_frame);

    // Make sure animationUpdateTime is updated, so that it is current even if no
    // styleChange has happened (e.g. accelerated animations)
    AnimationPrivateUpdateBlock updateBlock(*this);

    // When the timer fires, all we do is call setChanged on all DOM nodes with running animations and then do an immediate
    // updateStyleIfNeeded.  It will then call back to us with new information.
    updateAnimationTimer(CallSetChanged);

    // Fire events right away, to avoid a flash of unanimated style after an animation completes, and before
    // the 'end' event fires.
    fireEventsAndUpdateStyle();
}
Пример #15
0
static
uint replacePairs(CRDS *crds, PAIR *target, CODE new_code)
{
  uint i, j;
  uint num_replaced = 0;
  SEQ *seq = crds->seq;

  i = target->f_pos;
  while (i != DUMMY_POS) {
    j = seq[i].next;
    if (j == rightPos(crds, i)) {
      j = seq[j].next;
    }
    updateBlock(crds, new_code, i);
    i = j;
    num_replaced++;
  }

  return num_replaced;
}
Пример #16
0
void Furnace::consumeFuel()
{
  // Check that we have fuel
  if(slots()[SLOT_FUEL].count == 0)
    return;

  // Increment the fuel burning time based on fuel type
  // http://www.minecraftwiki.net/wiki/Furnace#Fuel_efficiency
  Item *fuelSlot = &slots()[SLOT_FUEL];

  uint16_t fuelTime = 0;
  switch(fuelSlot->type)
  {
    case ITEM_COAL:           fuelTime = 80;   break;
    case BLOCK_PLANK:         fuelTime = 15;   break;
    case ITEM_STICK:          fuelTime = 5;    break;
    case BLOCK_WOOD:          fuelTime = 15;   break;
    case BLOCK_WORKBENCH:     fuelTime = 15;   break;
    case BLOCK_CHEST:         fuelTime = 15;   break;
    case BLOCK_BOOKSHELF:     fuelTime = 15;   break;
    case BLOCK_JUKEBOX:       fuelTime = 15;   break;
    case BLOCK_FENCE:         fuelTime = 15;   break;
    case BLOCK_WOODEN_STAIRS: fuelTime = 15;   break;
    case ITEM_LAVA_BUCKET:    fuelTime = 1000; break;
    default: break;
  }

  if(fuelTime > 0)
  {
    data->burnTime += fuelTime;
    // Now decrement the fuel & reset
    fuelSlot->count--;
    if (fuelSlot->count == 0)
    {
      *fuelSlot = Item();
    }
  }

  // Update our block type if need be
  updateBlock();
}
Пример #17
0
void DocBlock::setFolded(bool fold)
{
    if (fold == folded) return; //! do nothing

    folded = fold;

    if (fold)
    {
        backup = myTextItem->document()->clone();

        if (docType == Image)
        {
            QTextCursor cursor = QTextCursor(myTextItem->document());
            cursor.document()->setPlainText(" ");
            cursor.insertImage(QImage(":/image.png"));
            cursor.insertText(QFileInfo(path).fileName());
        }
        else
        {
            QString cue = myTextItem->toPlainText();
            int index = cue.indexOf("\n");
            cue.truncate(qMin(8, index));
            cue.append(" ...");
            myTextItem->setPlainText(cue);
            myTextItem->setTextInteractionFlags(Qt::TextEditable | Qt::TextSelectableByKeyboard);
        }

    }
    else
    {
        Q_ASSERT(backup != 0);
        myTextItem->setDocument(backup);

        if (!docType == Text)
            myTextItem->setTextInteractionFlags(Qt::NoTextInteraction);

        backup = 0;
    }
    updateBlock();
}
Пример #18
0
void DocBlock::textChanged()
{
    if (docType == Generic) return;

    QString text = myTextItem->toPlainText();

    if (text.isEmpty() && !myTextItem->hasFocus() && docType != Image)
    {
        removeBlock(true);
    }
    else
    {
        if (element->getType() != text)
        {
//            if(!isFolded()) {
//                element->setType(text);
//            }
            group->setModified(true);
            updateBlock(false);
        }
    }
}
Пример #19
0
void DocBlock::addWebLink(QUrl url)
{
    myTextItem->setTextInteractionFlags(Qt::TextSelectableByKeyboard);
    docType = WebLink;

    // add web icon
    QTextCursor cursor = QTextCursor(myTextItem->document());
    cursor.document()->setPlainText(" ");
    cursor.insertImage(QImage(":/weblink.png"));

    path = url.toString();
    QString str = path;

    if (str.lastIndexOf("/") > 7)
        str = str.left(str.lastIndexOf("/"));

    QString html = "<a href=\""+path+"\">"+str+"</a>";
    cursor.insertHtml(html);

    if (arrow != 0)
        arrow->setColor(getHoverColor());

    updateBlock(false);
}
Пример #20
0
void ShadowManager::update(float dt) {
  std::vector<V2F_C4B_T2F_Triangle> triangles[NUM_SHADOW_LAYERS];

  GameLevel::instance().traverseObjects([&](GameObject* block){
    updateBlock(block, triangles[block->getRenderer()->getShadowLayer()]);
  }, true);

  auto cameraPos = GameLevel::instance().getGameLayer()->getCamera()->getPosition();
  for (int i = 0; i < NUM_SHADOW_LAYERS; ++i) {
#if EDITOR_MODE
    mRenderTextures[i]->setPosition(cameraPos - Vec2(0, UI_LAYER_HIGHT / 2));
#else
    mRenderTextures[i]->setPosition(cameraPos);
#endif

    mShadowDrawers[i]->clear();
    if (!triangles[i].empty()) {
      mShadowDrawers[i]->drawTriangles(triangles[i]);
    }
    mRenderTextures[i]->beginWithClear(0, 0, 0, 0);
    mShadowDrawers[i]->visit();
    mRenderTextures[i]->end();
  }
}
Пример #21
0
void Motogame::onReadAvailable()
{
    while (true)
    {
        QByteArray Msg = m_Motogame.readLine();
        if (Msg.size() == 0)
            break;

        MotoWork Work;
        MotoPoW PoW;
        if (motoParseMessage(Msg.data(), Work))
        {
            auto iter = findBlock(Work);
            if (iter != m_Templates.end())
                m_Templates.erase(iter);
        }
        else if (motoParseMessage(Msg.data(), Work, PoW))
        {
            auto iter = findBlock(Work);
            if (iter != m_Templates.end())
            {
                CBlock *pBlock = &(*iter)->block;
                pBlock->Nonce = PoW;
                CheckWork(pBlock, *m_pWallet, m_ReserveKey);
            }
            updateBlock();
        }
        else if (strncmp(Msg.data(), "***Config:*", 11) == 0)
        {
            QString Controls(Msg.data() + 11);
            Controls.remove("\n");
            QSettings settings;
            settings.setValue("GameControls", Controls);
        }
    }
}
Пример #22
0
void TextDocument::removeHighlight(int block)
{
    if (d.highlights.removeOne(block) && block >= 0 && block < totalCount())
        updateBlock(block);
}
Пример #23
0
void erodeBunker(unsigned int* framePointer, int which_bunker){
	int which_block = rand()%8;
	short* bunker;
	int i, j;
	int block_row, block_col;
	switch(which_bunker){ 		// select a bunker that I want to erode
	case 0:
		bunker = getBunker4();
		break;
	case 1:
		bunker = getBunker3();
		break;
	case 2:
		bunker = getBunker2();
		break;
	case 3:
		bunker = getBunker1();
		break;
	default :
		break;
	}

	switch(which_block){ 		// 'block_row, block_col' are used to calculate to find out the position of framePointer
	case 0:
		block_row = 0;
		block_col = 0;
		blankBlock(framePointer, which_bunker, which_block, block_row, block_col);
		updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker);
		break;
	case 1:
		block_row = 0;
		block_col = 1;
		blankBlock(framePointer, which_bunker, which_block, block_row, block_col);
		updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker);

		break;
	case 2  :
		block_row = 0;
		block_col = 2;
		blankBlock(framePointer, which_bunker, which_block, block_row, block_col);
		updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker);

		break;
	case 3  :
		block_row = 1;
		block_col = 0;
		blankBlock(framePointer, which_bunker, which_block, block_row, block_col);
		updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker);

		break;
	case 4  :
		block_row = 1;
		block_col = 1;
		blankBlock(framePointer, which_bunker, which_block, block_row, block_col);
		updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker);

		break;
	case 5  :
		block_row = 1;
		block_col = 2;
		blankBlock(framePointer, which_bunker, which_block, block_row, block_col);
		updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker);

		break;
	case 6  :
		block_row = 2;
		block_col = 0;
		blankBlock(framePointer, which_bunker, which_block, block_row, block_col);
		updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker);

		break;
	case 7  :
		block_row = 2;
		block_col = 2;
		blankBlock(framePointer, which_bunker, which_block, block_row, block_col);
		updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker);

		break;
	default :

		break;
	}

}
Пример #24
0
/*! \reimp
 */
void TextDocumentLayout::documentChanged(int from, int /*charsRemoved*/, int charsAdded)
{
    QTextDocument *doc = document();
    int newBlockCount = doc->blockCount();

    QTextBlock changeStartBlock = doc->findBlock(from);
    QTextBlock changeEndBlock = doc->findBlock(qMax(0, from + charsAdded - 1));

    if (changeStartBlock == changeEndBlock && newBlockCount == d->blockCount) {
        QTextBlock block = changeStartBlock;
        if (block.isValid()  && block.layout()->lineCount()) {
            QRectF oldBr = blockBoundingRect(block);
            layoutBlock(block);
            QRectF newBr = blockBoundingRect(block);
            if (newBr.height() == oldBr.height()) {
                if (!d->blockUpdate)
                    emit updateBlock(block);
                return;
            }
        }
    } else {
        QTextBlock block = changeStartBlock;
        do {
            block.clearLayout();
            if (block == changeEndBlock)
                break;
            block = block.next();
        } while(block.isValid());
    }

    if (newBlockCount != d->blockCount) {

        int changeEnd = changeEndBlock.blockNumber();
        int blockDiff = newBlockCount - d->blockCount;
        int oldChangeEnd = changeEnd - blockDiff;

        if (d->maximumWidthBlockNumber > oldChangeEnd)
            d->maximumWidthBlockNumber += blockDiff;

        d->blockCount = newBlockCount;
        if (d->blockCount == 1)
            d->maximumWidth = blockWidth(doc->firstBlock());

        if (!d->blockDocumentSizeChanged)
            emit documentSizeChanged(documentSize());

        if (blockDiff == 1 && changeEnd == newBlockCount -1 ) {
            if (!d->blockUpdate)
            {
                QTextBlock b = changeStartBlock;
                for(;;) {
                    emit updateBlock(b);
                    if (b == changeEndBlock)
                        break;
                    b = b.next();
                }
            }
            return;
        }
    }
    if (!d->blockUpdate)
        emit update(QRectF(0., -doc->documentMargin(), 1000000000., 1000000000.)); // optimization potential
}
Пример #25
0
void TextDocumentLayout::layoutBlock(const QTextBlock &block)
{
    QTextDocument *doc = document();
    qreal margin = doc->documentMargin();
    qreal blockMaximumWidth = 0;

    qreal height = 0;
    QTextLayout *tl = block.layout();
    QTextOption option = doc->defaultTextOption();
    tl->setTextOption(option);

    int extraMargin = 0;
    if (option.flags() & QTextOption::AddSpaceForLineAndParagraphSeparators) {
        QFontMetrics fm(block.charFormat().font());
        extraMargin += fm.width(QChar(0x21B5));
    }
    tl->beginLayout();
    qreal availableWidth = d->width;
    if (availableWidth <= 0) {
        availableWidth = qreal(INT_MAX); // similar to text edit with pageSize.width == 0
    }
    availableWidth -= 2*margin + extraMargin;
    qreal indentMargin = 0;
    while (1) {
        QTextLine line = tl->createLine();
        if (!line.isValid())
            break;
        line.setLeadingIncluded(true);
        line.setLineWidth(availableWidth - indentMargin);
        line.setPosition(QPointF(margin + indentMargin, height));
        if(!height) //enter only in the first iteration
        {
            indentMargin = indentWidth(block);
        }
        height += line.height();
        blockMaximumWidth = qMax(blockMaximumWidth, line.naturalTextWidth() + 2*margin);
    }
    tl->endLayout();

    int previousLineCount = doc->lineCount();
    const_cast<QTextBlock&>(block).setLineCount(block.isVisible() ? tl->lineCount() : 0);
    int lineCount = doc->lineCount();

    bool emitDocumentSizeChanged = previousLineCount != lineCount;
    if (blockMaximumWidth > d->maximumWidth) {
        // new longest line
        d->maximumWidth = blockMaximumWidth;
        d->maximumWidthBlockNumber = block.blockNumber();
        emitDocumentSizeChanged = true;
    } else if (block.blockNumber() == d->maximumWidthBlockNumber && blockMaximumWidth < d->maximumWidth) {
        // longest line shrinking
        QTextBlock b = doc->firstBlock();
        d->maximumWidth = 0;
        QTextBlock maximumBlock;
        while (b.isValid()) {
            qreal blockMaximumWidth = blockWidth(b);
            if (blockMaximumWidth > d->maximumWidth) {
                d->maximumWidth = blockMaximumWidth;
                maximumBlock = b;
            }
            b = b.next();
        }
        if (maximumBlock.isValid()) {
            d->maximumWidthBlockNumber = maximumBlock.blockNumber();
            emitDocumentSizeChanged = true;
        }
    }
    if (emitDocumentSizeChanged)// && !d->blockDocumentSizeChanged)
        emit documentSizeChanged(documentSize());

    emit updateBlock(block);
}
Пример #26
0
/* Writes SIZE bytes from BUFFER into INODE, starting at OFFSET.
	 Returns the number of bytes actually written, which may be
	 less than SIZE if end of file is reached or an error occurs.
	 (Normally a write at end of file would extend the inode, but
	 growth is not yet implemented.) */
off_t
inode_write_at (struct inode *inode, const void *buffer_, off_t size,
                off_t offset)
{
    const uint8_t *buffer = buffer_;
    off_t bytes_written = 0;
    uint8_t *bounce = NULL;
    /* Debugging */
    bool debug = false;

    if (inode->deny_write_cnt)
        return 0;

    //printf("inode_length : %d\n",inode_length(inode));
    ASSERT(inode->sector <20000);
    //printf("*node[%d]->extension=%d \n", inode->sector, inode->extension);
    while(inode->extension);
    //printf("inode_write_at called size: %d, offset : %d, inode_length : %d\n",size,offset,inode->data.length);
    while (size > 0)
    {
        /* Sector to write, starting byte offset within sector. */
        block_sector_t sector_idx = byte_to_sector (inode, offset);
        int sector_ofs = offset % BLOCK_SECTOR_SIZE;

        /* Bytes left in inode, bytes left in sector, lesser of the two. */
        off_t inode_left = inode_length (inode) - offset;
        int sector_left = BLOCK_SECTOR_SIZE - sector_ofs;
        int min_left = inode_left < sector_left ? inode_left : sector_left;

        /* Number of bytes to actually write into this sector. */
        int chunk_size = size < min_left ? size : min_left;

        struct cache * cache = find_cache(sector_idx);

        //if(debug) printf("sector_idx : %d\n",sector_idx);

        if(offset > inode_length(inode))
        {
            //printf("setting node[%d]->extension=true \n", inode->sector);
            inode->extension = true;
            //printf("You made me true\n");
            int left = (offset - inode_length(inode));
            int i;
            int sectors = (left+1)/BLOCK_SECTOR_SIZE;

            //printf("Offset Over\n");
            block_sector_t new_sector;

            int check = inode_length(inode) + BLOCK_SECTOR_SIZE - inode_length(inode)%512+1;
            inode->data.length += left;
            block_write(fs_device,inode->sector,&(inode->data));

            //printf("offset inode length increase from :%d to %d sector num : %d check : %d\n",inode_length(inode),inode_length(inode)-left,sectors,check);

            for(i=0; i<sectors; i++)
            {
                //printf("check is : %d\n",check);
                if(!free_map_allocate(1,&new_sector))
                {
                    printf("Fail to allocate freemap\n");
                    ASSERT(false);
                }
                updateBlock(inode,check,new_sector);
                //printf("Allocate new Sector : %d\n",new_sector);
                check += BLOCK_SECTOR_SIZE;
            }
            //debug = true;
            continue;
        }
        else if((size >= inode_left - offset) && min_left == 0)
        {
            int sector_num;
            int i;

            //printf("Size Over\n");
            if((size-sector_left+1) <=0)
                sector_num = 0;
            else
                sector_num = bytes_to_sectors((size-sector_left)+1);

            //printf("size : %d , offset : %d, sector_left : %d\n",size,offset,sector_left);
            block_sector_t new_sector;
            int check = inode_length(inode) + sector_left ;
            //printf("setting node[%d]->extension=true \n", inode->sector);
            inode->extension = true;
            //printf("You made me true\n");
            //file_extension(inode,buffer+bytes_written,size);
            inode->data.length = inode->data.length + size;
            block_write(fs_device,inode->sector,&(inode->data));
            //printf("Sector_left : %d\n",sector_left);
            //printf("size inode length increase from :%d to %d now sector num : %d sector_num : %d\n",inode_length(inode),inode_length(inode)-size,sector_idx,sector_num);

            for(i=0; i<sector_num; i++)
            {
                if(!free_map_allocate(1,&new_sector))
                {
                    printf("Freemap Fail\n");
                    ASSERT(false);
                }
                updateBlock(inode,check,new_sector);
                //printf("Allocate new Sector : %d\n",new_sector);
                //	print_table_info(inode);
                check +=BLOCK_SECTOR_SIZE;
            }
            debug = true;
            continue;
        }
        else if(sector_idx == -1)
        {
            print_table_info(inode);
            //printf("offset : %d inode : %#x inode_sector : %d length : %d\n",offset,inode,inode->sector,inode_length(inode));
        }

        if(debug)
        {
        }

        //ASSERT(sector_idx < 20000);
        if (chunk_size <= 0)
            break;
        /*
        			if(debug)
        			{
        				print_table_info(inode);
        			}
        	*/
        //printf("inode read at called chunksize : %d , sector_ofs : %d, sector_idx : %d\n",chunk_size,sector_ofs,sector_idx);
        if(cache == NULL)
        {
            cache = add_cache(sector_idx);

            if(cache == NULL)
            {
                print_table_info(inode);
                printf("read Error\n");
                return bytes_written;
            }
        }
        cache->accessed = true;
        cache->pin = true;
        //if(inode_left - sector_ofs > 512)
        //	read_ahead(sector_idx +1);
        write_cache(cache , buffer+bytes_written , sector_ofs ,chunk_size);
        /* Advance. */
        cache->pin = false;
        size -= chunk_size;
        offset += chunk_size;
        bytes_written += chunk_size;
    } // free (bounce);
    if(inode->extension == true)
    {
        //printf("set node[%d]->extension as false\n", inode->sector);
        inode->extension = false;
        ASSERT(inode->extension==false);
    }
    return bytes_written;
}
Пример #27
0
void Motogame::timerEvent(QTimerEvent*)
{
    updateBlock();
}
Пример #28
0
void DocBlock::updateGeometryAfter(bool doAnimation)
{
    updateBlock(doAnimation);
}