source/tools/bitmapcode.cpp

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