---

gstockcalc.cpp

/***************************************************************************
                          GStockCalc.cpp  -  description
                             -------------------
    begin                : Fri Oct 18 2002
    copyright            : (C) 2002 by Michael Otto
    email                : Michael.Otto@saskathex.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "gstockcalc.h"

#include "stockmarketvector.h"
#include "stockmarket.h"
#include "stockcontainer.h"
#include "stock.h"
#include "stockgui.h"
#include "preferencesdialog.h"
#include "addnewstock.h"
#include "removestock.h"
#include "movestock.h"
#include "addmarket.h"
#include "removemarket.h"
#include "editstockmarketnames.h"
#include "aboutdialog.h"
#include "xmlfileparser.h"
#include "preferences.h"
#include "summarydialog.h"
#include "changepageorder.h"

#include <gtkmm/stock.h>

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <time.h>

GStockCalc *GStockCalc::gStockCalcStatic = NULL;


GStockCalc::GStockCalc() {

  gStockCalcStatic = this;

  stockMarketVector = new StockMarketVector();
  preferences = new Preferences();

  // setting up window attributes
  set_title("gstockcalc");
  set_border_width(5);
  set_resizable(false);
  vbox = manage(new Gtk::VBox(false, 0));
  vbox->set_spacing(5);
  add(*vbox);
  fillMenu();

  // add an event box that can catch button_press events:
  vbox->pack_start(m_EventBox);
  m_EventBox.signal_button_press_event().connect( SigC::slot(*this, &GStockCalc::on_button_press_event) );
  fillPopUpMenu();

  vboxNotebookParent = manage(new Gtk::VBox(false, 0));
  vboxNotebookChild = manage(new Gtk::VBox(false, 0));
  m_EventBox.add(*vboxNotebookParent);
  vboxNotebookParent->pack_start(*vboxNotebookChild, Gtk::PACK_SHRINK, 0);

  // Loading the StockMarketVector from the save file, if it exists
  int i = strlen (getenv ("HOME"));
  strncpy(stockmarketVectorFilename, getenv ("HOME"), i);
  stockmarketVectorFilename[i] = '\0';
  i = strlen ("/.gstockcalc_stocks.xml");
  strncat(stockmarketVectorFilename, "/.gstockcalc_stocks.xml", i);
  if (fileNotExists(stockmarketVectorFilename)) {
    printf("~/.gstockcalc_stocks.xml does not exist; will create a new one!\n");
    createFile(stockmarketVectorFilename);
    stockMarketVector->createInitialMarkets();
    saveStockMarketVectorToFile();
  } else {
    // reading the stocks from a file
    XMLFileParser *parser = new XMLFileParser();
    parser->parsingTheXmlFile(stockmarketVectorFilename, stockMarketVector);
  }
  // Attaching the Observer "this" to all stockmarkets
  for (int i = 0; i < stockMarketVector->getNumberOfStockMarkets(); i++) {
    StockMarket *stockMarket = stockMarketVector->getStockMarket(i);
    stockMarket->attach(this);
  }

  // Loading the Preferences from the save file, if it exists
  i = strlen (getenv ("HOME"));
  strncpy(preferencesFilename, getenv ("HOME"), i);
  preferencesFilename[i] = '\0';
  i = strlen("/.gstockcalc");
  strncat(preferencesFilename, "/.gstockcalc", i);
  if (fileNotExists(preferencesFilename)) {
    printf("~/.gstockcalc does not exist; will create a new one!\n");
    createFile(preferencesFilename);
    savePreferencesToFile();
  } else {
    // reading the preferences from the file
    XMLFileParser *parser = new XMLFileParser();
    parser->parsingTheXmlFile(preferencesFilename, preferences);
  }

  // Attaching the Observer "this" to the stockmarketvector
  stockMarketVector->attach(this);
  this->update(stockMarketVector);
  // displaying all
  show_all();

}

void GStockCalc::fillMenu() {
  Gtk::Image *imageSave, *imageQuit, *imageAddStock, *imageRemoveStock, *imageMoveStock, *imageAddMarket, *imageRemoveMarket,
  *imagePreferences, *imageAbout, *imageEditStockMarketNames, *imageShowSummary, *imageChangePageOrder;

  //File menu:
  {
    Gtk::Menu::MenuList& menulist = m_Menu_File.items();
    imageSave = new Gtk::Image(Gtk::Stock::SAVE, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("_Save", Gtk::Menu::AccelKey("<control>s"), *imageSave,
                       SigC::slot(*this, &GStockCalc::eventButtonSaveToFile)));
    menulist.push_back(Gtk::Menu_Helpers::SeparatorElem());
    imagePreferences = new Gtk::Image(Gtk::Stock::PREFERENCES, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("Pr_eferences", *imagePreferences,
                       SigC::slot(*this, &GStockCalc::eventPreferences)));
    menulist.push_back(Gtk::Menu_Helpers::SeparatorElem());
    imageQuit = new Gtk::Image(Gtk::Stock::QUIT, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("_Quit",  Gtk::Menu::AccelKey("<control>q"), *imageQuit,
                       SigC::slot(*this, &GStockCalc::beforeQuit)));
  }
  //Manage menu:
  {
    Gtk::Menu::MenuList& menulist = m_Menu_Manage.items();
    imageAddStock = new Gtk::Image(Gtk::Stock::YES, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("_Add Stock",  Gtk::Menu::AccelKey("<control><alt>s"), *imageAddStock,
                       SigC::slot(*this, &GStockCalc::eventAddNewStock)));
    imageRemoveStock = new Gtk::Image(Gtk::Stock::NO, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("_Remove Stock", *imageRemoveStock,
                       SigC::slot(*this, &GStockCalc::eventRemoveStock)));
    imageMoveStock = new Gtk::Image(Gtk::Stock::CONVERT, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("_Move Stock", *imageMoveStock,
                       SigC::slot(*this, &GStockCalc::eventMoveStock)));
    menulist.push_back(Gtk::Menu_Helpers::SeparatorElem());
    imageAddMarket = new Gtk::Image(Gtk::Stock::YES, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("A_dd Market",  Gtk::Menu::AccelKey("<control><alt>m"), *imageAddMarket,
                       SigC::slot(*this, &GStockCalc::eventAddMarket)));
    imageRemoveMarket = new Gtk::Image(Gtk::Stock::NO, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("R_emove Market", *imageRemoveMarket,
                       SigC::slot(*this, &GStockCalc::eventRemoveMarket)));
    menulist.push_back(Gtk::Menu_Helpers::SeparatorElem());
    imageShowSummary = manage(new Gtk::Image(Gtk::Stock::JUMP_TO, Gtk::ICON_SIZE_MENU));
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("_Show summary on selected Stockmarket",  Gtk::Menu::AccelKey("<control>u"), *imageShowSummary,
                       SigC::slot(*this, &GStockCalc::eventShowSummary)));
    imageEditStockMarketNames = new Gtk::Image(Gtk::Stock::PREFERENCES, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("Ed_it Market names", *imageEditStockMarketNames,
                       SigC::slot(*this, &GStockCalc::eventEditStockMarketNames)));
    imageChangePageOrder = new Gtk::Image(Gtk::Stock::CONVERT, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("_Change page order", *imageChangePageOrder,
                       SigC::slot(*this, &GStockCalc::eventChangePageOrder)));

  }
  //Help menu:
  {
    Gtk::Menu::MenuList& menulist = m_Menu_Help.items();
    imageAbout = new Gtk::Image(Gtk::Stock::DIALOG_INFO, Gtk::ICON_SIZE_MENU);
    menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("_About", *imageAbout,
                       SigC::slot(*this, &GStockCalc::eventAboutDialog) ) );
  }

  //Add the menus to the MenuBar:
  m_MenuBar.items().push_back(Gtk::Menu_Helpers::MenuElem("_File", m_Menu_File) );
  m_MenuBar.items().push_back(Gtk::Menu_Helpers::MenuElem("_Manage", m_Menu_Manage) );
  m_MenuBar.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::Stock::HELP, m_Menu_Help) );

  //Add the MenuBar to the window:
  vbox->pack_start(m_MenuBar, Gtk::PACK_SHRINK, 0);
}

void GStockCalc::fillPopUpMenu() {

  Gtk::Image *imageShowSummary;
  // fill popup menu:
  Gtk::Menu::MenuList& menulist = m_Menu_Popup.items();

  imageShowSummary = manage(new Gtk::Image(Gtk::Stock::JUMP_TO, Gtk::ICON_SIZE_MENU));
  menulist.push_back(Gtk::Menu_Helpers::ImageMenuElem("_Show summary",  Gtk::Menu::AccelKey("<control>u"), *imageShowSummary,
                       SigC::slot(*this, &GStockCalc::eventShowSummary)));

  m_Menu_Popup.accelerate(*this);
}


GStockCalc::~GStockCalc() {
  delete preferences;
  Gtk::Table *table;
  for (int i = 0; i < stockMarketVector->getNumberOfStockMarkets(); i++) {
    table = tableStockMarket[i];
    delete table;
    tableStockMarket[i] = NULL;
  }
  // deleting the stockMarketVector causes a seg fault; reason: Observer - Subject problem
  //delete stockMarketVector;
}

void GStockCalc::beforeQuit() {
  if (preferences->getAutoSaveOnExit()) {
    quitAndSave();
  }
  if (preferences->getSaveDialogOnExit()) {
    Gtk::Window *win = new Gtk::Window();
    win->set_title("Message");
    win->set_modal(true);
    win->set_border_width(5);
    Gtk::VBox *box;
    Gtk::HButtonBox *buttonBox;
    Gtk::Button *buttonNo, *buttonYes;
    box = manage(new Gtk::VBox(false, 0));
    box->set_spacing(5);
    win->add(*box);
    Gtk::Label *label = manage(new Gtk::Label("Do you want to save the Stockmarket(s)/Stock(s)/..?"));
    box->pack_start(*label, Gtk::PACK_SHRINK, 0);
    Gtk::HSeparator *sep = manage(new Gtk::HSeparator());
    box->pack_start(*sep, Gtk::PACK_SHRINK, 0);
    buttonBox = manage( new Gtk::HButtonBox());
    buttonBox->set_spacing(5);
    box->pack_start(*buttonBox, Gtk::PACK_SHRINK, 0);
    buttonNo = manage( new Gtk::Button(Gtk::Stock::NO));
    buttonNo->signal_clicked().connect(slot(*this,&GStockCalc::quit));
    buttonBox->pack_start(*buttonNo, Gtk::PACK_SHRINK, 0);
    buttonYes = manage( new Gtk::Button(Gtk::Stock::YES));
    buttonYes->signal_clicked().connect(slot(*this,&GStockCalc::quitAndSave));
    buttonBox->pack_start(*buttonYes, Gtk::PACK_SHRINK, 0);
    win->show_all();
  } else {
    quit();
  }
}

void GStockCalc::quitAndSave() {
  saveStockMarketVectorToFile();
  quit();
}

void GStockCalc::quit() {
  savePreferencesToFile();
  Gtk::Main::quit();
}


void GStockCalc::saveStockMarketVectorToFile() {
  Stock *s;
  FILE *file;      // FILE pointer
  file = fopen(stockmarketVectorFilename, "w"); // create a file for writing
  if  (file == NULL) {
    printf("An error has occurred.\n");
  }
  fprintf(file,"<?xml version=\"1.0\"?>\n");
  fprintf(file,"<stocks>\n");
  //last save
  time_t t1;
  (void) time(&t1);
  tm *t;
  t = localtime(&t1);
  fprintf(file,"  <lastSave>%d/%d</lastSave>\n",t->tm_mon,t->tm_mday);

  for (int i = 0; i < stockMarketVector->getNumberOfStockMarkets(); i++) {
    StockMarket *stockMarket = stockMarketVector->getStockMarket(i);
    fprintf(file,"  <stockmarket>\n",stockMarket->getMarketName().c_str());
    fprintf(file,"    <name>%s</name>\n",stockMarket->getMarketName().c_str());
    for (int j = 0; j < stockMarket->getNumberOfStockContainer(); j++) {
      StockContainer *stockContainer = stockMarket->getStockContainer(j);
      Stock *stock = stockContainer->getStock();
      writeOneStockToFile(file, stock);
    }
    fprintf(file,"  </stockmarket>\n");
  }
  fprintf(file,"</stocks>\n");
  fclose(file); // now close the file
}


void GStockCalc::writeOneStockToFile(FILE *file, Stock *s) {
  fprintf(file,"    <stock>\n");
  fprintf(file,"      <name>%s</name>\n",(s->getName()).c_str());
  fprintf(file,"      <wkn>%s</wkn>\n",(s->getWkn()).c_str());
  fprintf(file,"      <buyingDate>%s</buyingDate>\n",(s->getBuyingDate()).c_str());
  fprintf(file,"      <amount>%d</amount>\n",s->getAmount());
  fprintf(file,"      <buyingRate>%.2f</buyingRate>\n",s->getBuyingRate());
  fprintf(file,"      <purchaseCost>%.2f</purchaseCost>\n",s->getPurchaseCost());
  fprintf(file,"      <currentMarketPrice>%.2f</currentMarketPrice>\n",s->getCurrentMarketPrice());
  fprintf(file,"      <values>\n");
  vector <float> values = s->getValuesVector();
  for (int i=0; i < values.size(); i++) {
    fprintf(file,"        <v>%.2f</v>\n",values[i]);
  }
  fprintf(file,"      </values>\n");
  fprintf(file,"    </stock>\n");
}


void GStockCalc::savePreferencesToFile() {
  FILE *file;      // FILE pointer
  file = fopen(preferencesFilename, "w"); // create a file for writing
  if  (file == NULL) {
    printf("An error has occurred.\n");
  }
  fprintf(file,"<?xml version=\"1.0\"?>\n");
  fprintf(file,"<preferences>\n");
  fprintf(file,"  <autoSaveOnExit>%i</autoSaveOnExit>\n",(int) preferences->getAutoSaveOnExit());
  fprintf(file,"  <saveDialogOnExit>%i</saveDialogOnExit>\n",(int) preferences->getSaveDialogOnExit());
  fprintf(file,"</preferences>\n");
  fclose(file); // now close the file
}


int GStockCalc::createFile(char *filename) {
  // creating file
  mode_t oldumask;
  int ret;
  oldumask = umask (0);
  ret = creat (filename, (S_IRUSR | S_IWUSR));
  umask (oldumask);
  return ret;
}

int GStockCalc::fileNotExists (char *filename) {
  struct stat naamstat;
  if ((stat (filename, &naamstat) == -1) && (errno == ENOENT)) return 1;
  else return 0;
}


void GStockCalc::eventButtonSaveToFile() {
  saveStockMarketVectorToFile();
}

void GStockCalc::eventPreferences() {
  new class PreferencesDialog(stockMarketVector, preferences);
}

void GStockCalc::eventAddNewStock() {
  new class AddNewStock(stockMarketVector);
}

void GStockCalc::eventRemoveStock() {
  new class RemoveStock(stockMarketVector);
}

void GStockCalc::eventMoveStock() {
  new class MoveStock(stockMarketVector);
}

void GStockCalc::eventAddMarket() {
  new class AddMarket(stockMarketVector);
}

void GStockCalc::eventRemoveMarket() {
  new class RemoveMarket(stockMarketVector);
}

void GStockCalc::eventEditStockMarketNames() {
  new class EditStockMarketNames(stockMarketVector);
}

void GStockCalc::eventAboutDialog() {
  new class AboutDialog();
}

void GStockCalc::eventShowSummary() {
  new class SummaryDialog(stockMarketVector, notebook->get_current_page());
}

void GStockCalc::eventChangePageOrder() {
  new class ChangePageOrder(stockMarketVector);
}

gint GStockCalc::delete_event_impl(GdkEventAny *event) {
  beforeQuit();
  return 0;
}

bool GStockCalc::on_button_press_event(GdkEventButton* event) {
  if ((event->type == GDK_BUTTON_PRESS) && ((event->button == 1) || (event->button == 3))) {
    m_Menu_Popup.popup(event->button, event->time);
    return true; //It has been handled.
  } else {
    return false;
  }
}


void GStockCalc::fillTable(int tableStockMarketNumber) {
  Gtk::Label *label;
  Gtk::SpinButton *spinButton;
  Gtk::Button *button;

  Gtk::Table *table = tableStockMarket[tableStockMarketNumber];
  this->fillTableWithLabels(table);

  // Market == "All"
  if (tableStockMarketNumber == 0 ) {
    int offset = 0;
    for (int j = 0; j < stockMarketVector->getNumberOfStockMarkets(); j++) {
      StockMarket *stockMarket = stockMarketVector->getStockMarket(j);
      for (int i = 0; i < stockMarket->getNumberOfStockContainer(); i++) {
        StockContainer *stockContainer = stockMarket->getStockContainer(i);
        // refreshing the gui elements
        Stock *s = stockContainer->getStock();
        StockGui *sg = manage(new StockGui(s));

        table->attach(*sg, 0, 1, i+2+offset, i+3+offset);
        label = sg->getLabelWkn();
        table->attach(*label, 1, 2, i+2+offset, i+3+offset);
        label = sg->getLabelBuyingDate();
        table->attach(*label, 2, 3, i+2+offset, i+3+offset);
        spinButton = sg->getSpinButtonAmount();
        table->attach(*spinButton, 3, 4, i+2+offset, i+3+offset);
        spinButton = sg->getSpinButtonBuyingRate();
        table->attach(*spinButton, 4, 5, i+2+offset, i+3+offset);
        label = sg->getLabelPurchaseValue();
        table->attach(*label, 5, 6, i+2+offset, i+3+offset);
        vSep = manage(new Gtk::VSeparator());
        table->attach(*vSep, 6, 7, i+2+offset, i+3+offset);
        spinButton = sg->getSpinButtonCurrentMarketPrice();
        table->attach(*spinButton, 7, 8, i+2+offset, i+3+offset);
        label = sg->getLabelDayPerformance();
        table->attach(*label, 8, 9, i+2+offset, i+3+offset);
        label = sg->getLabelTotalMarketValue();
        table->attach(*label, 9, 10, i+2+offset, i+3+offset);
        label = sg->getLabelOverallPerformance();
        table->attach(*label, 10, 11, i+2+offset, i+3+offset);
        button = sg->getButtonInfo();
        table->attach(*button, 11, 12, i+2+offset, i+3+offset);
        button = sg->getButtonChart();
        table->attach(*button, 12, 13, i+2+offset, i+3+offset);
      }
      offset += stockMarket->getNumberOfStockContainer();
    }
    // other markets, not "All"
  } else {
    StockMarket *stockMarket = stockMarketVector->getStockMarket(tableStockMarketNumber - 1);
    for (int i = 0; i < stockMarket->getNumberOfStockContainer(); i++) {
      StockContainer *stockContainer = stockMarket->getStockContainer(i);
      // refreshing the gui elements
      Stock *s = stockContainer->getStock();
      StockGui *sg = manage(new StockGui(s));

      table->attach(*sg, 0, 1, i+2, i+3);
      label = sg->getLabelWkn();
      table->attach(*label, 1, 2, i+2, i+3);
      label = sg->getLabelBuyingDate();
      table->attach(*label, 2, 3, i+2, i+3);
      spinButton = sg->getSpinButtonAmount();
      table->attach(*spinButton, 3, 4, i+2, i+3);
      spinButton = sg->getSpinButtonBuyingRate();
      table->attach(*spinButton, 4, 5, i+2, i+3);
      label = sg->getLabelPurchaseValue();
      table->attach(*label, 5, 6, i+2, i+3);
      vSep = manage(new Gtk::VSeparator());
      table->attach(*vSep, 6, 7, i+2, i+3);
      spinButton = sg->getSpinButtonCurrentMarketPrice();
      table->attach(*spinButton, 7, 8, i+2, i+3);
      label = sg->getLabelDayPerformance();
      table->attach(*label, 8, 9, i+2, i+3);
      label = sg->getLabelTotalMarketValue();
      table->attach(*label, 9, 10, i+2, i+3);
      label = sg->getLabelOverallPerformance();
      table->attach(*label, 10, 11, i+2, i+3);
      button = sg->getButtonInfo();
      table->attach(*button, 11, 12, i+2, i+3);
      button = sg->getButtonChart();
      table->attach(*button, 12, 13, i+2, i+3);
    }
  }
}


void GStockCalc::fillTableWithLabels(Gtk::Table *table) {
  Gtk::Label *label;
  label = manage (new Gtk::Label("Name", 0));
  table->attach(*label, 0, 1, 0, 1);
  label = manage (new Gtk::Label("ID/WKN", 0));
  table->attach(*label, 1, 2, 0, 1);
  label = manage (new Gtk::Label("Purchase Date", 0));
  table->attach(*label, 2, 3, 0, 1);
  label = manage (new Gtk::Label("Amount", 0));
  table->attach(*label, 3, 4, 0, 1);
  label = manage (new Gtk::Label("Buying rate", 0));
  table->attach(*label, 4, 5, 0, 1);
  label = manage (new Gtk::Label("Purchase value", 0));
  table->attach(*label, 5, 6, 0, 1);
  vSep = manage(new Gtk::VSeparator());
  table->attach(*vSep, 6, 7, 0, 1);

  label = manage (new Gtk::Label("current price", 0));
  table->attach(*label, 7, 8, 0, 1);
  label = manage (new Gtk::Label("Day perf.", 0));
  table->attach(*label, 8, 9, 0, 1);
  label = manage (new Gtk::Label("total market value", 0));
  table->attach(*label, 9, 10, 0, 1);
  label = manage (new Gtk::Label("Overall perf.", 0));
  table->attach(*label, 10, 11, 0, 1);

  hSep = manage(new Gtk::HSeparator());
  table->attach(*hSep, 0, 13, 1, 2);
}



void GStockCalc::update(const Subject *const subject) {

  Gtk::VBox *vboxHelpChild, *vboxHelpParent;
  Gtk::Table *tableHelp;//, *tableNew;

#ifdef DEBUG
  printf("GStockCalc::update()\n");
#endif
  for (int i = 0; i < stockMarketVector->getNumberOfStockMarkets(); i++) {
    StockMarket *stockMarket = stockMarketVector->getStockMarket(i);
    if (stockMarket == subject) {
      updateStockMarketNotebookPage(stockMarket, i);
    }
  }

  if (stockMarketVector == subject) {
#ifdef DEBUG
    printf("  stockMarketVector has changed\n");
    int size = stockMarketVector->getNumberOfStockMarkets();
    printf("  size: %d\n",size);
    for (int i = 0; i < size; i++) {
      StockMarket *stockMarket = stockMarketVector->getStockMarket(i);
      printf("  %d. market: %s\n", i, stockMarket->getMarketName().c_str());
    }
#endif
    delete vboxNotebookChild;
    vboxNotebookChild = manage(new Gtk::VBox(false, 0));
    vboxNotebookParent->pack_start(*vboxNotebookChild, Gtk::PACK_SHRINK, 0);
    notebook = manage(new Gtk::Notebook());
    vboxNotebookChild->pack_start(*notebook, Gtk::PACK_SHRINK, 0);

    Gtk::Table *table;

    // creating the GUI elements for the StockMarket "All"
    // sum up number of stocks over all StockMarkets
    int sum = 0;
    for (int i = 0; i < stockMarketVector->getNumberOfStockMarkets(); i++) {
      StockMarket *stockMarket = stockMarketVector->getStockMarket(i);
      sum += stockMarket->getNumberOfStockContainer();
    }
    vboxHelpParent = manage(new Gtk::VBox(false, 0));
    vboxHelpParent->set_spacing(5);
    vboxHelpParent->set_border_width(5);
    notebook->append_page(*vboxHelpParent ,"All", "", true);
    // save the object to an array
    vboxParentStockMarket[0] = vboxHelpParent;
    vboxHelpChild = manage(new Gtk::VBox(false, 0));
    // save the object to an array
    vboxChildStockMarket[0] = vboxHelpChild;
    vboxHelpParent->pack_start(*vboxHelpChild, Gtk::PACK_EXPAND_WIDGET, 0);
    if (sum > 0) {
      table = manage(new Gtk::Table(sum, 13, false));
    } else {
      table = manage(new Gtk::Table(1, 13, false));
    }
    table->set_spacings(10);
    vboxHelpChild->pack_start(*table, Gtk::PACK_SHRINK, 0);
    // save the object to an array
    tableStockMarket[0] = table;

    // creating the GUI elements for each StockMarket
    for (int i = 0; i < stockMarketVector->getNumberOfStockMarkets(); i++) {
      StockMarket *stockMarket = stockMarketVector->getStockMarket(i);
      int tableSize = stockMarket->getNumberOfStockContainer();

      vboxHelpParent = manage(new Gtk::VBox(false, 0));
      vboxHelpParent->set_spacing(5);
      vboxHelpParent->set_border_width(5);
      notebook->append_page(*vboxHelpParent ,stockMarket->getMarketName(), "", true);
      // save the object to an array
      vboxParentStockMarket[i+1] = vboxHelpParent;
      vboxHelpChild = manage(new Gtk::VBox(false, 0));
      // save the object to an array
      vboxChildStockMarket[i+1] = vboxHelpChild;
      vboxHelpParent->pack_start(*vboxHelpChild, Gtk::PACK_EXPAND_WIDGET, 0);
      if (tableSize > 0) {
        table = manage(new Gtk::Table(tableSize, 13, false));
      } else {
        table = manage(new Gtk::Table(1, 13, false));
      }
      table->set_spacings(10);
      vboxHelpChild->pack_start(*table, Gtk::PACK_SHRINK, 0);
      // save the object to an array
      tableStockMarket[i+1] = table;
      updateStockMarketNotebookPage(stockMarket,i);
    }
  }
  updateStockMarketAllNotebookPage();
  for (int i = notebook->get_n_pages()-1; i >= 0; i--) {
    notebook->set_current_page(i);
  }
  set_size_request(-1,-1);
  show_all();
}

void GStockCalc::updateStockMarketNotebookPage(StockMarket *stockMarket, int stockMarketNumber) {
  Gtk::VBox *vboxHelpChild, *vboxHelpParent;
  Gtk::Table *tableHelp, *tableNew;

  // update label: stockmarket name
  Widget* widget = notebook->get_nth_page(stockMarketNumber+1);
  notebook->set_tab_label_text(*widget, stockMarket->getMarketName());

#ifdef DEBUG
  printf("StockMarket %s has changed.\n",stockMarket->getMarketName().c_str());
#endif
  vboxHelpChild = vboxChildStockMarket[stockMarketNumber+1];
  // update tableStockMarket[i+1]
  int tableSize = stockMarket->getNumberOfStockContainer();
  if (tableSize > 0) {
    tableNew = manage(new Gtk::Table(tableSize, 13, false));
  } else {
    tableNew = manage(new Gtk::Table(1, 13, false));
  }
  tableNew->set_spacings(10);
  vboxHelpChild->pack_start(*tableNew, Gtk::PACK_SHRINK, 0);
  // creating vector tableStockMarketNew
  tableHelp = tableStockMarket[stockMarketNumber+1];
  delete tableHelp;
  tableStockMarket[stockMarketNumber+1] = tableNew;
  fillTable(stockMarketNumber+1);
}

void GStockCalc::updateStockMarketAllNotebookPage() {
  // update tableStockMarket[0] == "All"
  // creating the GUI elements for the StockMarket "All"
  // sum up number of stocks over all StockMarkets

  Gtk::VBox *vboxHelpChild;
  Gtk::Table *tableHelp, *tableNew;

#ifdef DEBUG
  printf("All has changed.\n");
#endif
  vboxHelpChild = vboxChildStockMarket[0];
  int sum = 0;
  for (int i = 0; i < stockMarketVector->getNumberOfStockMarkets(); i++) {
    StockMarket *stockMarket = stockMarketVector->getStockMarket(i);
    sum += stockMarket->getNumberOfStockContainer();
  }
  if (sum > 0) {
    tableNew = manage(new Gtk::Table(sum, 13, false));
  } else {
    tableNew = manage(new Gtk::Table(1, 13, false));
  }
  tableNew->set_spacings(10);
  vboxHelpChild->pack_start(*tableNew, Gtk::PACK_SHRINK, 0);
  // creating vector tableStockMarketNew
  tableHelp = tableStockMarket[0];
  delete tableHelp;
  tableStockMarket[0] = tableNew;
  this->fillTable(0);
}

---