FWGUIEventDataAdder.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     Core
// Class  :     FWGUIEventDataAdder
//
// Implementation:
//     <Notes on implementation>
//
// Original Author:  Chris Jones
//         Created:  Fri Jun 13 09:58:53 EDT 2008
//

// system include files
#include <iostream>
#include <sigc++/signal.h>
#include <boost/bind.hpp>
#include <algorithm>
#include <cctype>
#include <string>

#include "TGFrame.h"
#include "TGTextEntry.h"
#include "TGButton.h"
#include "TGMsgBox.h"
#include "TClass.h"
#include "TFile.h"
#include "TTree.h"
#include "TBranch.h"

// user include files
#include "Fireworks/Core/src/FWGUIEventDataAdder.h"
#include "Fireworks/Core/interface/FWPhysicsObjectDesc.h"
#include "Fireworks/Core/interface/FWEventItemsManager.h"
#include "Fireworks/Core/interface/FWEventItem.h"
#include "Fireworks/Core/interface/FWItemAccessorFactory.h"
#include "Fireworks/Core/interface/FWJobMetadataManager.h"
#include "Fireworks/TableWidget/interface/FWTableWidget.h"
#include "Fireworks/TableWidget/interface/FWTableManagerBase.h"
#include "Fireworks/TableWidget/interface/FWTextTableCellRenderer.h"
#include "Fireworks/Core/interface/fwLog.h"
#include "Fireworks/Core/src/FWDialogBuilder.h"
//
// constants, enums and typedefs
//
static const std::string& dataForColumn( const FWJobMetadataManager::Data& iData, int iCol)
{
   switch (iCol) {
      case 0:
         return iData.purpose_;
         break;
      case 4:
         return iData.type_;
         break;
      case 1:
         return iData.moduleLabel_;
         break;
      case 2:
         return iData.productInstanceLabel_;
         break;
      case 3:
         return iData.processName_;
         break;
      default:
         break;
   }
   static const std::string s_blank;
   return s_blank;
}

static const unsigned int kNColumns = 5;
class DataAdderTableManager : public FWTableManagerBase {
public:
   DataAdderTableManager(FWJobMetadataManager *manager):
      m_manager(manager), m_selectedRow(-1), m_filter() 
   {
      reset();
   }

   int numberOfRows() const override {
      return m_row_to_index.size();
   }
   int numberOfColumns() const override {
      return kNColumns;
   }
   
   virtual void sortWithFilter(const char *filter)
   {
      m_filter = filter;
      sort(-1, sortOrder());
      dataChanged();
   }
   
   int unsortedRowNumber(int iSortedRowNumber) const override {
      return m_row_to_index[iSortedRowNumber];
   }

   void implSort(int col, bool sortOrder) override;
   std::vector<std::string> getTitles() const override {
      std::vector<std::string> returnValue;
      returnValue.reserve(kNColumns);
      returnValue.push_back("Purpose");
      returnValue.push_back("Module Label");
      returnValue.push_back("Product Instance Label");
      returnValue.push_back("Process Name");
      returnValue.push_back("C++ Class");
      return returnValue;
   }
   
   FWTableCellRendererBase* cellRenderer(int iSortedRowNumber, int iCol) const override
   {
      
      if(static_cast<int>(m_row_to_index.size())>iSortedRowNumber) {
         int unsortedRow =  m_row_to_index[iSortedRowNumber];
         const FWJobMetadataManager::Data& data = (m_manager->usableData())[unsortedRow];

         m_renderer.setData(dataForColumn(data,iCol),m_selectedRow==unsortedRow);
      } else {
         m_renderer.setData(std::string(),false);
      }
      return &m_renderer;
   }

   void setSelection (int row, int mask) {
      if(mask == 4) {
         if( row == m_selectedRow) {
            row = -1;
         }
      }
      changeSelection(row);
   }

   virtual const std::string title() const {
      return "Viewable Collections";
   }

   int selectedRow() const {
      return m_selectedRow;
   }
   //virtual void sort (int col, bool reset = false);
   virtual bool rowIsSelected(int row) const {
      return m_selectedRow == row;
   }

   void reset() {
      changeSelection(-1);
      m_row_to_index.clear();
      m_row_to_index.reserve(m_manager->usableData().size());
      for(unsigned int i =0; i < m_manager->usableData().size(); ++i) {
         m_row_to_index.push_back(i);
      }
      dataChanged();
   }
   sigc::signal<void,int> indexSelected_;
private:
   void changeSelection(int iRow) {
      if(iRow != m_selectedRow) {
         m_selectedRow=iRow;
         if(-1 == iRow) {
            indexSelected_(-1);
         } else {
            indexSelected_(iRow);
         }
         visualPropertiesChanged();
      }
   }
   FWJobMetadataManager* m_manager;
   std::vector<int>      m_row_to_index;
   int                   m_selectedRow;
   std::string           m_filter;
   mutable FWTextTableCellRenderer m_renderer;
};

namespace {
void strip(std::string &source, const char *str)
   {
      std::string remove(str);
      while(true)
      {
         size_t found = source.find(remove);
         if (found == std::string::npos)
            break;
         source.erase(found, remove.size());
      }
   }

   class SortAndFilter
   {
   public:
      SortAndFilter(const char *filter, int column, bool order, 
                    const std::vector<FWJobMetadataManager::Data> &data)
         : m_filter(filter),
           m_column(column),
           m_order(order),
           m_data(data)
         {
            simplify(m_filter);
            m_weights.resize(data.size());
            
            // Calculate whether or not all the entries match the given filter.
            // This is done only once, since it's invariant under permutations
            // of the data.
            for (size_t i = 0, e = m_weights.size(); i != e; ++i)
               m_weights[i] = matchesFilter(m_data[i]);
         }

      static void simplify(std::string &str)
      {
         std::transform(str.begin(), str.end(), str.begin(), tolower);
         strip(str, "std::");
         strip(str, "edm::");
         strip(str, "vector<");
         strip(str, "clonepolicy");
         strip(str, "ownvector");
         strip(str, "rangemap<");
         strip(str, "strictweakordering<");
         strip(str, "sortedcollection<");
         strip(str, "reco::");
         strip(str, "edmnew::");
      }
      
      unsigned int matches(const std::string &str) const
         {
            std::string up(str);
            simplify(up);
            const char *begin = up.c_str();
            
            // If the filter is empty, we consider anything as matching 
            // (i.e. it will not loop).
            // If the filter is not empty but the string to be matched is, we 
            // consider it as if it was not matching.
            if ((!m_filter.empty()) && str.empty())
               return 0;
            
            // There are two level of matching. "Full string" and 
            // "All characters". "Full string" matches return an higher weight 
            // and therefore should appear on top.
            if (strstr(begin, m_filter.c_str()))
               return 2;

            return 0;
         }
      
      unsigned int matchesFilter(const FWJobMetadataManager::Data &data) const
         {
            std::vector<unsigned int> scores;
            scores.reserve(10);
            scores.push_back(matches(data.purpose_));
            scores.push_back(matches(data.type_));
            scores.push_back(matches(data.moduleLabel_));
            scores.push_back(matches(data.productInstanceLabel_));
            scores.push_back(matches(data.processName_));
            std::sort(scores.begin(), scores.end());
            return scores.back();
         }
      
      bool operator()(const int &aIndex, const int &bIndex)
         {
            // In case no column is selected, we sort by relevance of the 
            // filter.
            if (m_column == -1)
               return m_weights[aIndex] >= m_weights[bIndex];

            const FWJobMetadataManager::Data &a = m_data[aIndex];
            const FWJobMetadataManager::Data &b = m_data[bIndex];

            if (m_order)
               return dataForColumn(a, m_column) < dataForColumn(b, m_column);
            else
               return dataForColumn(a, m_column) > dataForColumn(b, m_column);
         }
   private:
      std::string m_filter;
      int         m_column;
      bool        m_order;

      const std::vector<FWJobMetadataManager::Data> &m_data;
      std::vector<unsigned int>                      m_weights;
   };

   void doSort(int column,
               const char *filter,
               bool descentSort,
               const std::vector<FWJobMetadataManager::Data>& iData,
               std::vector<int>& oRowToIndex)
   {
      std::vector<int> ordered;
      ordered.reserve(iData.size());
      
      for (size_t i = 0, e = iData.size(); i != e; ++i)
         ordered.push_back(i);
      
      SortAndFilter sorter(filter, column, descentSort, iData);
      // GE: Using std::sort does not work for some reason... Bah...
      std::stable_sort(ordered.begin(), ordered.end(), sorter);

      oRowToIndex.clear();
      oRowToIndex.reserve(ordered.size());
      // Only keep track of the rows that match.
      for (size_t i = 0, e = ordered.size(); i != e; ++i)
         if (sorter.matchesFilter(iData[ordered[i]]) != 0)
            oRowToIndex.push_back(ordered[i]);
   }
}

void
DataAdderTableManager::implSort(int column, bool sortOrder)
{
   doSort(column, m_filter.c_str(), sortOrder, m_manager->usableData(), m_row_to_index);
}

//
// static data member definitions
//

//
// constructors and destructor
//

FWGUIEventDataAdder::FWGUIEventDataAdder(
   UInt_t iWidth,UInt_t iHeight,
   FWEventItemsManager* iManager,
   TGFrame* iParent,
   FWJobMetadataManager *iMetadataManager) 
   :
      m_manager(iManager),
      m_metadataManager(iMetadataManager),
      m_parentFrame(iParent)
{
   m_metadataManager->metadataChanged_.connect(boost::bind(&FWGUIEventDataAdder::metadataUpdatedSlot, this));
   createWindow();
}

// FWGUIEventDataAdder::FWGUIEventDataAdder(const FWGUIEventDataAdder& rhs)
// {
//    // do actual copying here;
// }

FWGUIEventDataAdder::~FWGUIEventDataAdder()
{
   /*
    // m_frame->Cleanup();
    // delete m_frame;
    m_frame=0;
    // delete m_tableWidget;
    m_tableWidget=0;
    delete m_tableManager;
    m_tableManager=0;
    */
}

//
// assignment operators
//
// const FWGUIEventDataAdder& FWGUIEventDataAdder::operator=(const FWGUIEventDataAdder& rhs)
// {
//   //An exception safe implementation is
//   FWGUIEventDataAdder temp(rhs);
//   swap(rhs);
//
//   return *this;
// }

//
// member functions
//
void
FWGUIEventDataAdder::addNewItem()
{
   TClass* theClass = TClass::GetClass(m_type.c_str());
   if(nullptr==theClass) {
      return;
   }
   const std::string moduleLabel = m_moduleLabel;
   if(moduleLabel.empty()) {
      return;
   }

   const std::string name = m_name->GetText();
   if(name.empty()) {
      return;
   }

   if ( m_manager->find( name ) ) {
      TString msg("Event item '");
      msg += name;
      msg += "' is already registered. Please use another name.";
      fwLog(fwlog::kWarning) << msg.Data() << std::endl;
      new TGMsgBox(gClient->GetDefaultRoot(), m_frame,
                   "Error - Name conflict", msg, kMBIconExclamation, kMBOk);
      return;
   }

   int largest = -1;
   if(m_manager->begin() != m_manager->end()) {
      if ( *(m_manager->begin()) )
         largest = (*(m_manager->begin()))->layer();
   }
   for(FWEventItemsManager::const_iterator it = m_manager->begin(),
                                           itEnd = m_manager->end();
       it!=itEnd;
       ++it) {
      if((*it) && largest < (*it)->layer()) {
         largest = (*it)->layer();
      }
   }
   ++largest;
   std::string processName = m_processName;
   if(m_doNotUseProcessName->IsOn() && m_doNotUseProcessName->IsEnabled()) {
      processName="";
   }
   FWPhysicsObjectDesc desc(name, theClass, m_purpose,
                            FWDisplayProperties::defaultProperties,
                            moduleLabel,
                            m_productInstanceLabel,
                            processName,
                            "",
                            largest);
   m_manager->add(desc);
}

void
FWGUIEventDataAdder::addNewItemAndClose()
{
   addNewItem();
   windowIsClosing();
}

void
FWGUIEventDataAdder::show()
{
   // Map main frame
   if(nullptr==m_frame) {
      createWindow();
   }
   m_frame->MapWindow();
}

void
FWGUIEventDataAdder::windowIsClosing()
{
   m_name->SetText("");
   m_search->SetText("");
   m_purpose.clear();
   m_type.clear();
   m_moduleLabel.clear();
   m_processName.clear();
   m_productInstanceLabel.clear();
   m_apply->SetEnabled(false);
   m_applyAndClose->SetEnabled(false);
   
   m_frame->UnmapWindow();
   m_frame->DontCallClose();
}

void
FWGUIEventDataAdder::updateFilterString(const char *str)
{
   m_tableManager->sortWithFilter(str);
   m_tableManager->dataChanged();
}

void
FWGUIEventDataAdder::createWindow()
{
   m_tableManager = new DataAdderTableManager(m_metadataManager);
   m_tableManager->indexSelected_.connect(boost::bind(&FWGUIEventDataAdder::newIndexSelected,this,_1));

   m_frame = new TGTransientFrame(gClient->GetDefaultRoot(),m_parentFrame,600,400);
   m_frame->Connect("CloseWindow()","FWGUIEventDataAdder",this,"windowIsClosing()");

   FWDialogBuilder builder(m_frame);
   TGTextButton *cancelButton, *resetButton;
   
   builder.indent(10)
          .spaceDown(15)
          .addLabel("Search:", 0).expand(false).spaceUp(4).floatLeft(4)
          .addTextEntry("", &m_search).spaceUp(0)
          .frameSpaceDown(10)
          .addLabel("Viewable Collections", 8)
          .frameSpaceDown(5)
          .addTable(m_tableManager, &m_tableWidget).expand(true, true)
          .addLabel("Name:", 0).expand(false).spaceUp(4).floatLeft(4)
          .addTextEntry("", &m_name).spaceUp(0).floatLeft(4)
          .addTextButton(" Reset  ", &resetButton).expand(false, false)
          .frameSpaceUpDown(5)
          .addCheckbox("Do not use Process Name and "
                       "instead only get this data "
                       "from the most recent Process",
                       &m_doNotUseProcessName)
          .frameSpaceDown(15)
          .hSpacer().floatLeft(0)
          .addTextButton(" Close  ", &cancelButton).expand(false).floatLeft(4)
          .addTextButton(" Add Data  ", &m_apply).expand(false).floatLeft(4)
          .addTextButton(" Add Data && Close  ", &m_applyAndClose).expand(false)
                                .spaceRight(25).spaceDown(15);

   m_search->Connect("TextChanged(const char *)", "FWGUIEventDataAdder", 
                     this, "updateFilterString(const char *)");
   m_search->SetEnabled(true);
   m_tableWidget->SetBackgroundColor(0xffffff);
   m_tableWidget->SetLineSeparatorColor(0x000000);
   m_tableWidget->SetHeaderBackgroundColor(0xececec);
   m_tableWidget->Connect("rowClicked(Int_t,Int_t,Int_t,Int_t,Int_t)",
                          "FWGUIEventDataAdder",this,
                          "rowClicked(Int_t,Int_t,Int_t,Int_t,Int_t)");

   m_tableWidget->disableGrowInWidth();
   m_name->SetState(true);
   resetButton->SetEnabled(true);
   resetButton->Connect("Clicked()", "FWGUIEventDataAdder", this, "resetNameEntry()");
   m_doNotUseProcessName->SetState(kButtonDown);
   cancelButton->Connect("Clicked()","FWGUIEventDataAdder", this, "windowIsClosing()");
   cancelButton->SetEnabled(true);
   m_apply->Connect("Clicked()", "FWGUIEventDataAdder", this, "addNewItem()");
   m_applyAndClose->Connect("Clicked()", "FWGUIEventDataAdder", this, "addNewItemAndClose()");
   
   m_frame->SetWindowName("Add Collection");
   m_frame->MapSubwindows();
   m_frame->Layout();
}

void
FWGUIEventDataAdder::metadataUpdatedSlot(void)
{
   m_tableManager->reset();
   m_tableManager->sort(0, true);
}

void
FWGUIEventDataAdder::resetNameEntry()
{
   m_name->SetText(m_apply->IsEnabled() ? m_moduleLabel.c_str() : "", kFALSE);
}

void
FWGUIEventDataAdder::newIndexSelected(int iSelectedIndex)
{
   if(-1 != iSelectedIndex) {
      std::vector<FWJobMetadataManager::Data> &metadata = m_metadataManager->usableData();
      m_purpose = metadata[iSelectedIndex].purpose_;
      m_type = metadata[iSelectedIndex].type_;
      std::string oldModuleLabel = m_moduleLabel;
      m_moduleLabel = metadata[iSelectedIndex].moduleLabel_;
      m_productInstanceLabel = metadata[iSelectedIndex].productInstanceLabel_;
      m_processName = metadata[iSelectedIndex].processName_;
      
      if(strlen(m_name->GetText())==0 || oldModuleLabel == m_name->GetText()) {
         m_name->SetText(m_moduleLabel.c_str());
      }
      m_apply->SetEnabled(true);
      m_applyAndClose->SetEnabled(true);

      //Check to see if this is the last process, if it is then we can let the user decide
      // to not use the process name when doing the lookup.  This makes a saved configuration
      // more robust.  However, if they choose a collection not from the last process then we need the
      // process name in order to correctly get the data they want
      bool isMostRecentProcess =true;
      int index = 0;
      for(std::vector<FWJobMetadataManager::Data>::iterator it = metadata.begin(), itEnd = metadata.end();
          it != itEnd && isMostRecentProcess;
          ++it,++index) {
         if(index == iSelectedIndex) {continue;}
         if(it->moduleLabel_ == m_moduleLabel &&
            it->purpose_ == m_purpose &&
            it->type_ == m_type &&
            it->productInstanceLabel_ == m_productInstanceLabel) {
            //see if this process is newer than the data requested
            
            for(size_t pni = 0, pne = m_metadataManager->processNamesInJob().size();
                pni != pne; ++pni) 
            {
               const std::string &processName = m_metadataManager->processNamesInJob()[pni];
               if (m_processName == processName)
                  break;

               if(it->processName_ == processName) 
               {
                  isMostRecentProcess = false;
                  break;
               }
            }
         }
      }
      if(isMostRecentProcess) {
         if(!m_doNotUseProcessName->IsEnabled()) {
            m_doNotUseProcessName->SetEnabled(true);
         }
      } else {
         //NOTE: must remember state before we get here because 'enable' and 'on' are mutually
         // exlcusive :(
         m_doNotUseProcessName->SetEnabled(false);
      }
   }
}

void 
FWGUIEventDataAdder::rowClicked(Int_t iRow,Int_t iButton,Int_t iKeyMod,Int_t,Int_t)
{
   if(iButton==kButton1) {
      m_tableManager->setSelection(iRow,iKeyMod);
   }
}

//
// const member functions
//

//
// static member functions
//