sc/source/ui/dbgui/asciiopt.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: asciiopt.cxx,v $
  10  * $Revision: 1.25 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35
  36 #include "global.hxx"
  37 #include "scresid.hxx"
  38 #include "impex.hxx"
  39 #include "asciiopt.hxx"
  40 #include "asciiopt.hrc"
  41 #include <tools/debug.hxx>
  42 #include <rtl/tencinfo.h>
  43 #include <unotools/transliterationwrapper.hxx>
  44 // ause
  45 #include "editutil.hxx"
  46
  47 // ============================================================================
  48
  49 static const sal_Char __FAR_DATA pStrFix[] = "FIX";
  50 static const sal_Char __FAR_DATA pStrMrg[] = "MRG";
  51
  52
  53 // ============================================================================
  54
  55 ScAsciiOptions::ScAsciiOptions() :
  56     bFixedLen           ( FALSE ),
  57     aFieldSeps          ( ';' ),
  58     bMergeFieldSeps     ( FALSE ),
  59     bQuotedFieldAsText(false),
  60     bDetectSpecialNumber(false),
  61     cTextSep            ( cDefaultTextSep ),
  62     eCharSet            ( gsl_getSystemTextEncoding() ),
  63     eLang           ( LANGUAGE_SYSTEM ),
  64     bCharSetSystem      ( FALSE ),
  65     nStartRow           ( 1 ),
  66     nInfoCount          ( 0 ),
  67     pColStart       ( NULL ),
  68     pColFormat          ( NULL )
  69 {
  70 }
  71
  72
  73 ScAsciiOptions::ScAsciiOptions(const ScAsciiOptions& rOpt) :
  74     bFixedLen           ( rOpt.bFixedLen ),
  75     aFieldSeps          ( rOpt.aFieldSeps ),
  76     bMergeFieldSeps     ( rOpt.bMergeFieldSeps ),
  77     bQuotedFieldAsText(rOpt.bQuotedFieldAsText),
  78     bDetectSpecialNumber(rOpt.bDetectSpecialNumber),
  79     cTextSep            ( rOpt.cTextSep ),
  80     eCharSet            ( rOpt.eCharSet ),
  81     eLang           ( rOpt.eLang ),
  82     bCharSetSystem      ( rOpt.bCharSetSystem ),
  83     nStartRow           ( rOpt.nStartRow ),
  84     nInfoCount          ( rOpt.nInfoCount )
  85 {
  86     if (nInfoCount)
  87     {
  88         pColStart = new xub_StrLen[nInfoCount];
  89         pColFormat = new BYTE[nInfoCount];
  90         for (USHORT i=0; i<nInfoCount; i++)
  91         {
  92             pColStart[i] = rOpt.pColStart[i];
  93             pColFormat[i] = rOpt.pColFormat[i];
  94         }
  95     }
  96     else
  97     {
  98         pColStart = NULL;
  99         pColFormat = NULL;
 100     }
 101 }
 102
 103
 104 ScAsciiOptions::~ScAsciiOptions()
 105 {
 106     delete[] pColStart;
 107     delete[] pColFormat;
 108 }
 109
 110
 111 void ScAsciiOptions::SetColInfo( USHORT nCount, const xub_StrLen* pStart, const BYTE* pFormat )
 112 {
 113     delete[] pColStart;
 114     delete[] pColFormat;
 115
 116     nInfoCount = nCount;
 117
 118     if (nInfoCount)
 119     {
 120         pColStart = new xub_StrLen[nInfoCount];
 121         pColFormat = new BYTE[nInfoCount];
 122         for (USHORT i=0; i<nInfoCount; i++)
 123         {
 124             pColStart[i] = pStart[i];
 125             pColFormat[i] = pFormat[i];
 126         }
 127     }
 128     else
 129     {
 130         pColStart = NULL;
 131         pColFormat = NULL;
 132     }
 133 }
 134
 135
 136 void ScAsciiOptions::SetColumnInfo( const ScCsvExpDataVec& rDataVec )
 137 {
 138     delete[] pColStart;
 139     pColStart = NULL;
 140     delete[] pColFormat;
 141     pColFormat = NULL;
 142
 143     nInfoCount = static_cast< sal_uInt16 >( rDataVec.size() );
 144     if( nInfoCount )
 145     {
 146         pColStart = new xub_StrLen[ nInfoCount ];
 147         pColFormat = new sal_uInt8[ nInfoCount ];
 148         for( sal_uInt16 nIx = 0; nIx < nInfoCount; ++nIx )
 149         {
 150             pColStart[ nIx ] = rDataVec[ nIx ].mnIndex;
 151             pColFormat[ nIx ] = rDataVec[ nIx ].mnType;
 152         }
 153     }
 154 }
 155
 156
 157 ScAsciiOptions& ScAsciiOptions::operator=( const ScAsciiOptions& rCpy )
 158 {
 159     SetColInfo( rCpy.nInfoCount, rCpy.pColStart, rCpy.pColFormat );
 160
 161     bFixedLen           = rCpy.bFixedLen;
 162     aFieldSeps          = rCpy.aFieldSeps;
 163     bMergeFieldSeps     = rCpy.bMergeFieldSeps;
 164     bQuotedFieldAsText = rCpy.bQuotedFieldAsText;
 165     cTextSep            = rCpy.cTextSep;
 166     eCharSet            = rCpy.eCharSet;
 167     bCharSetSystem      = rCpy.bCharSetSystem;
 168     nStartRow           = rCpy.nStartRow;
 169
 170     return *this;
 171 }
 172
 173
 174 BOOL ScAsciiOptions::operator==( const ScAsciiOptions& rCmp ) const
 175 {
 176     if ( bFixedLen               == rCmp.bFixedLen &&
 177          aFieldSeps              == rCmp.aFieldSeps &&
 178          bMergeFieldSeps == rCmp.bMergeFieldSeps &&
 179          bQuotedFieldAsText == rCmp.bQuotedFieldAsText &&
 180          cTextSep                == rCmp.cTextSep &&
 181          eCharSet                == rCmp.eCharSet &&
 182          bCharSetSystem  == rCmp.bCharSetSystem &&
 183          nStartRow               == rCmp.nStartRow &&
 184          nInfoCount              == rCmp.nInfoCount )
 185     {
 186         DBG_ASSERT( !nInfoCount || (pColStart && pColFormat && rCmp.pColStart && rCmp.pColFormat),
 187                      "0-Zeiger in ScAsciiOptions" );
 188         for (USHORT i=0; i<nInfoCount; i++)
 189             if ( pColStart[i] != rCmp.pColStart[i] ||
 190                  pColFormat[i] != rCmp.pColFormat[i] )
 191                 return FALSE;
 192
 193         return TRUE;
 194     }
 195     return FALSE;
 196 }
 197
 198 //
 199 //      Der Options-String darf kein Semikolon mehr enthalten (wegen Pickliste)
 200 //      darum ab Version 336 Komma stattdessen
 201 //
 202
 203
 204 void ScAsciiOptions::ReadFromString( const String& rString )
 205 {
 206     xub_StrLen nCount = rString.GetTokenCount(',');
 207     String aToken;
 208     xub_StrLen nSub;
 209     xub_StrLen i;
 210
 211         //
 212         //      Feld-Trenner
 213         //
 214
 215     if ( nCount >= 1 )
 216     {
 217         bFixedLen = bMergeFieldSeps = FALSE;
 218         aFieldSeps.Erase();
 219
 220         aToken = rString.GetToken(0,',');
 221         if ( aToken.EqualsAscii(pStrFix) )
 222             bFixedLen = TRUE;
 223         nSub = aToken.GetTokenCount('/');
 224         for ( i=0; i<nSub; i++ )
 225         {
 226             String aCode = aToken.GetToken( i, '/' );
 227             if ( aCode.EqualsAscii(pStrMrg) )
 228                 bMergeFieldSeps = TRUE;
 229             else
 230             {
 231                 sal_Int32 nVal = aCode.ToInt32();
 232                 if ( nVal )
 233                     aFieldSeps += (sal_Unicode) nVal;
 234             }
 235         }
 236     }
 237
 238         //
 239         //      Text-Trenner
 240         //
 241
 242     if ( nCount >= 2 )
 243     {
 244         aToken = rString.GetToken(1,',');
 245         sal_Int32 nVal = aToken.ToInt32();
 246         cTextSep = (sal_Unicode) nVal;
 247     }
 248
 249         //
 250         //      Zeichensatz
 251         //
 252
 253     if ( nCount >= 3 )
 254     {
 255         aToken = rString.GetToken(2,',');
 256         eCharSet = ScGlobal::GetCharsetValue( aToken );
 257     }
 258
 259     // Language
 260     if (nCount >= 4)
 261     {
 262         aToken = rString.GetToken(3, ',');
 263         eLang = static_cast<LanguageType>(aToken.ToInt32());
 264     }
 265
 266         //
 267         //      Startzeile
 268         //
 269
 270     if ( nCount >= 5 )
 271     {
 272         aToken = rString.GetToken(4,',');
 273         nStartRow = aToken.ToInt32();
 274     }
 275
 276         //
 277         //      Spalten-Infos
 278         //
 279
 280     if ( nCount >= 6 )
 281     {
 282         delete[] pColStart;
 283         delete[] pColFormat;
 284
 285         aToken = rString.GetToken(5,',');
 286         nSub = aToken.GetTokenCount('/');
 287         nInfoCount = nSub / 2;
 288         if (nInfoCount)
 289         {
 290             pColStart = new xub_StrLen[nInfoCount];
 291             pColFormat = new BYTE[nInfoCount];
 292             for (USHORT nInfo=0; nInfo<nInfoCount; nInfo++)
 293             {
 294                 pColStart[nInfo]  = (xub_StrLen) aToken.GetToken( 2*nInfo, '/' ).ToInt32();
 295                 pColFormat[nInfo] = (BYTE) aToken.GetToken( 2*nInfo+1, '/' ).ToInt32();
 296             }
 297         }
 298         else
 299         {
 300             pColStart = NULL;
 301             pColFormat = NULL;
 302         }
 303     }
 304
 305     // Import quoted field as text.
 306     if (nCount >= 7)
 307     {
 308         aToken = rString.GetToken(6, ',');
 309         bQuotedFieldAsText = aToken.EqualsAscii("true") ? true : false;
 310     }
 311
 312     // Detect special nubmers.
 313     if (nCount >= 8)
 314     {
 315         aToken = rString.GetToken(7, ',');
 316         bDetectSpecialNumber = aToken.EqualsAscii("true") ? true : false;
 317     }
 318 }
 319
 320
 321 String ScAsciiOptions::WriteToString() const
 322 {
 323     String aOutStr;
 324
 325         //
 326         //      Feld-Trenner
 327         //
 328
 329     if ( bFixedLen )
 330         aOutStr.AppendAscii(pStrFix);
 331     else if ( !aFieldSeps.Len() )
 332         aOutStr += '0';
 333     else
 334     {
 335         xub_StrLen nLen = aFieldSeps.Len();
 336         for (xub_StrLen i=0; i<nLen; i++)
 337         {
 338             if (i)
 339                 aOutStr += '/';
 340             aOutStr += String::CreateFromInt32(aFieldSeps.GetChar(i));
 341         }
 342         if ( bMergeFieldSeps )
 343         {
 344             aOutStr += '/';
 345             aOutStr.AppendAscii(pStrMrg);
 346         }
 347     }
 348
 349     aOutStr += ',';                                     // Token-Ende
 350
 351         //
 352         //      Text-Trenner
 353         //
 354
 355     aOutStr += String::CreateFromInt32(cTextSep);
 356     aOutStr += ',';                                     // Token-Ende
 357
 358         //
 359         //      Zeichensatz
 360         //
 361
 362     if ( bCharSetSystem )                       // force "SYSTEM"
 363         aOutStr += ScGlobal::GetCharsetString( RTL_TEXTENCODING_DONTKNOW );
 364     else
 365         aOutStr += ScGlobal::GetCharsetString( eCharSet );
 366     aOutStr += ',';                                     // Token-Ende
 367
 368     // Language
 369     aOutStr += String::CreateFromInt32(eLang);
 370     aOutStr += ',';
 371
 372         //
 373         //      Startzeile
 374         //
 375
 376     aOutStr += String::CreateFromInt32(nStartRow);
 377     aOutStr += ',';                                     // Token-Ende
 378
 379         //
 380         //      Spalten-Infos
 381         //
 382
 383     DBG_ASSERT( !nInfoCount || (pColStart && pColFormat), "0-Zeiger in ScAsciiOptions" );
 384     for (USHORT nInfo=0; nInfo<nInfoCount; nInfo++)
 385     {
 386         if (nInfo)
 387             aOutStr += '/';
 388         aOutStr += String::CreateFromInt32(pColStart[nInfo]);
 389         aOutStr += '/';
 390         aOutStr += String::CreateFromInt32(pColFormat[nInfo]);
 391     }
 392
 393     aOutStr += ',';
 394
 395     // Import quoted field as text.
 396     aOutStr += String::CreateFromAscii(bQuotedFieldAsText ? "true" : "false");
 397     aOutStr += ',';
 398
 399     // Detect special nubmers.
 400     aOutStr += String::CreateFromAscii(bDetectSpecialNumber ? "true" : "false");
 401
 402     return aOutStr;
 403 }
 404
 405 #if 0
 406 //      Code, um die Spalten-Liste aus einem Excel-kompatiblen String zu erzeugen:
 407 //      (im Moment nicht benutzt)
 408
 409 void ScAsciiOptions::InterpretColumnList( const String& rString )
 410 {
 411     //  Eingabe ist 1-basiert, pColStart fuer FixedLen ist 0-basiert
 412
 413     //  Kommas durch Semikolon ersetzen
 414
 415     String aSemiStr = rString;
 416     USHORT nPos = 0;
 417     do
 418         nPos = aSemiStr.SearchAndReplace( ',', ';', nPos );
 419     while ( nPos != STRING_NOTFOUND );
 420
 421     //  Eintraege sortieren
 422
 423     USHORT nCount = aSemiStr.GetTokenCount();
 424     USHORT* pTemp = new USHORT[nCount+1];
 425     pTemp[0] = 1;                                                                       // erste Spalte faengt immer bei 1 an
 426     USHORT nFound = 1;
 427     USHORT i,j;
 428     for (i=0; i<nCount; i++)
 429     {
 430         USHORT nVal = (USHORT) aSemiStr.GetToken(i);
 431         if (nVal)
 432         {
 433             BOOL bThere = FALSE;
 434             nPos = 0;
 435             for (j=0; j<nFound; j++)
 436             {
 437                 if ( pTemp[j] == nVal )
 438                     bThere = TRUE;
 439                 else if ( pTemp[j] < nVal )
 440                     nPos = j+1;
 441             }
 442             if ( !bThere )
 443             {
 444                 if ( nPos < nFound )
 445                     memmove( &pTemp[nPos+1], &pTemp[nPos], (nFound-nPos)*sizeof(USHORT) );
 446                 pTemp[nPos] = nVal;
 447                 ++nFound;
 448             }
 449         }
 450     }
 451
 452     //  Eintraege uebernehmen
 453
 454     delete[] pColStart;
 455     delete[] pColFormat;
 456     nInfoCount = nFound;
 457     if (nInfoCount)
 458     {
 459         pColStart = new USHORT[nInfoCount];
 460         pColFormat = new BYTE[nInfoCount];
 461         for (i=0; i<nInfoCount; i++)
 462         {
 463             pColStart[i] = pTemp[i] - 1;
 464             pColFormat[i] = SC_COL_STANDARD;
 465         }
 466     }
 467     else
 468     {
 469         pColStart = NULL;
 470         pColFormat = NULL;
 471     }
 472
 473     bFixedLen = TRUE;                   // sonst macht's keinen Sinn
 474
 475     //  aufraeumen
 476
 477     delete[] pTemp;
 478 }
 479 #endif
 480