vcl/source/gdi/bmpacc3.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <tools/poly.hxx>
  21
  22 #include <vcl/salbtype.hxx>
  23 #include <vcl/bitmap.hxx>
  24 #include <vcl/region.hxx>
  25 #include <vcl/bitmapaccess.hxx>
  26
  27 #include <bmpfast.hxx>
  28
  29 void BitmapWriteAccess::SetLineColor( const Color& rColor )
  30 {
  31     if (rColor.GetTransparency() == 255)
  32     {
  33         mpLineColor.reset();
  34     }
  35     else
  36     {
  37         if (HasPalette())
  38         {
  39             mpLineColor.reset(new BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rColor))));
  40         }
  41         else
  42         {
  43             mpLineColor.reset(new BitmapColor(rColor));
  44         }
  45     }
  46 }
  47
  48 void BitmapWriteAccess::SetFillColor()
  49 {
  50     mpFillColor.reset();
  51 }
  52
  53 void BitmapWriteAccess::SetFillColor( const Color& rColor )
  54 {
  55     if (rColor.GetTransparency() == 255)
  56     {
  57         mpFillColor.reset();
  58     }
  59     else
  60     {
  61         if (HasPalette())
  62         {
  63             mpFillColor.reset(new BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rColor))));
  64         }
  65         else
  66         {
  67             mpFillColor.reset(new BitmapColor(rColor));
  68         }
  69     }
  70 }
  71
  72 void BitmapWriteAccess::Erase( const Color& rColor )
  73 {
  74     // convert the color format from RGB to palette index if needed
  75     // TODO: provide and use Erase( BitmapColor& method)
  76     BitmapColor aColor = rColor;
  77     if (HasPalette())
  78     {
  79         aColor = BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rColor)));
  80     }
  81     // try fast bitmap method first
  82     if (ImplFastEraseBitmap(*mpBuffer, aColor))
  83         return;
  84
  85     // use the canonical method to clear the bitmap
  86     BitmapColor* pOldFillColor = mpFillColor ? new BitmapColor(*mpFillColor) : nullptr;
  87     const Point aPoint;
  88     const tools::Rectangle aRect(aPoint, maBitmap.GetSizePixel());
  89
  90     SetFillColor(rColor);
  91     FillRect(aRect);
  92
  93     mpFillColor.reset(pOldFillColor);
  94 }
  95
  96 void BitmapWriteAccess::DrawLine( const Point& rStart, const Point& rEnd )
  97 {
  98     if (mpLineColor)
  99     {
 100         const BitmapColor& rLineColor = *mpLineColor.get();
 101         long nX, nY;
 102
 103         if (rStart.X() == rEnd.X())
 104         {
 105             // Vertical Line
 106             const long nEndY = rEnd.Y();
 107
 108             nX = rStart.X();
 109             nY = rStart.Y();
 110
 111             if (nEndY > nY)
 112             {
 113                 for (; nY <= nEndY; nY++ )
 114                     SetPixel( nY, nX, rLineColor );
 115             }
 116             else
 117             {
 118                 for (; nY >= nEndY; nY-- )
 119                     SetPixel( nY, nX, rLineColor );
 120             }
 121         }
 122         else if (rStart.Y() == rEnd.Y())
 123         {
 124             // Horizontal Line
 125             const long nEndX = rEnd.X();
 126
 127             nX = rStart.X();
 128             nY = rStart.Y();
 129
 130             if (nEndX > nX)
 131             {
 132                 for (; nX <= nEndX; nX++)
 133                     SetPixel(nY, nX, rLineColor);
 134             }
 135             else
 136             {
 137                 for (; nX >= nEndX; nX--)
 138                     SetPixel(nY, nX, rLineColor);
 139             }
 140         }
 141         else
 142         {
 143             const long  nDX = labs( rEnd.X() - rStart.X() );
 144             const long  nDY = labs( rEnd.Y() - rStart.Y() );
 145             long nX1;
 146             long nY1;
 147             long nX2;
 148             long nY2;
 149
 150             if (nDX >= nDY)
 151             {
 152                 if (rStart.X() < rEnd.X())
 153                 {
 154                     nX1 = rStart.X();
 155                     nY1 = rStart.Y();
 156                     nX2 = rEnd.X();
 157                     nY2 = rEnd.Y();
 158                 }
 159                 else
 160                 {
 161                     nX1 = rEnd.X();
 162                     nY1 = rEnd.Y();
 163                     nX2 = rStart.X();
 164                     nY2 = rStart.Y();
 165                 }
 166
 167                 const long nDYX = (nDY - nDX) << 1;
 168                 const long nDY2 = nDY << 1;
 169                 long nD = nDY2 - nDX;
 170                 bool bPos = nY1 < nY2;
 171
 172                 for (nX = nX1, nY = nY1; nX <= nX2; nX++)
 173                 {
 174                     SetPixel(nY, nX, rLineColor);
 175
 176                     if (nD < 0)
 177                         nD += nDY2;
 178                     else
 179                     {
 180                         nD += nDYX;
 181
 182                         if (bPos)
 183                             nY++;
 184                         else
 185                             nY--;
 186                     }
 187                 }
 188             }
 189             else
 190             {
 191                 if (rStart.Y() < rEnd.Y())
 192                 {
 193                     nX1 = rStart.X();
 194                     nY1 = rStart.Y();
 195                     nX2 = rEnd.X();
 196                     nY2 = rEnd.Y();
 197                 }
 198                 else
 199                 {
 200                     nX1 = rEnd.X();
 201                     nY1 = rEnd.Y();
 202                     nX2 = rStart.X();
 203                     nY2 = rStart.Y();
 204                 }
 205
 206                 const long  nDYX = (nDX - nDY) << 1;
 207                 const long  nDY2 = nDX << 1;
 208                 long nD = nDY2 - nDY;
 209                 bool bPos = nX1 < nX2;
 210
 211                 for (nX = nX1, nY = nY1; nY <= nY2; nY++)
 212                 {
 213                     SetPixel(nY, nX, rLineColor);
 214
 215                     if (nD < 0)
 216                         nD += nDY2;
 217                     else
 218                     {
 219                         nD += nDYX;
 220
 221                         if (bPos)
 222                             nX++;
 223                         else
 224                             nX--;
 225                     }
 226                 }
 227             }
 228         }
 229     }
 230 }
 231
 232 void BitmapWriteAccess::FillRect( const tools::Rectangle& rRect )
 233 {
 234     if (mpFillColor)
 235     {
 236         const BitmapColor& rFillColor = *mpFillColor.get();
 237         Point aPoint;
 238         tools::Rectangle aRect(aPoint, maBitmap.GetSizePixel());
 239
 240         aRect.Intersection(rRect);
 241
 242         if (!aRect.IsEmpty())
 243         {
 244             const long nStartX = rRect.Left();
 245             const long nStartY = rRect.Top();
 246             const long nEndX = rRect.Right();
 247             const long nEndY = rRect.Bottom();
 248
 249             for (long nY = nStartY; nY <= nEndY; nY++)
 250             {
 251                 for (long nX = nStartX; nX <= nEndX; nX++)
 252                 {
 253                     SetPixel(nY, nX, rFillColor);
 254                 }
 255             }
 256         }
 257     }
 258 }
 259
 260 void BitmapWriteAccess::DrawRect( const tools::Rectangle& rRect )
 261 {
 262     if (mpFillColor)
 263         FillRect(rRect);
 264
 265     if (mpLineColor && (!mpFillColor || ( *mpFillColor.get() != *mpLineColor.get())))
 266     {
 267         DrawLine(rRect.TopLeft(), rRect.TopRight());
 268         DrawLine(rRect.TopRight(), rRect.BottomRight());
 269         DrawLine(rRect.BottomRight(), rRect.BottomLeft());
 270         DrawLine(rRect.BottomLeft(), rRect.TopLeft());
 271     }
 272 }
 273
 274 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */