void DragTo(HTREEITEM dstItem, HTREEITEM srcItem) { PROJECTITEM *srcData = GetItemInfo(srcItem); PROJECTITEM *dstData = GetItemInfo(dstItem); if (srcData && dstData && srcData->parent != dstData) { PROJECTITEM *p = dstData->parent; while(p) if (p == srcData) return; else p = p->parent; if (srcData->type == PJ_FOLDER || srcData->type == PJ_FILE) { if (dstData->type == PJ_FOLDER || dstData->type == PJ_PROJ) { PROJECTITEM **rmv = &srcData->parent->children; MarkChanged(srcData,FALSE); while (*rmv && *rmv != srcData) rmv = &(*rmv)->next; if (*rmv) { PROJECTITEM **ins = &dstData->children; HTREEITEM pos = TVI_FIRST; (*rmv) = (*rmv)->next; TreeView_DeleteItem(prjTreeWindow, srcData->hTreeItem); ResDeleteItem(srcData); if (srcData->type == PJ_FILE) { while (*ins && (*ins)->type == PJ_FOLDER) { pos = (*ins)->hTreeItem; ins = &(*ins)->next; } } while (*ins && (*ins)->type == srcData->type && stricmp((*ins)->displayName, srcData->displayName) < 0) { pos = (*ins)->hTreeItem; ins = &(*ins)->next; } srcData->parent = dstData; srcData->next = NULL; RecursiveCreateTree(dstData->hTreeItem, pos, srcData); srcData->next = *ins; *ins = srcData; MarkChanged(srcData,FALSE); } } } } }
void DrawTargetSkia::MaskSurface(const Pattern &aSource, SourceSurface *aMask, Point aOffset, const DrawOptions &aOptions) { MarkChanged(); AutoPaintSetup paint(mCanvas.get(), aOptions, aSource); SkPaint maskPaint; TempBitmap tmpBitmap; SetPaintPattern(maskPaint, SurfacePattern(aMask, ExtendMode::CLAMP), tmpBitmap); SkMatrix transform = maskPaint.getShader()->getLocalMatrix(); transform.postTranslate(SkFloatToScalar(aOffset.x), SkFloatToScalar(aOffset.y)); maskPaint.getShader()->setLocalMatrix(transform); SkLayerRasterizer *raster = new SkLayerRasterizer(); raster->addLayer(maskPaint); SkSafeUnref(paint.mPaint.setRasterizer(raster)); IntSize size = aMask->GetSize(); Rect rect = Rect(aOffset.x, aOffset.y, size.width, size.height); mCanvas->drawRect(RectToSkRect(rect), paint.mPaint); }
/********************\ ** ProcessSingles *********************************************\ ** ** ** ProcessSingles takes a naked single and marks each cell ** ** in the 3 associated groups as not allowing that number. ** ** It also marks the groups as changed so we know to check ** ** for hidden singles in that group. ** ** ** ** This routines marks cells changed as each single is ** ** processed. ** ** ** \****************************************************************/ static void ProcessSingles (void) { int i, t, g, t2; register unsigned int b; for (i = 0; i < SingleCnt; i++) { t = SinglePos[i]; // Get local copy of position b = SingleVal[i]; // Get local copy of the value if (Gp->Grid[t] == 0) continue; // Check if we already processed this position if (!(Gp->Grid[t] & b)) // Check for error conditions { No_Sol = 1; SingleCnt = Changed = 0; return; } SolGrid[t] = b; // Store the single in the solution grid Gp->CellsLeft--; // mark one less empty space Gp->Grid[t] = 0; // mark this position processed for (g = 0; g < 3; g++) // loop through all 3 groups Gp->Grp[C2Grp[t][g]] |= b; // mark the value as found in the group for (g = 0; g < 20; g++) // loop through each cell in the groups { t2 = (int)In_Groups[t][g]; // get temp copy of position if (Gp->Grid[t2] & b) // check if removing a possibility { Gp->Grid[t2] = Gp->Grid[t2] ^ b; // remove possibility if (Gp->Grid[t2] == 0) // check for error (no possibility) { No_Sol = 1; SingleCnt = 0; Changed = 0; return; } if (B2V[Gp->Grid[t2]]) // Check if a naked single is found PushSingle(t2, Gp->Grid[t2]); MarkChanged(t2); // Mark groups as changed } } } SingleCnt = 0; // Clear the single count }
void DrawTargetSkia::CopySurface(SourceSurface *aSurface, const IntRect& aSourceRect, const IntPoint &aDestination) { //TODO: We could just use writePixels() here if the sourceRect is the entire source if (aSurface->GetType() != SurfaceType::SKIA) { return; } MarkChanged(); TempBitmap bitmap = GetBitmapForSurface(aSurface); mCanvas->save(); mCanvas->resetMatrix(); SkRect dest = IntRectToSkRect(IntRect(aDestination.x, aDestination.y, aSourceRect.width, aSourceRect.height)); SkIRect source = IntRectToSkIRect(aSourceRect); mCanvas->clipRect(dest, SkRegion::kReplace_Op); SkPaint paint; if (mCanvas->getDevice()->config() == SkBitmap::kRGB_565_Config) { // Set the xfermode to SOURCE_OVER to workaround // http://code.google.com/p/skia/issues/detail?id=628 // RGB565 is opaque so they're equivalent anyway paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); } else { paint.setXfermodeMode(SkXfermode::kSrc_Mode); } mCanvas->drawBitmapRect(bitmap.mBitmap, &source, dest, &paint); mCanvas->restore(); }
void DrawTargetSkia::FillGlyphs(ScaledFont *aFont, const GlyphBuffer &aBuffer, const Pattern &aPattern, const DrawOptions &aOptions, const GlyphRenderingOptions*) { if (aFont->GetType() != FONT_MAC && aFont->GetType() != FONT_SKIA && aFont->GetType() != FONT_GDI) { return; } MarkChanged(); ScaledFontBase* skiaFont = static_cast<ScaledFontBase*>(aFont); AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern); paint.mPaint.setTypeface(skiaFont->GetSkTypeface()); paint.mPaint.setTextSize(SkFloatToScalar(skiaFont->mSize)); paint.mPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); std::vector<uint16_t> indices; std::vector<SkPoint> offsets; indices.resize(aBuffer.mNumGlyphs); offsets.resize(aBuffer.mNumGlyphs); for (unsigned int i = 0; i < aBuffer.mNumGlyphs; i++) { indices[i] = aBuffer.mGlyphs[i].mIndex; offsets[i].fX = SkFloatToScalar(aBuffer.mGlyphs[i].mPosition.x); offsets[i].fY = SkFloatToScalar(aBuffer.mGlyphs[i].mPosition.y); } mCanvas->drawPosText(&indices.front(), aBuffer.mNumGlyphs*2, &offsets.front(), paint.mPaint); }
void DrawTargetSkia::DrawSurfaceWithShadow(SourceSurface *aSurface, const Point &aDest, const Color &aColor, const Point &aOffset, Float aSigma, CompositionOp aOperator) { if (!(aSurface->GetType() == SurfaceType::SKIA || aSurface->GetType() == SurfaceType::DATA)) { return; } MarkChanged(); mCanvas->save(SkCanvas::kMatrix_SaveFlag); mCanvas->resetMatrix(); TempBitmap bitmap = GetBitmapForSurface(aSurface); SkPaint paint; SkImageFilter* filter = SkDropShadowImageFilter::Create(aOffset.x, aOffset.y, aSigma, ColorToSkColor(aColor, 1.0)); paint.setImageFilter(filter); paint.setXfermodeMode(GfxOpToSkiaOp(aOperator)); mCanvas->drawBitmap(bitmap.mBitmap, aDest.x, aDest.y, &paint); mCanvas->restore(); }
bool WaveTrack::Copy(double t0, double t1, Track **dest) { if (t1 < t0) return false; sampleCount s0, s1; TimeToSamplesClip(t0, &s0); TimeToSamplesClip(t1, &s1); WaveTrack *newTrack = new WaveTrack(mDirManager); newTrack->Init(*this); delete newTrack->mSequence; newTrack->mSequence = NULL; if (!mSequence->Copy(s0, s1, &newTrack->mSequence)) { // Error *dest = NULL; delete newTrack; return false; } newTrack->GetEnvelope()->CopyFrom(GetEnvelope(), t0, t1); *dest = newTrack; MarkChanged(); return true; }
bool WaveTrack::Cut(double t0, double t1, Track **dest) { bool success; sampleCount s0, s1; WaveTrack *newTrack; if (t1 < t0) return false; TimeToSamplesClip(t0, &s0); TimeToSamplesClip(t1, &s1); newTrack = new WaveTrack(mDirManager); delete newTrack->mSequence; newTrack->mSequence = NULL; success = mSequence->Copy(s0, s1, &newTrack->mSequence); if (success) success = mSequence->Delete(s0, s1-s0); if (!success) { *dest = NULL; delete newTrack; return false; } newTrack->GetEnvelope()->CopyFrom(GetEnvelope(), t0, t1); mEnvelope->CollapseRegion(t0, t1); *dest = newTrack; MarkChanged(); return true; }
void DrawTargetSkia::DrawSurface(SourceSurface *aSurface, const Rect &aDest, const Rect &aSource, const DrawSurfaceOptions &aSurfOptions, const DrawOptions &aOptions) { if (!(aSurface->GetType() == SurfaceType::SKIA || aSurface->GetType() == SurfaceType::DATA)) { return; } if (aSource.IsEmpty()) { return; } MarkChanged(); SkRect destRect = RectToSkRect(aDest); SkRect sourceRect = RectToSkRect(aSource); TempBitmap bitmap = GetBitmapForSurface(aSurface); AutoPaintSetup paint(mCanvas.get(), aOptions); if (aSurfOptions.mFilter == Filter::POINT) { paint.mPaint.setFilterBitmap(false); } mCanvas->drawBitmapRectToRect(bitmap.mBitmap, &sourceRect, destRect, &paint.mPaint); }
bool WaveClip::SetSamples(samplePtr buffer, sampleFormat format, sampleCount start, sampleCount len) { bool bResult = mSequence->Set(buffer, format, start, len); MarkChanged(); return bResult; }
void DrawTargetSkia::MaskSurface(const Pattern &aSource, SourceSurface *aMask, Point aOffset, const DrawOptions &aOptions) { MarkChanged(); AutoPaintSetup paint(mCanvas.get(), aOptions, aSource); TempBitmap bitmap = GetBitmapForSurface(aMask); if (bitmap.mBitmap.colorType() == kAlpha_8_SkColorType) { mCanvas->drawBitmap(bitmap.mBitmap, aOffset.x, aOffset.y, &paint.mPaint); } else { SkPaint maskPaint; TempBitmap tmpBitmap; SetPaintPattern(maskPaint, SurfacePattern(aMask, ExtendMode::CLAMP), tmpBitmap); SkMatrix transform = maskPaint.getShader()->getLocalMatrix(); transform.postTranslate(SkFloatToScalar(aOffset.x), SkFloatToScalar(aOffset.y)); maskPaint.getShader()->setLocalMatrix(transform); SkLayerRasterizer::Builder builder; builder.addLayer(maskPaint); SkAutoTUnref<SkRasterizer> raster(builder.detachRasterizer()); paint.mPaint.setRasterizer(raster.get()); IntSize size = aMask->GetSize(); Rect rect = Rect(aOffset.x, aOffset.y, size.width, size.height); mCanvas->drawRect(RectToSkRect(rect), paint.mPaint); } }
void DrawTargetSkia::Mask(const Pattern &aSource, const Pattern &aMask, const DrawOptions &aOptions) { MarkChanged(); AutoPaintSetup paint(mCanvas.get(), aOptions, aSource); SkPaint maskPaint; SetPaintPattern(maskPaint, aMask); SkLayerRasterizer *raster = new SkLayerRasterizer(); raster->addLayer(maskPaint); SkSafeUnref(paint.mPaint.setRasterizer(raster)); // Skia only uses the mask rasterizer when we are drawing a path/rect. // Take our destination bounds and convert them into user space to use // as the path to draw. SkPath path; path.addRect(SkRect::MakeWH(SkScalar(mSize.width), SkScalar(mSize.height))); Matrix temp = mTransform; temp.Invert(); SkMatrix mat; GfxMatrixToSkiaMatrix(temp, mat); path.transform(mat); mCanvas->drawPath(path, paint.mPaint); }
void DrawTargetSkia::DrawSurface(SourceSurface *aSurface, const Rect &aDest, const Rect &aSource, const DrawSurfaceOptions &aSurfOptions, const DrawOptions &aOptions) { if (aSurface->GetType() != SURFACE_SKIA) { return; } if (aSource.IsEmpty()) { return; } MarkChanged(); SkRect destRect = RectToSkRect(aDest); SkRect sourceRect = RectToSkRect(aSource); SkMatrix matrix; matrix.setRectToRect(sourceRect, destRect, SkMatrix::kFill_ScaleToFit); const SkBitmap& bitmap = static_cast<SourceSurfaceSkia*>(aSurface)->GetBitmap(); AutoPaintSetup paint(mCanvas.get(), aOptions); SkShader *shader = SkShader::CreateBitmapShader(bitmap, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode); shader->setLocalMatrix(matrix); SkSafeUnref(paint.mPaint.setShader(shader)); if (aSurfOptions.mFilter != FILTER_LINEAR) { paint.mPaint.setFilterBitmap(false); } mCanvas->drawRect(destRect, paint.mPaint); }
static BOOL SoftwareDirectories_OnDelete(HWND hDlg) { int nCount; int nSelect; int nItem; HWND hList = GetDlgItem(hDlg, IDC_DIR_LIST); BOOL res; g_bModifiedSoftwarePaths = TRUE; nItem = ListView_GetNextItem(hList, -1, LVNI_SELECTED | LVNI_ALL); if (nItem == -1) return FALSE; /* Don't delete "Append" placeholder. */ if (nItem == ListView_GetItemCount(hList) - 1) return FALSE; res = ListView_DeleteItem(hList, nItem); nCount = ListView_GetItemCount(hList); if (nCount <= 1) return FALSE; /* If the last item was removed, select the item above. */ if (nItem == nCount - 1) nSelect = nCount - 2; else nSelect = nItem; ListView_SetItemState(hList, nSelect, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED); MarkChanged(hDlg); return TRUE; }
void WaveClip::ConvertToSampleFormat(sampleFormat format) { bool bChanged; bool bResult = mSequence->ConvertToSampleFormat(format, &bChanged); if (bResult && bChanged) MarkChanged(); wxASSERT(bResult); // TODO: Throw an actual error. }
void cTexturedQuadFactory::AddReference(cQuadInfo& info) { AKJ_ASSERT(info.mReferences >= 0); if(++info.mReferences == 1) { MarkChanged(info); } }
bool WaveClip::Clear(double t0, double t1) { sampleCount s0, s1; TimeToSamplesClip(t0, &s0); TimeToSamplesClip(t1, &s1); if (GetSequence()->Delete(s0, s1-s0)) { // msmeyer // // Delete all cutlines that are within the given area, if any. // // Note that when cutlines are active, two functions are used: // Clear() and ClearAndAddCutLine(). ClearAndAddCutLine() is called // whenever the user directly calls a command that removes some audio, e.g. // "Cut" or "Clear" from the menu. This command takes care about recursive // preserving of cutlines within clips. Clear() is called when internal // operations want to remove audio. In the latter case, it is the right // thing to just remove all cutlines within the area. // double clip_t0 = t0; double clip_t1 = t1; if (clip_t0 < GetStartTime()) clip_t0 = GetStartTime(); if (clip_t1 > GetEndTime()) clip_t1 = GetEndTime(); WaveClipList::compatibility_iterator nextIt; for (WaveClipList::compatibility_iterator it = mCutLines.GetFirst(); it; it=nextIt) { nextIt = it->GetNext(); WaveClip* clip = it->GetData(); double cutlinePosition = mOffset + clip->GetOffset(); if (cutlinePosition >= t0 && cutlinePosition <= t1) { // This cutline is within the area, delete it delete clip; mCutLines.DeleteNode(it); } else if (cutlinePosition >= t1) { clip->Offset(clip_t0-clip_t1); } } // Collapse envelope GetEnvelope()->CollapseRegion(t0, t1); if (t0 < GetStartTime()) Offset(-(GetStartTime() - t0)); MarkChanged(); return true; } return false; }
void DrawTargetSkia::FillGlyphs(ScaledFont *aFont, const GlyphBuffer &aBuffer, const Pattern &aPattern, const DrawOptions &aOptions, const GlyphRenderingOptions *aRenderingOptions) { if (aFont->GetType() != FontType::MAC && aFont->GetType() != FontType::SKIA && aFont->GetType() != FontType::GDI) { return; } MarkChanged(); ScaledFontBase* skiaFont = static_cast<ScaledFontBase*>(aFont); AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern); paint.mPaint.setTypeface(skiaFont->GetSkTypeface()); paint.mPaint.setTextSize(SkFloatToScalar(skiaFont->mSize)); paint.mPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); if (aRenderingOptions && aRenderingOptions->GetType() == FontType::CAIRO) { switch (static_cast<const GlyphRenderingOptionsCairo*>(aRenderingOptions)->GetHinting()) { case FontHinting::NONE: paint.mPaint.setHinting(SkPaint::kNo_Hinting); break; case FontHinting::LIGHT: paint.mPaint.setHinting(SkPaint::kSlight_Hinting); break; case FontHinting::NORMAL: paint.mPaint.setHinting(SkPaint::kNormal_Hinting); break; case FontHinting::FULL: paint.mPaint.setHinting(SkPaint::kFull_Hinting); break; } if (static_cast<const GlyphRenderingOptionsCairo*>(aRenderingOptions)->GetAutoHinting()) { paint.mPaint.setAutohinted(true); } } else { paint.mPaint.setHinting(SkPaint::kNormal_Hinting); } std::vector<uint16_t> indices; std::vector<SkPoint> offsets; indices.resize(aBuffer.mNumGlyphs); offsets.resize(aBuffer.mNumGlyphs); for (unsigned int i = 0; i < aBuffer.mNumGlyphs; i++) { indices[i] = aBuffer.mGlyphs[i].mIndex; offsets[i].fX = SkFloatToScalar(aBuffer.mGlyphs[i].mPosition.x); offsets[i].fY = SkFloatToScalar(aBuffer.mGlyphs[i].mPosition.y); } mCanvas->drawPosText(&indices.front(), aBuffer.mNumGlyphs*2, &offsets.front(), paint.mPaint); }
void DrawTargetD2D1::ClearRect(const Rect &aRect) { MarkChanged(); mDC->PushAxisAlignedClip(D2DRect(aRect), D2D1_ANTIALIAS_MODE_PER_PRIMITIVE); mDC->Clear(); mDC->PopAxisAlignedClip(); }
bool WaveClip::Paste(double t0, WaveClip* other) { WaveClip* pastedClip; bool clipNeedsResampling = other->mRate != mRate; if (clipNeedsResampling) { // The other clip's rate is different to our's, so resample pastedClip = new WaveClip(*other, mSequence->GetDirManager()); if (!pastedClip->Resample(mRate)) { delete pastedClip; return false; } } else { // No resampling needed, just use original clip without making a copy pastedClip = other; } sampleCount s0; TimeToSamplesClip(t0, &s0); // Force sample formats to match. if (pastedClip->mSequence->GetSampleFormat() != mSequence->GetSampleFormat()) pastedClip->ConvertToSampleFormat(mSequence->GetSampleFormat()); bool result = false; if (mSequence->Paste(s0, pastedClip->mSequence)) { MarkChanged(); mEnvelope->Paste((double)s0/mRate + mOffset, pastedClip->mEnvelope); mEnvelope->RemoveUnneededPoints(); OffsetCutLines(t0, pastedClip->GetEndTime() - pastedClip->GetStartTime()); // Paste cut lines contained in pasted clip for (WaveClipList::compatibility_iterator it = pastedClip->mCutLines.GetFirst(); it; it=it->GetNext()) { WaveClip* cutline = it->GetData(); WaveClip* newCutLine = new WaveClip(*cutline, mSequence->GetDirManager()); newCutLine->Offset(t0 - mOffset); mCutLines.Append(newCutLine); } result = true; } if (clipNeedsResampling) { // Clip was constructed as a copy, so delete it delete pastedClip; } return result; }
void DrawTargetSkia::CopySurface(SourceSurface *aSurface, const IntRect& aSourceRect, const IntPoint &aDestination) { //TODO: We could just use writePixels() here if the sourceRect is the entire source if (aSurface->GetType() != SurfaceType::SKIA && aSurface->GetType() != SurfaceType::DATA) { return; } MarkChanged(); TempBitmap bitmap = GetBitmapForSurface(aSurface); // This is a fast path that is disabled for now to mimimize risk if (false && !bitmap.mBitmap.getTexture() && mCanvas->getDevice()->config() == bitmap.mBitmap.config()) { SkBitmap bm(bitmap.mBitmap); bm.lockPixels(); if (bm.getPixels()) { SkImageInfo info = bm.info(); info.fWidth = aSourceRect.width; info.fHeight = aSourceRect.height; uint8_t* pixels = static_cast<uint8_t*>(bm.getPixels()); // adjust pixels for the source offset pixels += aSourceRect.x + aSourceRect.y*bm.rowBytes(); mCanvas->writePixels(info, pixels, bm.rowBytes(), aDestination.x, aDestination.y); return; } } mCanvas->save(); mCanvas->resetMatrix(); SkRect dest = IntRectToSkRect(IntRect(aDestination.x, aDestination.y, aSourceRect.width, aSourceRect.height)); SkIRect source = IntRectToSkIRect(aSourceRect); mCanvas->clipRect(dest, SkRegion::kReplace_Op); SkPaint paint; if (mCanvas->getDevice()->config() == SkBitmap::kRGB_565_Config) { // Set the xfermode to SOURCE_OVER to workaround // http://code.google.com/p/skia/issues/detail?id=628 // RGB565 is opaque so they're equivalent anyway paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); } else { paint.setXfermodeMode(SkXfermode::kSrc_Mode); } // drawBitmapRect with A8 bitmaps ends up doing a mask operation // so we need to clear before if (bitmap.mBitmap.config() == SkBitmap::kA8_Config) { SkPaint clearPaint; clearPaint.setColor(SkColorSetARGB(0, 0, 0, 0)); clearPaint.setXfermodeMode(SkXfermode::kSrc_Mode); mCanvas->drawPaint(clearPaint); } mCanvas->drawBitmapRect(bitmap.mBitmap, &source, dest, &paint); mCanvas->restore(); }
bool WaveTrack::AppendAlias(wxString fName, sampleCount start, sampleCount len, int channel) { MarkChanged(); bool ret=mSequence->AppendAlias(fName, start, len, channel); if(ret==true) mEnvelope->SetTrackLen(mSequence->GetNumSamples() / mRate); return ret; }
bool WaveClip::AppendCoded(wxString fName, sampleCount start, sampleCount len, int channel, int decodeType) { bool result = mSequence->AppendCoded(fName, start, len, channel, decodeType); if (result) { UpdateEnvelopeTrackLen(); MarkChanged(); } return result; }
void DrawTargetSkia::FillRect(const Rect &aRect, const Pattern &aPattern, const DrawOptions &aOptions) { MarkChanged(); SkRect rect = RectToSkRect(aRect); AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern, &aRect); mCanvas->drawRect(rect, paint.mPaint); }
bool WaveClip::AppendAlias(wxString fName, sampleCount start, sampleCount len, int channel,bool useOD) { bool result = mSequence->AppendAlias(fName, start, len, channel,useOD); if (result) { UpdateEnvelopeTrackLen(); MarkChanged(); } return result; }
void DrawTargetSkia::ClearRect(const Rect &aRect) { MarkChanged(); SkPaint paint; mCanvas->save(); mCanvas->clipRect(RectToSkRect(aRect), SkRegion::kIntersect_Op, true); paint.setColor(SkColorSetARGB(0, 0, 0, 0)); paint.setXfermodeMode(SkXfermode::kSrc_Mode); mCanvas->drawPaint(paint); mCanvas->restore(); }
bool WaveTrack::Silence(double t0, double t1) { sampleCount s0, s1; if (t1 < t0) return false; TimeToSamplesClip(t0, &s0); TimeToSamplesClip(t1, &s1); MarkChanged(); return mSequence->SetSilence(s0, s1-s0); }
bool WaveClip::Append(samplePtr buffer, sampleFormat format, sampleCount len, unsigned int stride /* = 1 */, XMLWriter* blockFileLog /*=NULL*/) { //wxLogDebug(wxT("Append: len=%i"), len); sampleCount maxBlockSize = mSequence->GetMaxBlockSize(); sampleCount blockSize = mSequence->GetIdealAppendLen(); sampleFormat seqFormat = mSequence->GetSampleFormat(); if (!mAppendBuffer) mAppendBuffer = NewSamples(maxBlockSize, seqFormat); for(;;) { if (mAppendBufferLen >= blockSize) { bool success = mSequence->Append(mAppendBuffer, seqFormat, blockSize, blockFileLog); if (!success) return false; memmove(mAppendBuffer, mAppendBuffer + blockSize * SAMPLE_SIZE(seqFormat), (mAppendBufferLen - blockSize) * SAMPLE_SIZE(seqFormat)); mAppendBufferLen -= blockSize; blockSize = mSequence->GetIdealAppendLen(); } if (len == 0) break; int toCopy = maxBlockSize - mAppendBufferLen; if (toCopy > len) toCopy = len; CopySamples(buffer, format, mAppendBuffer + mAppendBufferLen * SAMPLE_SIZE(seqFormat), seqFormat, toCopy, true, // high quality stride); mAppendBufferLen += toCopy; buffer += toCopy * SAMPLE_SIZE(format) * stride; len -= toCopy; } UpdateEnvelopeTrackLen(); MarkChanged(); return true; }
/************************\ ** ProcessInitSingles *****************************************\ ** ** ** ProcessInitSingles takes a naked single and marks each ** ** cell in the 3 associated groups as not allowing that ** ** number. It also marks the groups as changed so we know ** ** to check for hidden singles in that group. ** ** ** ** This routines marks all the groups first, then marks the ** ** cells for each changed groups. ** ** ** \****************************************************************/ static void ProcessInitSingles (void) { register unsigned char const *ucp; register int i, t, g, t2, j; unsigned int b; while (SingleCnt > 2) { for (i = 0; i < SingleCnt; i++){ t = SinglePos[i]; // Get local copy of position b = SingleVal[i]; // Get local copy of the value if (Gp->Grid[t] == 0) continue; // Check if we already processed this position if (!(Gp->Grid[t] & b)) { // Check for error conditions No_Sol = 1; SingleCnt = Changed = 0; return; } SolGrid[t] = b; // Store the single in the solution grid Gp->CellsLeft--; // mark one less empty space Gp->Grid[t] = 0; // mark this position processed ucp = C2Grp[t]; for (g = 0; g < 3; g++) { // loop through all 3 groups if (Gp->Grp[*(ucp++)] & b) { No_Sol = 1; SingleCnt = Changed = 0; return; } Gp->Grp[C2Grp[t][g]] |= b; // mark the value as found in the group SingleGroup[C2Grp[t][g]] = 1; } } SingleCnt = 0; for (i = 0; i < 27; i++) if (SingleGroup[i]) { SingleGroup[i] = 0; for (j = 0; j < 9; j++) { t2 = Group[i][j]; // get temp copy of position b = Gp->Grp[i]; if (Gp->Grid[t2] & b) { // check if removing a possibility Gp->Grid[t2] = Gp->Grid[t2] & ~b; // remove possibility if (Gp->Grid[t2] == 0) { // check for error (no possibility) No_Sol = 1; SingleCnt = 0; Changed = 0; return; } if (B2V[Gp->Grid[t2]]) // Check if a naked single is found PushSingle(t2, Gp->Grid[t2]); MarkChanged(t2); // Mark groups as changed } } } } }
void DrawTargetSkia::StrokeRect(const Rect &aRect, const Pattern &aPattern, const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions) { MarkChanged(); AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern); if (!StrokeOptionsToPaint(paint.mPaint, aStrokeOptions)) { return; } mCanvas->drawRect(RectToSkRect(aRect), paint.mPaint); }