source/tools/bitmapcode.cpp

   1 // bitmapcode.cpp - Bitmap code helper.
   2 //
   3 // (c) 2012-2015 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Address Book.
   6 //
   7 // Xestia Address Book is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Address Book is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Address Book. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include <iostream>
  20 #include <fstream>
  21 #include <iomanip>
  22 #include <ios>
  23 #include <string>
  24
  25 #include <wx/wx.h>
  26 #include <wx/dir.h>
  27 #include <wx/tokenzr.h>
  28
  29 using namespace std;
  30
  31 void CreateCPPFile(wxString dirfilename, wxString PNGFilename, int* counter)
  32 {
  33 //-------------------------------------------------------------------
  34 // CreateCPPFile: Create a CPP file from the filename given.
  35 //
  36 // dirfilename  wxString of the directory name.
  37 // filename     wxString of the filename.
  38 // counter      Pointer to a integer counter.
  39 //-------------------------------------------------------------------
  40
  41         char pngfile_char;
  42         int pageseek = 0;
  43         wxString outname;
  44         wxString CPPFilename;
  45         CPPFilename = PNGFilename;
  46         CPPFilename.RemoveLast(4);
  47         CPPFilename.Append(wxT(".cpp"));
  48
  49         wxString DirFilenameOnly;
  50         wxString CPPFilenameOnly;
  51
  52 #if defined(__HAIKU__)
  53
  54 #elif defined(__WIN32__)
  55
  56         wxStringTokenizer CPPFilenameTokens(CPPFilename, wxT("\\"));
  57         wxStringTokenizer DirFilenameTokens(dirfilename, wxT("\\"));
  58
  59 #else
  60
  61         wxStringTokenizer CPPFilenameTokens(CPPFilename, wxT("/"));
  62         wxStringTokenizer DirFilenameTokens(dirfilename, wxT("/"));
  63
  64 #endif
  65
  66         while (CPPFilenameTokens.HasMoreTokens()){
  67
  68                 CPPFilenameOnly = CPPFilenameTokens.GetNextToken();
  69
  70         }
  71
  72         while (DirFilenameTokens.HasMoreTokens()){
  73
  74                 DirFilenameOnly = DirFilenameTokens.GetNextToken();
  75
  76         }
  77
  78         // Setup the PNG file reading and cpp file.
  79
  80         fstream cppfile, pngfile;
  81
  82 #if defined(__WIN32__)
  83
  84         pngfile.open(PNGFilename.wc_str(), ios::in | ios::binary );
  85         cppfile.open(CPPFilename.wc_str(), ios::out | ios::trunc );
  86
  87 # else
  88
  89         pngfile.open(PNGFilename.c_str(), ios::in | ios::binary );
  90         cppfile.open(CPPFilename.c_str(), ios::out | ios::trunc );
  91
  92 #endif
  93
  94         outname.Append(wxString::FromUTF8(DirFilenameOnly.c_str()));
  95         outname.Append(wxT("_"));
  96         outname.Append(wxString::FromUTF8(CPPFilenameOnly.c_str()));
  97         outname.MakeUpper();
  98         outname.RemoveLast(4);
  99
 100         // Setup the inclusion guard.
 101
 102         cppfile << "#include <iostream>" << endl << endl;
 103         cppfile << "#ifndef " << outname.c_str() << "_CPP" << endl;
 104         cppfile << "#define " << outname.c_str() << "_CPP" << endl << endl;
 105
 106         outname.Clear();
 107         outname.Append(wxString::FromUTF8(DirFilenameOnly.c_str()));
 108         outname.Append(wxT("_"));
 109         outname.Append(wxString::FromUTF8(CPPFilenameOnly.c_str()));
 110         outname.RemoveLast(4);
 111         outname.Append(wxT("_png"));
 112         outname.MakeLower();
 113
 114         // Convert the PNG file into an unsigned char array.
 115
 116         cppfile << "static unsigned char " << outname.c_str() <<
 117                 "[] = {" << endl;
 118
 119         while (pngfile){
 120                 pngfile.get(pngfile_char);
 121                 cppfile << "0x";
 122
 123                 if ((unsigned short)pngfile_char > 255){
 124
 125                         cppfile << hex << setw(2) << setfill('0') <<
 126                                 ((unsigned short)pngfile_char - 65280);
 127
 128                 } else {
 129
 130                         cppfile << hex << setw(2) << setfill('0') <<
 131                                 (unsigned short)pngfile_char;
 132
 133                 }
 134
 135                 cppfile << ", ";
 136                 pageseek++;
 137
 138                 if (pageseek == 8){
 139                         cppfile << endl;
 140                         pageseek = 0;
 141                 }
 142
 143         }
 144
 145         // End the file, close it and increment the counter.
 146
 147         cppfile << "};" << endl << endl;
 148         cppfile << "#endif" << endl << endl;
 149         cppfile.close();
 150
 151         cout << "CPP\t" << CPPFilename.c_str() << endl;
 152
 153         ++*counter;
 154
 155 }
 156
 157 void CreateHPPFileDir(wxString dirfilename, wxArrayString filelist,
 158                         int* counter)
 159 {
 160 //-------------------------------------------------------------------
 161 // CreateHPPFileDir:    Create a HPP Directory with the directory
 162 //                      filename and list of files in the directory
 163 //                      given.
 164 //
 165 // dirfilename  wxString of the directory name.
 166 // filelist     wxArrayString of the directory filelist.
 167 // counter      Pointer to a integer counter.
 168 //-------------------------------------------------------------------
 169
 170         fstream hppfile;
 171
 172         bool fmatch = FALSE;
 173         wxString finaldirname;
 174         wxString HPPFilename = dirfilename.c_str();
 175
 176         wxString DirFilenameOnly;
 177         wxString HPPFilenameOnly;
 178         wxString CPPFilename;
 179
 180 #if defined(__WIN32__)
 181
 182         wxStringTokenizer HPPFilenameTokens(HPPFilename, wxT("\\"));
 183         wxStringTokenizer DirFilenameTokens(dirfilename, wxT("\\"));
 184
 185 #else
 186
 187         wxStringTokenizer HPPFilenameTokens(HPPFilename, wxT("/"));
 188         wxStringTokenizer DirFilenameTokens(dirfilename, wxT("/"));
 189
 190 #endif
 191
 192         while (HPPFilenameTokens.HasMoreTokens()){
 193
 194                 HPPFilenameOnly = HPPFilenameTokens.GetNextToken();
 195
 196         }
 197
 198         while (DirFilenameTokens.HasMoreTokens()){
 199
 200                 DirFilenameOnly = DirFilenameTokens.GetNextToken();
 201
 202         }
 203
 204         // Make the directory filename upper case for writing to the
 205         // header file.
 206
 207         wxString CPPFileOnly;
 208
 209         finaldirname.Append(wxString::FromUTF8(DirFilenameOnly.c_str()));
 210         finaldirname.MakeUpper();
 211
 212         // Write out the header file inclusion guard.
 213
 214         HPPFilename.Append(wxT(".h"));
 215
 216 #if defined(__WIN32__)
 217
 218             hppfile.open(HPPFilename.wc_str(), ios::out | ios::trunc );
 219
 220 #else
 221
 222         hppfile.open(HPPFilename.c_str(), ios::out | ios::trunc );
 223
 224 #endif
 225
 226         hppfile << "#include <iostream>" << endl << endl;
 227         hppfile << "#ifndef " << finaldirname.c_str() << "_H" << endl;
 228         hppfile << "#define " << finaldirname.c_str() << "_H" << endl << endl;
 229         hppfile << "// List all CPP files in the directory." << endl << endl;
 230
 231         // Write each CPP file into the header file.
 232
 233         for (int f = 0; f < filelist.GetCount() ; f++){
 234
 235                 CPPFilename = filelist[f];
 236
 237 #if defined(__HAIKU__)
 238
 239 #elif defined(__WIN32__)
 240
 241                 wxStringTokenizer CPPFilenameTokenizer(CPPFilename, wxT("\\"));
 242
 243 #else
 244
 245                 wxStringTokenizer CPPFilenameTokenizer(CPPFilename, wxT("/"));
 246
 247 #endif
 248
 249                 while (CPPFilenameTokenizer.HasMoreTokens()){
 250
 251                         CPPFileOnly = CPPFilenameTokenizer.GetNextToken();
 252
 253                 }
 254
 255                 CPPFileOnly.RemoveLast(4);
 256                 CPPFileOnly.Append(wxT(".cpp"));
 257
 258                 hppfile << "#include \"" << DirFilenameOnly.c_str() <<
 259                         "/" << CPPFileOnly.c_str() << "\"" << endl;
 260
 261         }
 262
 263         // Write the end if and close the file.
 264
 265         hppfile << endl << "#endif" << endl << endl;
 266         hppfile.close();
 267
 268         // Increment the HPP file counter.
 269
 270         cout << "HPPDIR\t" << HPPFilename.c_str() << endl;
 271         ++*counter;
 272
 273 }
 274
 275 int main(int argc, char *argv[])
 276 {
 277
 278         int fp = 0;
 279         int cppg = 0;
 280         int hppg = 0;
 281
 282         wxArrayString dirlist;
 283         wxArrayString filelist;
 284         wxString BitmapHeaderFilename;
 285         wxString DirFilenameWxS;
 286
 287         // Check if completed file exists before doing anything
 288         // else and write an error message if it does exist.
 289
 290         if (wxFileExists(wxT("bitmapsdone"))){
 291
 292                 std::cout << "Bitmap files have already been generated!" << std::endl << std::endl;
 293                 std::cout << "To regenerate the files simply delete the bitmapsdone file where this helper application is run." << std::endl;
 294
 295
 296                 return 0;
 297
 298         }
 299
 300         fstream finalhppfile;
 301
 302         if (!argv[1]){
 303                 std::cout << "Error: No directory name given!" << std::endl;
 304                 return -1;
 305         }
 306
 307         // Look in the subdirectories of the bitmaps directory and
 308         // collect the names of the directories.
 309
 310         std::cout << "Working out directories in bitmaps directory..." <<
 311         std::endl;
 312
 313         const char *dirarg = argv[1];
 314
 315         wxString BitmapDirName = wxString(dirarg, wxConvUTF8);
 316
 317 #if defined(__HAIKU__)
 318
 319 #elif defined(__WIN32__)
 320
 321         BitmapHeaderFilename.Append(BitmapDirName);
 322         BitmapHeaderFilename.Append(wxT("\\..\\bitmaps.h"));
 323
 324 #else
 325
 326         BitmapHeaderFilename.Append(BitmapDirName);
 327         BitmapHeaderFilename.Append(wxT("/../bitmaps.h"));
 328
 329 #endif
 330
 331         if ( wxDirExists(BitmapDirName) ){
 332
 333                 wxDir BitmapDir(BitmapDirName);
 334
 335                 wxString BitmapSubDir;
 336                 wxString BitmapSubDirFull;
 337
 338                 bool ContinueProcess = BitmapDir.GetFirst(&BitmapSubDir, wxEmptyString, wxDIR_DEFAULT);
 339
 340                 while (ContinueProcess){
 341
 342 #if defined(__HAIKU__)
 343
 344                         BitmapSubDirFull.Append(BitmapSubDir);
 345                         BitmapSubDirFull.Append();
 346
 347 #elif defined(__WIN32__)
 348
 349                         BitmapSubDirFull.Append(BitmapDirName);
 350                         BitmapSubDirFull.Append(wxT("\\"));
 351                         BitmapSubDirFull.Append(BitmapSubDir);
 352
 353 #else
 354
 355                         BitmapSubDirFull.Append(BitmapDirName);
 356                         BitmapSubDirFull.Append(wxT("/"));
 357                         BitmapSubDirFull.Append(BitmapSubDir);
 358
 359 #endif
 360
 361                         if (wxDirExists(BitmapSubDirFull)){
 362                                 dirlist.Add(BitmapSubDirFull);
 363                         }
 364
 365                         ContinueProcess = BitmapDir.GetNext(&BitmapSubDir);
 366
 367                         BitmapSubDirFull.Clear();
 368
 369                 }
 370
 371         } else {
 372                 std::cout << "Error: Bitmaps Directory doesn't exist!" << std::endl;
 373                 return 1;
 374         }
 375
 376         // Process each directory, generating a .cpp and .hpp file
 377         // for each image and then a final .hpp for the directory
 378         // containing the .hpp's for the directories.
 379
 380         if (dirlist.GetCount() == 0){
 381                 cout << "Error: No directories in the bitmaps folder. Unexpected behaviour!" << endl;
 382                 return 1;
 383         }
 384
 385         std::cout << "Looking in bitmaps folder for PNGs..." << std::endl;
 386
 387         DirFilenameWxS.Empty();
 388
 389         std::cout << BitmapHeaderFilename.c_str() << std::endl;
 390
 391 #if defined(__WIN32__)
 392
 393         finalhppfile.open(BitmapHeaderFilename.wc_str(), ios::out | ios::trunc);
 394
 395 #else
 396
 397         finalhppfile.open(BitmapHeaderFilename.c_str(), ios::out | ios::trunc);
 398
 399 #endif
 400
 401         finalhppfile << "#include <iostream>" << endl << endl;
 402         finalhppfile << "#ifndef BITMAPS_H" << endl;
 403         finalhppfile << "#define BITMAPS_H" << endl << endl;
 404
 405         for (int bi = 0; bi < dirlist.GetCount(); bi++)
 406         {
 407
 408                 wxString BitmapSubDirName = dirlist[bi];
 409                 wxString BitmapFilename;
 410                 wxDir BitmapSubDir(BitmapSubDirName);
 411
 412                 bool ContinueProcess = BitmapSubDir.GetFirst(&BitmapFilename, wxEmptyString, wxDIR_DEFAULT);
 413
 414                 while (ContinueProcess){
 415
 416                         if (BitmapFilename.Right(4) == wxT(".PNG") ||
 417
 418                                 BitmapFilename.Right(4) == wxT(".png")){
 419
 420 #if defined(__HAIKU__)
 421
 422                                 BitmapSubDirFull.Append(BitmapSubDir);
 423                                 BitmapSubDirFull.Append();
 424
 425 #elif defined(__WIN32__)
 426
 427                                 DirFilenameWxS.Append(wxString::FromUTF8(dirlist[bi].c_str()));
 428                                 DirFilenameWxS.Append(wxT("\\"));
 429                                 DirFilenameWxS.Append(wxString::FromUTF8(BitmapFilename.c_str()));
 430
 431 #else
 432
 433                                 DirFilenameWxS.Append(wxString::FromUTF8(dirlist[bi].c_str()));
 434                                 DirFilenameWxS.Append(wxString::FromUTF8("/"));
 435                                 DirFilenameWxS.Append(wxString::FromUTF8(BitmapFilename.c_str()));
 436
 437 #endif
 438
 439                                 filelist.Add(DirFilenameWxS);
 440
 441                         }
 442
 443                         DirFilenameWxS.Clear();
 444                         ContinueProcess = BitmapSubDir.GetNext(&BitmapFilename);
 445
 446                 }
 447
 448                 for (int fi = 0; fi < filelist.GetCount(); fi++)
 449                 {
 450
 451                         CreateCPPFile(dirlist[bi].wc_str(), filelist[fi].wc_str(), &cppg);
 452                         fp++;
 453
 454                 }
 455
 456                 if (filelist.GetCount() > 0)
 457                 {
 458
 459                         CreateHPPFileDir(dirlist[bi].wc_str(), filelist, &hppg);
 460
 461                 }
 462
 463                 filelist.Clear();
 464
 465                 wxString DirNameSplit;
 466
 467 #if defined(__HAIKU__)
 468
 469 #elif defined(__WIN32__)
 470
 471                 wxStringTokenizer DirListFile(dirlist[bi], wxT("\\"));
 472
 473 #else
 474
 475                 wxStringTokenizer DirListFile(dirlist[bi], wxT("/"));
 476
 477
 478 #endif
 479
 480                 while (DirListFile.HasMoreTokens()){
 481
 482                         DirNameSplit = DirListFile.GetNextToken();
 483
 484                 }
 485
 486 #if defined(__HAIKU__)
 487
 488 #elif defined(__WIN32__)
 489
 490                 finalhppfile << "#include \"bitmaps\\" << DirNameSplit.c_str() <<
 491                         ".h\"" << endl;
 492
 493 #else
 494
 495                 finalhppfile << "#include \"bitmaps/" << DirNameSplit.c_str() <<
 496                         ".h\"" << endl;
 497
 498 #endif
 499
 500         }
 501
 502         finalhppfile << endl << "#endif" << endl;
 503         finalhppfile.close();
 504         ++hppg;
 505
 506         // Print out the results.
 507
 508         std::cout << "Finished processing PNGs into code." << std::endl;
 509         std::cout << fp << " files processed." << std::endl;
 510         std::cout << cppg << " .cpp files generated." << std::endl;
 511         std::cout << hppg << " .hpp files generated." << std::endl;
 512
 513         // Write a success flag so that future runs won't take
 514         // place thus speeding up the compilation process as required.
 515
 516         fstream bitmapflag;
 517
 518         bitmapflag.open("bitmapsdone", ios::out | ios::trunc);
 519         bitmapflag << "Bitmaps as code generated. To recreate, simply delete this file and run the bitmap code generation tool again." << endl;
 520         bitmapflag.close();
 521
 522         return 0;
 523
 524 }