Porting to the Qt C++ Framework :: Part 1

May 26th, 10 / 0 Comments /

In this post we’ll start the process of porting a simple command line C++ application to the Nokia Qt framework. Well take a quick look at the code in question, then talk about how we’ll port it.

The application in question is a simple tool for cleaning up the export of a Print Publishing CMS system for eventual use in a Web-based CMS. By simple I mean we open a folder and loop through it, diving into sub-folders as needed to:

  1. Remove all images tagged with a _bw_
  2. Open XML ’story’ files and remove extra line breaks from headline elements, and clean up content HTML.

The application started as an Apple Xcode project, and has now moved into NetBeans 6.8 on Linux. In the end I hope to learn a good deal about the Qt framework, as well as proper C++ application development.

How and why are we doing this?

Command line apps are only so useful, so the next natural step was to port it to a GUI. I had not done this before, so it would be an education experience. Perhpas you find yourself in a similar situation, stuck with a command line tool when a nice GUI would be preferred. Of course doing so can be intimidating at first, as in most cases the libraries needed to accomplish this task can be quite daunting.

To that end I we’ll use Qt (read: cute) because it’s open source for non-commercial apps, is incredibly powerful, cross-platform, easy to learn, and well documented.

The Code

So what have we got to work with? I did a fair bit of experimentation during the first pass, what we see here is the sanitized version with most comments and junk taken out. That said, it should work on *NIX based distributions, Windows is iffy, and not tested.

  1. /**
  2.  * Clean Up Prestige Export Files
  3.  *
  4.  * Removes all _bw_ images
  5.  * TODO: Clean up image names (remove non-acceptable characters)
  6.  * Removes all <br/> and \r \n from headlines
  7.  * Transforms body <br/> items into valid p tags
  8.  *
  9.  * @author Matthew Grdinic
  10.  * @organization Journal Interactive
  11.  * @date 5/19/10
  12.  * @version 0.2.0008
  13.  *
  14.  * TODO:
  15.  *
  16.  */
  17.  
  18. #include <iostream>
  19. #include <string>
  20. #include <dirent.h>
  21. #include <stdio.h>
  22. #include <fstream>
  23. #include <iterator>
  24.  
  25. #include <sys/types.h>
  26. #include <sys/stat.h>
  27. #include <unistd.h>
  28.  
  29. #define DEBUG false
  30.  
  31. using namespace std;
  32.  
  33. int main (int argc, char * const argv[]) {
  34.  
  35.  if(argc != 2)
  36.  {
  37.   fprintf(stderr,"Usage: %s [base xmlout dirname]\n",argv[0]);
  38.   return(1);
  39.  }
  40.  
  41.  const string br = "<br/>";
  42.  const string rl = "\r";
  43.  const string nl = "\n";
  44.  const string rn = "\r\n";
  45.  
  46.  const string openp = "<p>";
  47.  const string closep = "</p>";
  48.  const string doublebr = "<br/><br/>";
  49.  
  50.  
  51.  std::cout << endl << "======================";
  52.  std::cout << endl << "WELCOME TO THE CLEANER";
  53.  std::cout << endl << "======================";
  54.  
  55.  // path data
  56.  string basePath = argv[1];
  57.  string imagePath = basePath + "/images";
  58.  string storyPath = basePath + "/stories";
  59.  
  60.  int counter = 0;
  61.  
  62.  
  63.  // images
  64.  std::cout << endl << "Starting image clean…\n";
  65.  
  66.  DIR *d;
  67.  struct dirent *dir;
  68.  string name;
  69.  string location;
  70.  string path;
  71.  string replaceString;
  72.  int p;
  73.  d = opendir(imagePath.c_str());
  74.  
  75.  if(d){
  76.  
  77.   int found;
  78.  
  79.   while((dir = readdir(d)) != NULL){
  80.    name = dir->d_name;
  81.    found = name.rfind("_bw_");
  82.    if(found != -1){
  83.     path = imagePath;
  84.     location = imagePath + "/" + name;
  85.     cout << location << endl;
  86.     int t = remove(location.c_str());
  87.     if(t != -1){
  88.      counter++;
  89.     }
  90.    }
  91.   }
  92.  
  93.   cout << counter << " image file(s) were removed." << endl << endl;
  94.  
  95.  }
  96.  
  97.  // xml files
  98.  std::cout << "Starting file clean…\n";
  99.  
  100.  string fileData;
  101.  
  102.  d = opendir(storyPath.c_str());
  103.  
  104.  if(d){
  105.  
  106.   // low memory, no parallelization
  107.   while((dir = readdir(d)) != NULL){
  108.    name = dir->d_name;
  109.    location = storyPath + "/" + name;
  110.  
  111.    if(name != "." && name != ".." && name != ".DS_Store"){
  112.  
  113.     // ==> buffer
  114.  
  115.     // alternative version of buffer –
  116.     string fileData2;
  117.     string buff;
  118.     ifstream file;
  119.     file.open(location.c_str());
  120.  
  121.     while(getline(file, fileData2)){
  122.      buff += fileData2 + "\r\n";
  123.     }
  124.     fileData = buff;
  125.  
  126.  
  127.     // == remove extra headline data
  128.     int hl1Start = fileData.find("<hl1>");
  129.     int hl1End = fileData.find("</hl1>");
  130.  
  131.     if(hl1Start != -1 && hl1End != -1){
  132.  
  133.      replaceString = fileData.substr(hl1Start, (hl1End - hl1Start));
  134.  
  135.  
  136.      p = replaceString.find(br);
  137.      while(p != -1){
  138.       replaceString.erase(p, 5);
  139.       p = replaceString.find(br);
  140.      }
  141.  
  142.      p = replaceString.find(rl);
  143.      while(p != -1){
  144.       replaceString.erase(p, 2);
  145.       p = replaceString.find(rl);
  146.      }
  147.  
  148.      p = replaceString.find(nl);
  149.      while(p != -1){
  150.       replaceString.erase(p, 2);
  151.       p = replaceString.find(nl);
  152.      }
  153.  
  154.      // join data
  155.      fileData.replace(hl1Start, (hl1End - hl1Start), replaceString);
  156.  
  157.     } // hl1 exists
  158.  
  159.     int bodyStart = fileData.find("<body.content>");
  160.     int bodyEnd = fileData.find("</body.content>");
  161.  
  162.     int innerp;
  163.  
  164.     if(bodyStart != -1 && bodyEnd != -1){
  165.  
  166.      replaceString = fileData.substr(bodyStart, (bodyEnd - bodyStart));
  167.  
  168.      p = replaceString.find(doublebr);
  169.      counter = 0;
  170.      int matchingP = 0;
  171.      while(p != -1){
  172.  
  173.       replaceString.replace(p, doublebr.size(), openp);
  174.       matchingP = 1;
  175.  
  176.       // next \r\n [Mac Uses nl, Windows rn]
  177.       innerp = replaceString.find(rn, p);
  178.  
  179.       if(innerp != -1){
  180.        replaceString.replace(innerp, rn.size(), closep);
  181.        matchingP = 0;
  182.       }
  183.  
  184.       p = replaceString.find(doublebr, p);
  185.  
  186.       if(matchingP == 1){
  187.        #if DEBUG == true
  188.        cout << "Hanging p" << endl;
  189.        #endif
  190.        replaceString.append(closep);
  191.       }
  192.  
  193.       counter++;
  194.      }
  195.  
  196.      // join data
  197.      fileData.replace(bodyStart, (bodyEnd - bodyStart), replaceString);
  198.  
  199.     } // bodyEnd exists
  200.  
  201.  
  202.  
  203.     // save file
  204.     #if DEBUG == true
  205.     ofstream outfile((location + "-debug.xml").c_str(), ofstream::binary);
  206.     #else
  207.     ofstream outfile((location).c_str(), ofstream::binary);
  208.     #endif
  209.  
  210.     outfile.write(fileData.c_str(), fileData.size());
  211.  
  212.    }
  213.  
  214.   } // while()
  215.  
  216.  }
  217.  
  218.  
  219.     return 0;
  220. }

The Current Program

The program is broken into several logical sections: The first part of the program takes the user supplied command line argument of a folder and creates a simple variable: basePath. This path is then used to build the other locations of our sub-folder structure. Here we also define a few text constants used in the XML file cleanup step.

With a valid path, we loop though the images folder and delete any files with a _bw_ in the name. The _bw_ is for Black and White, and is a known quantity in this work-flow.

I should add at this point the folder structure we are traversing looks like:

xmlout

–images/

—-/image_files.jog

–null/

–stories/

—-/story.xml

—-/story.xml

The next step is slightly longer, here we need to clean up XML files. The process really isn’t important for the porting process, as we’ll probably end up with very similar code in the end anyway. The long and short of it though is at several places in the XML output are unclosed <p> tags, extra line breaks and formatting, and other general messiness that cause an XML import of these files to fail when going to the ‘target’ system.

The one thing I do want to pay attention to is the file read process. It’s in this area that we’ll probably find the most diversion from the command line app. In particular, I want to see how Qt makes file reading easier, and also, I want to explore parallelization at this step. I can envision reading in a batch of files, say, 50 at a time, and then spawning new threads to handle the clean up tasks.

Of course we then write the cleaned up files back to the system, something that again, could probably be done in concert with a parallel processing model.

More generally though, with a port I want to explore a more object oriented way of performing these steps, as well as adding more error and sanity checks.

Coming In Part 2

Stay tuned for part 2 where we’ll take a look at the ported code I’ve created thus far. We’ll talk about general Qt development, and what goals I have the project in general.

Code Download

A note of caution: This code has not been tested, and may not work on Windows. Of course this is one area a proper Qt port will help with!

main.cpp
Go To Part 2 –>
Link

C++
<< >>

Leave a Comment

* are Required fields