source/Tools/bitmapcode.cpp

   1 // bitmapcode.cpp - Bitmap code helper.
   2 //
   3 // (c) 2012-2021 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.ToStdString() << "_CPP" << endl;
 104         cppfile << "#define " << outname.ToStdString() << "_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.ToStdString() <<
 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.ToStdString() << endl;
 152
 153         ++*counter;
 154 }
 155
 156 void CreateHPPFileDir(wxString dirfilename, wxArrayString filelist,
 157                         int* counter)
 158 {
 159 //-------------------------------------------------------------------
 160 // CreateHPPFileDir:    Create a HPP Directory with the directory
 161 //                      filename and list of files in the directory
 162 //                      given.
 163 //
 164 // dirfilename  wxString of the directory name.
 165 // filelist     wxArrayString of the directory filelist.
 166 // counter      Pointer to a integer counter.
 167 //-------------------------------------------------------------------
 168
 169         fstream hppfile;
 170
 171         bool fmatch = FALSE;
 172         wxString finaldirname;
 173         wxString HPPFilename = dirfilename.ToStdString();
 174
 175         wxString DirFilenameOnly;
 176         wxString HPPFilenameOnly;
 177         wxString CPPFilename;
 178
 179 #if defined(__WIN32__)
 180
 181         wxStringTokenizer HPPFilenameTokens(HPPFilename, wxT("\\"));
 182         wxStringTokenizer DirFilenameTokens(dirfilename, wxT("\\"));
 183
 184 #else
 185
 186         wxStringTokenizer HPPFilenameTokens(HPPFilename, wxT("/"));
 187         wxStringTokenizer DirFilenameTokens(dirfilename, wxT("/"));
 188
 189 #endif
 190
 191         while (HPPFilenameTokens.HasMoreTokens()){
 192
 193                 HPPFilenameOnly = HPPFilenameTokens.GetNextToken();
 194
 195         }
 196
 197         while (DirFilenameTokens.HasMoreTokens()){
 198
 199                 DirFilenameOnly = DirFilenameTokens.GetNextToken();
 200
 201         }
 202
 203         // Make the directory filename upper case for writing to the
 204         // header file.
 205
 206         wxString CPPFileOnly;
 207
 208         finaldirname.Append(wxString::FromUTF8(DirFilenameOnly.c_str()));
 209         finaldirname.MakeUpper();
 210
 211         // Write out the header file inclusion guard.
 212
 213         HPPFilename.Append(wxT(".h"));
 214
 215 #if defined(__WIN32__)
 216
 217             hppfile.open(HPPFilename.wc_str(), ios::out | ios::trunc );
 218
 219 #else
 220
 221         hppfile.open(HPPFilename.c_str(), ios::out | ios::trunc );
 222
 223 #endif
 224
 225         hppfile << "#include <iostream>" << endl << endl;
 226         hppfile << "#ifndef " << finaldirname.ToStdString() << "_H" << endl;
 227         hppfile << "#define " << finaldirname.ToStdString() << "_H" << endl << endl;
 228         hppfile << "// List all CPP files in the directory." << endl << endl;
 229
 230         // Write each CPP file into the header file.
 231
 232         for (int f = 0; f < filelist.GetCount() ; f++){
 233
 234                 CPPFilename = filelist[f];
 235
 236 #if defined(__HAIKU__)
 237
 238 #elif defined(__WIN32__)
 239
 240                 wxStringTokenizer CPPFilenameTokenizer(CPPFilename, wxT("\\"));
 241
 242 #else
 243
 244                 wxStringTokenizer CPPFilenameTokenizer(CPPFilename, wxT("/"));
 245
 246 #endif
 247
 248                 while (CPPFilenameTokenizer.HasMoreTokens()){
 249
 250                         CPPFileOnly = CPPFilenameTokenizer.GetNextToken();
 251
 252                 }
 253
 254                 CPPFileOnly.RemoveLast(4);
 255                 CPPFileOnly.Append(wxT(".cpp"));
 256
 257                 hppfile << "#include \"" << DirFilenameOnly.ToStdString() <<
 258                         "/" << CPPFileOnly.ToStdString() << "\"" << endl;
 259
 260         }
 261
 262         // Write the end if and close the file.
 263
 264         hppfile << endl << "#endif" << endl << endl;
 265         hppfile.close();
 266
 267         // Increment the HPP file counter.
 268
 269         cout << "HPPDIR\t" << HPPFilename.ToStdString() << endl;
 270         ++*counter;
 271
 272 }
 273
 274 int main(int argc, char *argv[])
 275 {
 276
 277         int fp = 0;
 278         int cppg = 0;
 279         int hppg = 0;
 280
 281         wxArrayString dirlist;
 282         wxArrayString filelist;
 283         wxString BitmapHeaderFilename;
 284         wxString DirFilenameWxS;
 285
 286         // Check if completed file exists before doing anything
 287         // else and write an error message if it does exist.
 288
 289         if (wxFileExists(wxT("BitmapsDone"))){
 290
 291                 std::cout << "Bitmap files have already been generated!" << std::endl << std::endl;
 292                 std::cout << "To regenerate the files simply delete the BitmapsDone file where this helper application is run." << std::endl;
 293
 294                 return 0;
 295
 296         }
 297
 298         fstream finalhppfile;
 299
 300         if (!argv[1]){
 301                 std::cout << "Error: No directory name given!" << std::endl;
 302                 return -1;
 303         }
 304
 305         // Look in the subdirectories of the bitmaps directory and
 306         // collect the names of the directories.
 307
 308         std::cout << "Working out directories in bitmaps directory..." <<
 309         std::endl;
 310
 311         const char *dirarg = argv[1];
 312
 313         wxString BitmapDirName = wxString(dirarg, wxConvUTF8);
 314
 315 #if defined(__HAIKU__)
 316
 317 #elif defined(__WIN32__)
 318
 319         BitmapHeaderFilename.Append(BitmapDirName);
 320         BitmapHeaderFilename.Append(wxT("\\..\\Bitmaps.h"));
 321
 322 #else
 323
 324         BitmapHeaderFilename.Append(BitmapDirName);
 325         BitmapHeaderFilename.Append(wxT("/../Bitmaps.h"));
 326
 327 #endif
 328
 329         if ( wxDirExists(BitmapDirName) ){
 330
 331                 wxDir BitmapDir(BitmapDirName);
 332
 333                 wxString BitmapSubDir;
 334                 wxString BitmapSubDirFull;
 335
 336                 bool ContinueProcess = BitmapDir.GetFirst(&BitmapSubDir, wxEmptyString, wxDIR_DEFAULT);
 337
 338                 while (ContinueProcess){
 339
 340 #if defined(__HAIKU__)
 341
 342                         BitmapSubDirFull.Append(BitmapSubDir);
 343                         BitmapSubDirFull.Append();
 344
 345 #elif defined(__WIN32__)
 346
 347                         BitmapSubDirFull.Append(BitmapDirName);
 348                         BitmapSubDirFull.Append(wxT("\\"));
 349                         BitmapSubDirFull.Append(BitmapSubDir);
 350
 351 #else
 352
 353                         BitmapSubDirFull.Append(BitmapDirName);
 354                         BitmapSubDirFull.Append(wxT("/"));
 355                         BitmapSubDirFull.Append(BitmapSubDir);
 356
 357 #endif
 358
 359                         if (wxDirExists(BitmapSubDirFull)){
 360                                 dirlist.Add(BitmapSubDirFull);
 361                         }
 362
 363                         ContinueProcess = BitmapDir.GetNext(&BitmapSubDir);
 364
 365                         BitmapSubDirFull.Clear();
 366
 367                 }
 368
 369         } else {
 370                 std::cout << "Error: Bitmaps Directory doesn't exist!" << std::endl;
 371                 return 1;
 372         }
 373
 374         // Process each directory, generating a .cpp and .hpp file
 375         // for each image and then a final .hpp for the directory
 376         // containing the .hpp's for the directories.
 377
 378         if (dirlist.GetCount() == 0){
 379                 cout << "Error: No directories in the bitmaps folder. Unexpected behaviour!" << endl;
 380                 return 1;
 381         }
 382
 383         std::cout << "Looking in bitmaps folder for PNGs..." << std::endl;
 384
 385         DirFilenameWxS.Empty();
 386
 387         std::cout << BitmapHeaderFilename.ToStdString() << std::endl;
 388
 389 #if defined(__WIN32__)
 390
 391         finalhppfile.open(BitmapHeaderFilename.wc_str(), ios::out | ios::trunc);
 392
 393 #else
 394
 395         finalhppfile.open(BitmapHeaderFilename.c_str(), ios::out | ios::trunc);
 396
 397 #endif
 398
 399         finalhppfile << "#include <iostream>" << endl << endl;
 400         finalhppfile << "#ifndef BITMAPS_H" << endl;
 401         finalhppfile << "#define BITMAPS_H" << endl << endl;
 402
 403         for (int bi = 0; bi < dirlist.GetCount(); bi++)
 404         {
 405
 406                 wxString BitmapSubDirName = dirlist[bi];
 407                 wxString BitmapFilename;
 408                 wxDir BitmapSubDir(BitmapSubDirName);
 409
 410                 bool ContinueProcess = BitmapSubDir.GetFirst(&BitmapFilename, wxEmptyString, wxDIR_DEFAULT);
 411
 412                 while (ContinueProcess){
 413
 414                         if (BitmapFilename.Right(4) == wxT(".PNG") ||
 415
 416                                 BitmapFilename.Right(4) == wxT(".png")){
 417
 418 #if defined(__HAIKU__)
 419
 420                                 BitmapSubDirFull.Append(BitmapSubDir);
 421                                 BitmapSubDirFull.Append();
 422
 423 #elif defined(__WIN32__)
 424
 425                                 DirFilenameWxS.Append(wxString::FromUTF8(dirlist[bi].c_str()));
 426                                 DirFilenameWxS.Append(wxT("\\"));
 427                                 DirFilenameWxS.Append(wxString::FromUTF8(BitmapFilename.c_str()));
 428
 429 #else
 430
 431                                 DirFilenameWxS.Append(wxString::FromUTF8(dirlist[bi].c_str()));
 432                                 DirFilenameWxS.Append(wxString::FromUTF8("/"));
 433                                 DirFilenameWxS.Append(wxString::FromUTF8(BitmapFilename.c_str()));
 434
 435 #endif
 436
 437                                 filelist.Add(DirFilenameWxS);
 438
 439                         }
 440
 441                         DirFilenameWxS.Clear();
 442                         ContinueProcess = BitmapSubDir.GetNext(&BitmapFilename);
 443
 444                 }
 445
 446                 for (int fi = 0; fi < filelist.GetCount(); fi++)
 447                 {
 448
 449                         CreateCPPFile(dirlist[bi].ToStdString(), filelist[fi].ToStdString(), &cppg);
 450                         fp++;
 451
 452                 }
 453
 454                 if (filelist.GetCount() > 0)
 455                 {
 456
 457                         CreateHPPFileDir(dirlist[bi].wc_str(), filelist, &hppg);
 458
 459                 }
 460
 461                 filelist.Clear();
 462
 463                 wxString DirNameSplit;
 464
 465 #if defined(__HAIKU__)
 466
 467 #elif defined(__WIN32__)
 468
 469                 wxStringTokenizer DirListFile(dirlist[bi], wxT("\\"));
 470
 471 #else
 472
 473                 wxStringTokenizer DirListFile(dirlist[bi], wxT("/"));
 474
 475
 476 #endif
 477
 478                 while (DirListFile.HasMoreTokens()){
 479
 480                         DirNameSplit = DirListFile.GetNextToken();
 481
 482                 }
 483
 484 #if defined(__HAIKU__)
 485
 486 #elif defined(__WIN32__)
 487
 488                 finalhppfile << "#include \"Bitmaps\\" << DirNameSplit.ToStdString() <<
 489                         ".h\"" << endl;
 490
 491 #else
 492
 493                 finalhppfile << "#include \"Bitmaps/" << DirNameSplit.ToStdString() <<
 494                         ".h\"" << endl;
 495
 496 #endif
 497
 498         }
 499
 500         finalhppfile << endl << "#endif" << endl;
 501         finalhppfile.close();
 502         ++hppg;
 503
 504         // Print out the results.
 505
 506         std::cout << "Finished processing PNGs into code." << std::endl;
 507         std::cout << fp << " files processed." << std::endl;
 508         std::cout << cppg << " .cpp files generated." << std::endl;
 509         std::cout << hppg << " .hpp files generated." << std::endl;
 510
 511         // Write a success flag so that future runs won't take
 512         // place thus speeding up the compilation process as required.
 513
 514         fstream bitmapflag;
 515
 516         bitmapflag.open("BitmapsDone", ios::out | ios::trunc);
 517         bitmapflag << "Bitmaps as code generated. To recreate, simply delete the BitmapsDone file and run the bitmap code generation tool again." << endl;
 518         bitmapflag.close();
 519
 520         return 0;
 521
 522 }