GoogleChart.cpp

00001 /**
00002  * GoogleChart API interface driver. (Version 0.0.1)
00003  *
00004  * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
00005  * http://shinta.main.jp/
00006  */
00007 
00008 #include "GoogleChart.h"
00009 
00010 const std::string GoogleChart::baseURL = "http://chart.apis.google.com/chart";
00011 
00012 GoogleChart::GoogleChart() : title(""), width(300), height(225) {
00013     for (int i = 0; i < MAX_AXIS; i++) {
00014         axislist[i] = 0;
00015     }
00016     for (int i = 0; i < MAX_DATA; i++) {
00017         datalist[i] = 0;
00018     }
00019 }
00020 
00021 GoogleChart::~GoogleChart() {}
00022 
00023 int GoogleChart::addNewAxis(Axis::Type type) {
00024     /*
00025      * Search maximum number of axis.
00026      */
00027     int max = 0;
00028     for (int i = 0; i < MAX_AXIS; i++) {
00029         if (0 != axislist[i]) {
00030             if (axislist[i]->getNumber() > max) {
00031                 max = axislist[i]->getNumber();
00032             }
00033         }
00034     }
00035 
00036     /*
00037      * Create a new axis.
00038      */
00039     for (int i = 0; i < MAX_AXIS; i++) {
00040         if (0 == axislist[i]) {
00041             axislist[i] = new Axis(max + 1, type);
00042             return max + 1;
00043         }
00044     }
00045     return -1;
00046 }
00047 
00048 int GoogleChart::setAxisType(const int number, Axis::Type type) {
00049     for (int i = 0; i < MAX_AXIS; i++) {
00050         if (0 != axislist[i]) {
00051             if (axislist[i]->getNumber() == number) {
00052                 axislist[i]->setType(type);
00053                 return number;
00054             }
00055         }
00056     }
00057     return -1;
00058 }
00059 
00060 int GoogleChart::setAxisRange(const int number, int rangeStart, int rangeEnd) {
00061     for (int i = 0; i < MAX_AXIS; i++) {
00062         if (0 != axislist[i]) {
00063             if (axislist[i]->getNumber() == number) {
00064                 axislist[i]->setRangeStart(rangeStart);
00065                 axislist[i]->setRangeEnd(rangeEnd);
00066                 return number;
00067             }
00068         }
00069     }
00070     return -1;
00071 }
00072 
00073 int GoogleChart::removeAxis(const int number) {
00074     for (int i = 0; i < MAX_AXIS; i++) {
00075         if (0 != axislist[i]) {
00076             if (axislist[i]->getNumber() == number) {
00077                 delete axislist[i];
00078                 axislist[i] = 0;
00079                 return number;
00080             }
00081         }
00082     }
00083     return -1;
00084 }
00085 
00086 int GoogleChart::addNewDataSet(std::string label, const int size) {
00087     /*
00088      * Search maximum number of data set.
00089      */
00090     int max = 0;
00091     for (int i = 0; i < MAX_DATA; i++) {
00092         if (0 != datalist[i]) {
00093             if (datalist[i]->getNumber() > max) {
00094                 max = datalist[i]->getNumber();
00095             }
00096         }
00097     }
00098 
00099     /*
00100      * Create a new data set.
00101      */
00102     for (int i = 0; i < MAX_DATA; i++) {
00103         if (0 == datalist[i]) {
00104             datalist[i] = new DataSet(label, max + 1, size);
00105             return max + 1;
00106         }
00107     }
00108     return -1;
00109 }
00110 
00111 int GoogleChart::removeDataSet(const int number) {
00112     for (int i = 0; i < MAX_DATA; i++) {
00113         if (0 != datalist[i]) {
00114             if (datalist[i]->getNumber() == number) {
00115                 delete datalist[i];
00116                 datalist[i] = 0;
00117                 return number;
00118             }
00119         }
00120     }
00121     return -1;
00122 }
00123 
00124 int GoogleChart::addData(const int number, double data) {
00125     for (int i = 0; i < MAX_DATA; i++) {
00126         if (0 != datalist[i]) {
00127             if (datalist[i]->getNumber() == number) {
00128                 datalist[i]->addData(data);
00129                 return i;
00130             }
00131         }
00132     }
00133     return -1;
00134 }
00135 
00136 int GoogleChart::clearAllData(const int number) {
00137     for (int i = 0; i < MAX_DATA; i++) {
00138         if (0 != datalist[i]) {
00139             if (datalist[i]->getNumber() == number) {
00140                 datalist[i]->clearAllData();
00141                 return i;
00142             }
00143         }
00144     }
00145     return -1;
00146 }
00147 
00148     int GoogleChart::setDataScale(const int number, int min, int max) {
00149     for (int i = 0; i < MAX_DATA; i++) {
00150         if (0 != datalist[i]) {
00151             if (datalist[i]->getNumber() == number) {
00152                 datalist[i]->setScale(min, max);
00153                 return i;
00154             }
00155         }
00156     }
00157     return -1;
00158     }
00159 
00160 void GoogleChart::setTitle(std::string title) {
00161     GoogleChart::title = title;
00162 }
00163 
00164 std::string GoogleChart::getTitle() const {
00165     return title;
00166 }
00167 
00168 void GoogleChart::setWidth(int width) {
00169     GoogleChart::width = width;
00170 }
00171 
00172 int GoogleChart::getWidth() const {
00173     return width;
00174 }
00175 
00176 void GoogleChart::setHeight(int height) {
00177     GoogleChart::height = height;
00178 }
00179 
00180 int GoogleChart::getHeight() const {
00181     return height;
00182 }
00183 
00184 std::string GoogleChart::toURL(std::string text) {
00185     static const char *unsafe_characters = " \"<>#%{}|\\^~[]`";
00186     std::string s = "";
00187     for (int i = 0; i < text.length(); i++) {
00188         char c = text.at(i);
00189         if (strchr(unsafe_characters, c) == NULL) {
00190             s = s + c;
00191         } else {
00192             char buf[8];
00193             snprintf(buf, sizeof(buf), "%%%02X", c & 0xff);
00194             s = s + std::string(buf);
00195         }
00196     }
00197     return s;
00198 }
00199 
00200 std::string GoogleChart::paramChartType(ChartType chartType) {
00201     /*
00202      * Chart Type.
00203      */
00204     std::string s = "cht=";
00205     switch (chartType) {
00206         case LineChart:
00207             s = s + "lc";
00208             break;
00209         default:
00210             s = s + "unknown";
00211             break;
00212     }
00213     return s;
00214 }
00215 
00216 std::string GoogleChart::paramAxis(Axis **list, int size) {
00217 
00218     char buf[64];
00219     /*
00220      * Axis type and range.
00221      */
00222     int cnt = 0;
00223     std::string sType = "chxt=";
00224     std::string sRange = "chxr=";
00225     for (int i = 0; i < size; i++) {
00226         Axis *p = list[i];
00227         if (0 != p) {
00228             /*
00229              * Type.
00230              */
00231             if (0 < cnt) {
00232                 sType = sType + ",";
00233             }
00234             switch (p->getType()) {
00235                 case Axis::Bottom:
00236                     sType = sType + "x";
00237                     break;
00238                 case Axis::Left:
00239                     sType = sType + "y";
00240                     break;
00241                 case Axis::Right:
00242                     sType = sType + "r";
00243                     break;
00244                 case Axis::Top:
00245                     sType = sType + "t";
00246                     break;
00247                 default:
00248                     sType = sType + "?";
00249                     break;
00250             }
00251             /*
00252              * Range.
00253              */
00254             if (0 < cnt) {
00255                 sRange = sRange + "|";
00256             }
00257             snprintf(buf, sizeof(buf), "%d,%d,%d", cnt, p->getRangeStart(), p->getRangeEnd());
00258             sRange = sRange + std::string(buf);
00259             /*
00260              * Next.
00261              */
00262             cnt++;
00263         }
00264     }
00265 
00266     return sRange + "&" + sType;
00267 }
00268 
00269 std::string GoogleChart::paramDataSet(DataSet **list, int size) {
00270     char buf[64];
00271     int cnt = 0;
00272     std::string sData = "chd=t:";
00273     std::string sScale = "chds=";
00274     std::string sLabel = "chdl=";
00275     for (int i = 0; i < size; i++) {
00276         DataSet *p = list[i];
00277         if (0 != p) {
00278             /*
00279              * Data.
00280              */
00281             if (0 < cnt) {
00282                 sData = sData + "|";
00283             }
00284             for (int i = 0; i < p->getDataCount(); i++) {
00285                 double d = p->getData(i);
00286                 snprintf(buf, sizeof(buf), "%.3f", d);
00287                 if (0 < i) {
00288                     sData = sData + ",";
00289                 }
00290                 sData = sData + std::string(buf);
00291             }
00292             /*
00293              * Range.
00294              */
00295             if (0 < cnt) {
00296                 sScale = sScale + ",";
00297             }
00298             snprintf(buf, sizeof(buf), "%.3f,%.3f", p->getMin(), p->getMax());
00299             sScale = sScale + std::string(buf);
00300             /*
00301              * Label.
00302              */
00303             if (0 < cnt) {
00304                 sLabel = sLabel + "|";
00305             }
00306             sLabel = sLabel + p->getLabel();
00307             /*
00308              * Next.
00309              */
00310             cnt++;
00311         }
00312     }
00313 
00314     return sScale + "&" + sData + "&" + sLabel;
00315 }
00316 
00317 std::string GoogleChart::paramTitle(std::string title, int color, double fontSize) {
00318     char buf[64];
00319     std::string s = "";
00320     /*
00321      * Chart Title Text.
00322      */
00323     s = s + "chtt=" + title;
00324     /*
00325      * Chart Title Specification.
00326      */
00327     snprintf(buf, sizeof(buf), "&chts=%06X,%.1f", color, fontSize);
00328     s = s + std::string(buf);
00329     return s;
00330 }
00331 
00332 std::string GoogleChart::paramSize(int width, int height) {
00333     char buf[64];
00334     /*
00335      * Chart Size.
00336      */
00337     snprintf(buf, sizeof(buf), "chs=%dx%d", width, height);
00338     return std::string(buf);
00339 }