diff options
Diffstat (limited to 'vcl/source/bitmap/BitmapWriteAccess.cxx')
| -rw-r--r-- | vcl/source/bitmap/BitmapWriteAccess.cxx | 397 |
1 files changed, 397 insertions, 0 deletions
diff --git a/vcl/source/bitmap/BitmapWriteAccess.cxx b/vcl/source/bitmap/BitmapWriteAccess.cxx new file mode 100644 index 000000000..c7fb31cc1 --- /dev/null +++ b/vcl/source/bitmap/BitmapWriteAccess.cxx @@ -0,0 +1,397 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <sal/config.h> +#include <sal/log.hxx> +#include <tools/debug.hxx> + +#include <bitmap/BitmapWriteAccess.hxx> +#include <bitmap/bmpfast.hxx> + +BitmapWriteAccess::BitmapWriteAccess(Bitmap& rBitmap) + : BitmapReadAccess(rBitmap, BitmapAccessMode::Write) +{ +} + +BitmapWriteAccess::~BitmapWriteAccess() {} + +void BitmapWriteAccess::CopyScanline(tools::Long nY, const BitmapReadAccess& rReadAcc) +{ + assert(nY >= 0 && nY < mpBuffer->mnHeight && "y-coordinate in destination out of range!"); + SAL_WARN_IF(nY >= rReadAcc.Height(), "vcl", "y-coordinate in source out of range!"); + SAL_WARN_IF((!HasPalette() || !rReadAcc.HasPalette()) + && (HasPalette() || rReadAcc.HasPalette()), + "vcl", "No copying possible between palette bitmap and TC bitmap!"); + + if ((GetScanlineFormat() == rReadAcc.GetScanlineFormat()) + && (GetScanlineSize() >= rReadAcc.GetScanlineSize())) + { + memcpy(GetScanline(nY), rReadAcc.GetScanline(nY), rReadAcc.GetScanlineSize()); + } + else + { + tools::Long nWidth = std::min(mpBuffer->mnWidth, rReadAcc.Width()); + if (!ImplFastCopyScanline(nY, *ImplGetBitmapBuffer(), *rReadAcc.ImplGetBitmapBuffer())) + { + Scanline pScanline = GetScanline(nY); + Scanline pScanlineRead = rReadAcc.GetScanline(nY); + for (tools::Long nX = 0; nX < nWidth; nX++) + SetPixelOnData(pScanline, nX, rReadAcc.GetPixelFromData(pScanlineRead, nX)); + } + } +} + +void BitmapWriteAccess::CopyScanline(tools::Long nY, ConstScanline aSrcScanline, + ScanlineFormat nSrcScanlineFormat, sal_uInt32 nSrcScanlineSize) +{ + const ScanlineFormat nFormat = RemoveScanline(nSrcScanlineFormat); + + assert(nY >= 0 && nY < mpBuffer->mnHeight && "y-coordinate in destination out of range!"); + DBG_ASSERT((HasPalette() && nFormat <= ScanlineFormat::N8BitPal) + || (!HasPalette() && nFormat > ScanlineFormat::N8BitPal), + "No copying possible between palette and non palette scanlines!"); + + const sal_uInt32 nCount = std::min(GetScanlineSize(), nSrcScanlineSize); + + if (!nCount) + return; + + if (GetScanlineFormat() == RemoveScanline(nSrcScanlineFormat)) + memcpy(GetScanline(nY), aSrcScanline, nCount); + else + { + if (ImplFastCopyScanline(nY, *ImplGetBitmapBuffer(), aSrcScanline, nSrcScanlineFormat, + nSrcScanlineSize)) + return; + + DBG_ASSERT(nFormat != ScanlineFormat::N32BitTcMask, + "No support for pixel formats with color masks yet!"); + FncGetPixel pFncGetPixel; + switch (nFormat) + { + case ScanlineFormat::N1BitMsbPal: + pFncGetPixel = GetPixelForN1BitMsbPal; + break; + case ScanlineFormat::N1BitLsbPal: + pFncGetPixel = GetPixelForN1BitLsbPal; + break; + case ScanlineFormat::N8BitPal: + pFncGetPixel = GetPixelForN8BitPal; + break; + case ScanlineFormat::N24BitTcBgr: + pFncGetPixel = GetPixelForN24BitTcBgr; + break; + case ScanlineFormat::N24BitTcRgb: + pFncGetPixel = GetPixelForN24BitTcRgb; + break; + case ScanlineFormat::N32BitTcAbgr: + if (Bitmap32IsPreMultipled()) + pFncGetPixel = GetPixelForN32BitTcAbgr; + else + pFncGetPixel = GetPixelForN32BitTcXbgr; + break; + case ScanlineFormat::N32BitTcArgb: + if (Bitmap32IsPreMultipled()) + pFncGetPixel = GetPixelForN32BitTcArgb; + else + pFncGetPixel = GetPixelForN32BitTcXrgb; + break; + case ScanlineFormat::N32BitTcBgra: + if (Bitmap32IsPreMultipled()) + pFncGetPixel = GetPixelForN32BitTcBgra; + else + pFncGetPixel = GetPixelForN32BitTcBgrx; + break; + case ScanlineFormat::N32BitTcRgba: + if (Bitmap32IsPreMultipled()) + pFncGetPixel = GetPixelForN32BitTcRgba; + else + pFncGetPixel = GetPixelForN32BitTcRgbx; + break; + case ScanlineFormat::N32BitTcMask: + pFncGetPixel = GetPixelForN32BitTcMask; + break; + + default: + assert(false); + pFncGetPixel = nullptr; + break; + } + + if (pFncGetPixel) + { + const ColorMask aDummyMask; + Scanline pScanline = GetScanline(nY); + for (tools::Long nX = 0, nWidth = mpBuffer->mnWidth; nX < nWidth; ++nX) + SetPixelOnData(pScanline, nX, pFncGetPixel(aSrcScanline, nX, aDummyMask)); + } + } +} + +void BitmapWriteAccess::SetLineColor(const Color& rColor) +{ + if (rColor.GetAlpha() == 0) + { + mpLineColor.reset(); + } + else + { + if (HasPalette()) + { + mpLineColor = BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rColor))); + } + else + { + mpLineColor = BitmapColor(rColor); + } + } +} + +void BitmapWriteAccess::SetFillColor() { mpFillColor.reset(); } + +void BitmapWriteAccess::SetFillColor(const Color& rColor) +{ + if (rColor.GetAlpha() == 0) + { + mpFillColor.reset(); + } + else + { + if (HasPalette()) + { + mpFillColor = BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rColor))); + } + else + { + mpFillColor = BitmapColor(rColor); + } + } +} + +void BitmapWriteAccess::Erase(const Color& rColor) +{ + // convert the color format from RGB to palette index if needed + // TODO: provide and use Erase( BitmapColor& method) + BitmapColor aColor = rColor; + if (HasPalette()) + { + aColor = BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rColor))); + } + + // try fast bitmap method first + if (ImplFastEraseBitmap(*mpBuffer, aColor)) + return; + + tools::Rectangle aRect(Point(), maBitmap.GetSizePixel()); + if (aRect.IsEmpty()) + return; + // clear the bitmap by filling the first line pixel by pixel, + // then dup the first line over each other line + Scanline pFirstScanline = GetScanline(0); + const tools::Long nEndX = aRect.Right(); + for (tools::Long nX = 0; nX <= nEndX; ++nX) + SetPixelOnData(pFirstScanline, nX, rColor); + const auto nScanlineSize = GetScanlineSize(); + const tools::Long nEndY = aRect.Bottom(); + for (tools::Long nY = 1; nY <= nEndY; nY++) + { + Scanline pDestScanline = GetScanline(nY); + memcpy(pDestScanline, pFirstScanline, nScanlineSize); + } +} + +void BitmapWriteAccess::DrawLine(const Point& rStart, const Point& rEnd) +{ + if (!mpLineColor) + return; + + const BitmapColor& rLineColor = *mpLineColor; + tools::Long nX, nY; + + if (rStart.X() == rEnd.X()) + { + // Vertical Line + const tools::Long nEndY = rEnd.Y(); + + nX = rStart.X(); + nY = rStart.Y(); + + if (nEndY > nY) + { + for (; nY <= nEndY; nY++) + SetPixel(nY, nX, rLineColor); + } + else + { + for (; nY >= nEndY; nY--) + SetPixel(nY, nX, rLineColor); + } + } + else if (rStart.Y() == rEnd.Y()) + { + // Horizontal Line + const tools::Long nEndX = rEnd.X(); + + nX = rStart.X(); + nY = rStart.Y(); + + if (nEndX > nX) + { + for (; nX <= nEndX; nX++) + SetPixel(nY, nX, rLineColor); + } + else + { + for (; nX >= nEndX; nX--) + SetPixel(nY, nX, rLineColor); + } + } + else + { + const tools::Long nDX = std::abs(rEnd.X() - rStart.X()); + const tools::Long nDY = std::abs(rEnd.Y() - rStart.Y()); + tools::Long nX1; + tools::Long nY1; + tools::Long nX2; + tools::Long nY2; + + if (nDX >= nDY) + { + if (rStart.X() < rEnd.X()) + { + nX1 = rStart.X(); + nY1 = rStart.Y(); + nX2 = rEnd.X(); + nY2 = rEnd.Y(); + } + else + { + nX1 = rEnd.X(); + nY1 = rEnd.Y(); + nX2 = rStart.X(); + nY2 = rStart.Y(); + } + + const tools::Long nDYX = (nDY - nDX) << 1; + const tools::Long nDY2 = nDY << 1; + tools::Long nD = nDY2 - nDX; + bool bPos = nY1 < nY2; + + for (nX = nX1, nY = nY1; nX <= nX2; nX++) + { + SetPixel(nY, nX, rLineColor); + + if (nD < 0) + nD += nDY2; + else + { + nD += nDYX; + + if (bPos) + nY++; + else + nY--; + } + } + } + else + { + if (rStart.Y() < rEnd.Y()) + { + nX1 = rStart.X(); + nY1 = rStart.Y(); + nX2 = rEnd.X(); + nY2 = rEnd.Y(); + } + else + { + nX1 = rEnd.X(); + nY1 = rEnd.Y(); + nX2 = rStart.X(); + nY2 = rStart.Y(); + } + + const tools::Long nDYX = (nDX - nDY) << 1; + const tools::Long nDY2 = nDX << 1; + tools::Long nD = nDY2 - nDY; + bool bPos = nX1 < nX2; + + for (nX = nX1, nY = nY1; nY <= nY2; nY++) + { + SetPixel(nY, nX, rLineColor); + + if (nD < 0) + nD += nDY2; + else + { + nD += nDYX; + + if (bPos) + nX++; + else + nX--; + } + } + } + } +} + +void BitmapWriteAccess::FillRect(const tools::Rectangle& rRect) +{ + if (!mpFillColor) + return; + + const BitmapColor& rFillColor = *mpFillColor; + tools::Rectangle aRect(Point(), maBitmap.GetSizePixel()); + + aRect.Intersection(rRect); + + if (aRect.IsEmpty()) + return; + + const tools::Long nStartX = rRect.Left(); + const tools::Long nStartY = rRect.Top(); + const tools::Long nEndX = rRect.Right(); + const tools::Long nEndY = rRect.Bottom(); + + for (tools::Long nY = nStartY; nY <= nEndY; nY++) + { + Scanline pScanline = GetScanline(nY); + for (tools::Long nX = nStartX; nX <= nEndX; nX++) + { + SetPixelOnData(pScanline, nX, rFillColor); + } + } +} + +void BitmapWriteAccess::DrawRect(const tools::Rectangle& rRect) +{ + if (mpFillColor) + FillRect(rRect); + + if (mpLineColor && (!mpFillColor || (*mpFillColor != *mpLineColor))) + { + DrawLine(rRect.TopLeft(), rRect.TopRight()); + DrawLine(rRect.TopRight(), rRect.BottomRight()); + DrawLine(rRect.BottomRight(), rRect.BottomLeft()); + DrawLine(rRect.BottomLeft(), rRect.TopLeft()); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |