svx/source/tbxctrls/Palette.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 <svx/Palette.hxx>
  21 #include <tools/stream.hxx>
  22
  23 #include <palettes.hxx>
  24 #include <utility>
  25
  26 Palette::~Palette()
  27 {
  28 }
  29
  30 PaletteASE::~PaletteASE()
  31 {
  32 }
  33
  34 PaletteASE::PaletteASE( OUString aFPath, OUString aFName ) :
  35     mbValidPalette( false ),
  36     maFPath (std::move( aFPath )),
  37     maASEPaletteName  (std::move( aFName ))
  38 {
  39     LoadPalette();
  40 }
  41
  42 void PaletteASE::LoadColorSet(SvxColorValueSet& rColorSet)
  43 {
  44     rColorSet.Clear();
  45     int nIx = 1;
  46     for (const auto& rColor : maColors)
  47     {
  48         rColorSet.InsertItem(nIx, rColor.m_aColor, rColor.m_aName);
  49         ++nIx;
  50     }
  51 }
  52
  53 const OUString& PaletteASE::GetName()
  54 {
  55     return maASEPaletteName;
  56 }
  57
  58 const OUString& PaletteASE::GetPath()
  59 {
  60     return maFPath;
  61 }
  62
  63 bool PaletteASE::IsValid()
  64 {
  65     return mbValidPalette;
  66 }
  67
  68 // CMYK values from 0 to 1
  69 // TODO: Deduplicate me (taken from core/cui/source/dialogs/colorpicker.cxx)
  70 static void lcl_CMYKtoRGB( float fCyan, float fMagenta, float fYellow, float fKey, float& dR, float& dG, float& dB )
  71 {
  72     fCyan = (fCyan * ( 1.0 - fKey )) + fKey;
  73     fMagenta = (fMagenta * ( 1.0 - fKey )) + fKey;
  74     fYellow = (fYellow * ( 1.0 - fKey )) + fKey;
  75
  76     dR = std::clamp( 1.0 - fCyan, 0.0, 1.0 );
  77     dG = std::clamp( 1.0 - fMagenta, 0.0, 1.0 );
  78     dB = std::clamp( 1.0 - fYellow, 0.0, 1.0 );
  79 }
  80
  81 void PaletteASE::LoadPalette()
  82 {
  83     SvFileStream aFile(maFPath, StreamMode::READ);
  84     aFile.SetEndian(SvStreamEndian::BIG);
  85
  86     // Verify magic first 4 characters
  87     char cMagic[5] = {0};
  88     if ((aFile.ReadBytes(cMagic, 4) != 4) || (strncmp(cMagic, "ASEF", 4) != 0))
  89     {
  90         mbValidPalette = false;
  91         return;
  92     }
  93
  94     // Ignore the version number
  95     aFile.SeekRel(4);
  96
  97     sal_uInt32 nBlocks = 0;
  98     aFile.ReadUInt32(nBlocks);
  99     for (sal_uInt32 nI = 0; nI < nBlocks; nI++) {
 100         sal_uInt32 nChunkType = 0;
 101         aFile.ReadUInt32(nChunkType);
 102         // End chunk
 103         if (nChunkType == 0)
 104            break;
 105
 106         // Grab chunk size, name length
 107         sal_uInt16 nChunkSize = 0;
 108         sal_uInt16 nChars = 0;
 109         aFile.ReadUInt16(nChunkSize);
 110         aFile.ReadUInt16(nChars);
 111
 112         OUString aPaletteName("");
 113         if (nChars > 1)
 114             aPaletteName = read_uInt16s_ToOUString(aFile, nChars);
 115         else
 116             aFile.SeekRel(2);
 117
 118         if (nChunkType == 0xC0010000)
 119         {
 120             // Got a start chunk, so set palette name
 121             maASEPaletteName = aPaletteName;
 122             // Is there color data? (shouldn't happen in a start block, but check anyway)
 123             if (nChunkSize > ((nChars * 2) + 2))
 124                 aPaletteName.clear();
 125             else
 126                 continue;
 127         }
 128
 129         char cColorModel[5] = {0};
 130         aFile.ReadBytes(cColorModel, 4);
 131         OString aColorModel(cColorModel);
 132         // r, g, and b are floats ranging from 0 to 1
 133         float r = 0, g = 0, b = 0;
 134
 135         if (aColorModel.equalsIgnoreAsciiCase("cmyk"))
 136         {
 137             float c = 0, m = 0, y = 0, k = 0;
 138             aFile.ReadFloat(c);
 139             aFile.ReadFloat(m);
 140             aFile.ReadFloat(y);
 141             aFile.ReadFloat(k);
 142             lcl_CMYKtoRGB(c, m, y, k, r, g, b);
 143         }
 144         else if (aColorModel.equalsIgnoreAsciiCase("rgb "))
 145         {
 146             aFile.ReadFloat(r);
 147             aFile.ReadFloat(g);
 148             aFile.ReadFloat(b);
 149         }
 150         else if (aColorModel.equalsIgnoreAsciiCase("gray"))
 151         {
 152             float nVal = 0;
 153             aFile.ReadFloat(nVal);
 154             r = g = b = nVal;
 155         }
 156         else
 157         {
 158             float nL = 0, nA = 0, nB = 0;
 159             aFile.ReadFloat(nL);
 160             aFile.ReadFloat(nA);
 161             aFile.ReadFloat(nB);
 162             // TODO: How to convert LAB to RGB?
 163             r = g = b = 0;
 164         }
 165
 166         // Ignore color type
 167         aFile.SeekRel(2);
 168         maColors.emplace_back(Color(r * 255, g * 255, b * 255), aPaletteName);
 169     }
 170
 171     mbValidPalette = true;
 172 }
 173
 174 Palette* PaletteASE::Clone() const
 175 {
 176     return new PaletteASE(*this);
 177 }
 178
 179 // PaletteGPL ------------------------------------------------------------------
 180
 181 static OString lcl_getToken(OStringBuffer& rStr, sal_Int32& index);
 182
 183 PaletteGPL::PaletteGPL( OUString aFPath, OUString aFName ) :
 184     mbLoadedPalette( false ),
 185     mbValidPalette( false ),
 186     maFName(std::move( aFName )),
 187     maFPath(std::move( aFPath ))
 188 {
 189     LoadPaletteHeader();
 190 }
 191
 192 PaletteGPL::~PaletteGPL()
 193 {
 194 }
 195
 196 const OUString& PaletteGPL::GetName()
 197 {
 198     return maGPLPaletteName;
 199 }
 200
 201 const OUString& PaletteGPL::GetPath()
 202 {
 203     return maFPath;
 204 }
 205
 206 void PaletteGPL::LoadColorSet(SvxColorValueSet& rColorSet)
 207 {
 208     LoadPalette();
 209
 210     rColorSet.Clear();
 211     int nIx = 1;
 212     for (const auto& rColor : maColors)
 213     {
 214         rColorSet.InsertItem(nIx, rColor.m_aColor, rColor.m_aName);
 215         ++nIx;
 216     }
 217 }
 218
 219 bool PaletteGPL::IsValid()
 220 {
 221     return mbValidPalette;
 222 }
 223
 224 bool PaletteGPL::ReadPaletteHeader(SvFileStream& rFileStream)
 225 {
 226     OString aLine;
 227     OString aPaletteName;
 228
 229     rFileStream.ReadLine(aLine);
 230     if( !aLine.startsWith("GIMP Palette") ) return false;
 231     rFileStream.ReadLine(aLine);
 232     if( aLine.startsWith("Name: ", &aPaletteName) )
 233     {
 234         maGPLPaletteName = OStringToOUString(aPaletteName, RTL_TEXTENCODING_ASCII_US);
 235         rFileStream.ReadLine(aLine);
 236         if( aLine.startsWith("Columns: "))
 237             rFileStream.ReadLine(aLine); // we can ignore this
 238     }
 239     else
 240     {
 241         maGPLPaletteName = maFName;
 242     }
 243     return true;
 244 }
 245
 246 void PaletteGPL::LoadPaletteHeader()
 247 {
 248     SvFileStream aFile(maFPath, StreamMode::READ);
 249     mbValidPalette = ReadPaletteHeader( aFile );
 250 }
 251
 252 void PaletteGPL::LoadPalette()
 253 {
 254     if( mbLoadedPalette ) return;
 255     mbLoadedPalette = true;
 256
 257     // TODO add error handling!!!
 258     SvFileStream aFile(maFPath, StreamMode::READ);
 259     mbValidPalette = ReadPaletteHeader( aFile );
 260
 261     if( !mbValidPalette ) return;
 262
 263     OStringBuffer aLine;
 264     do {
 265         if (aLine.isEmpty())
 266             continue;
 267
 268         if (aLine[0] != '#' && aLine[0] != '\n')
 269         {
 270             // TODO check if r,g,b are 0<= x <=255, or just clamp?
 271             sal_Int32 nIndex = 0;
 272             OString token;
 273
 274             token = lcl_getToken(aLine, nIndex);
 275             if(token.isEmpty() || nIndex == -1) continue;
 276             sal_Int32 r = token.toInt32();
 277
 278             token = lcl_getToken(aLine, nIndex);
 279             if(token.isEmpty() || nIndex == -1) continue;
 280             sal_Int32 g = token.toInt32();
 281
 282             token = lcl_getToken(aLine, nIndex);
 283             if(token.isEmpty()) continue;
 284             sal_Int32 b = token.toInt32();
 285
 286             std::string_view name;
 287             if(nIndex != -1)
 288                 name = std::string_view(aLine).substr(nIndex);
 289
 290             maColors.emplace_back(
 291                 Color(r, g, b),
 292                 OStringToOUString(name, RTL_TEXTENCODING_ASCII_US));
 293         }
 294     } while (aFile.ReadLine(aLine));
 295 }
 296
 297 Palette* PaletteGPL::Clone() const
 298 {
 299     return new PaletteGPL(*this);
 300 }
 301
 302 // finds first token in rStr from index, separated by whitespace
 303 // returns position of next token in index
 304 static OString lcl_getToken(OStringBuffer& rStr, sal_Int32& index)
 305 {
 306     sal_Int32 substart, toklen = 0;
 307     OUString aWhitespaceChars( " \n\t" );
 308
 309     while(index < rStr.getLength() &&
 310             aWhitespaceChars.indexOf( rStr[index] ) != -1)
 311         ++index;
 312     if(index == rStr.getLength())
 313     {
 314         index = -1;
 315         return OString();
 316     }
 317     substart = index;
 318
 319     //counts length of token
 320     while(index < rStr.getLength() &&
 321             aWhitespaceChars.indexOf( rStr[index] ) == -1 )
 322     {
 323         ++index;
 324         ++toklen;
 325     }
 326
 327     //counts to position of next token
 328     while(index < rStr.getLength() &&
 329             aWhitespaceChars.indexOf( rStr[index] ) != -1 )
 330         ++index;
 331     if(index == rStr.getLength())
 332         index = -1;
 333
 334     return OString(std::string_view(rStr).substr(substart, toklen));
 335 }
 336
 337 // PaletteSOC ------------------------------------------------------------------
 338
 339 PaletteSOC::PaletteSOC( OUString aFPath, OUString aFName ) :
 340     mbLoadedPalette( false ),
 341     maFPath(std::move( aFPath )),
 342     maSOCPaletteName(std::move( aFName ))
 343 {
 344 }
 345
 346 PaletteSOC::~PaletteSOC()
 347 {
 348 }
 349
 350 const OUString& PaletteSOC::GetName()
 351 {
 352     return maSOCPaletteName;
 353 }
 354
 355 const OUString& PaletteSOC::GetPath()
 356 {
 357     return maFPath;
 358 }
 359
 360 void PaletteSOC::LoadColorSet(SvxColorValueSet& rColorSet)
 361 {
 362     if( !mbLoadedPalette )
 363     {
 364         mbLoadedPalette = true;
 365         mpColorList = XPropertyList::AsColorList(XPropertyList::CreatePropertyListFromURL(XPropertyListType::Color, maFPath));
 366         (void)mpColorList->Load();
 367     }
 368     rColorSet.Clear();
 369     if( mpColorList.is() )
 370         rColorSet.addEntriesForXColorList( *mpColorList );
 371 }
 372
 373 bool PaletteSOC::IsValid()
 374 {
 375     return true;
 376 }
 377
 378 Palette* PaletteSOC::Clone() const
 379 {
 380     return new PaletteSOC(*this);
 381 }
 382
 383 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */