TinkerCell Core 1.0
TinkerCell's Core library providing all basic functionalities
SymbolsTable.cpp
Go to the documentation of this file.
00001 /****************************************************************************
00002 
00003 Copyright (c) 2008 Deepak Chandran
00004 Contact: Deepak Chandran (dchandran1@gmail.com)
00005 See COPYRIGHT.TXT
00006 
00007 This file defines the class that stores all symbols, such as node and 
00008 connection names and data columns and rows, for each scene
00009 
00010 ****************************************************************************/
00011 #include "MainWindow.h"
00012 #include "NetworkWindow.h"
00013 #include "NetworkHandle.h"
00014 #include "GraphicsScene.h"
00015 #include "TextEditor.h"
00016 #include "Tool.h"
00017 #include "SymbolsTable.h"
00018 #include "ConsoleWindow.h"
00019 
00020 namespace Tinkercell
00021 {
00022 
00023         SymbolsTable::SymbolsTable(NetworkHandle * net) : network(net)
00024         {
00025                 globalHandle.network = net;
00026         }
00027         
00028         void SymbolsTable::update(int n)
00029         {
00030                 if (!network) return;
00031                 
00032                 GraphicsScene* scene = 0;
00033                 TextEditor * editor = 0;
00034                 QList<NetworkWindow*> windows = network->networkWindows;
00035                 
00036                 QList<ItemHandle*> handles;
00037                 handles << &globalHandle;
00038 
00039                 for (int j=0; j < windows.size(); ++j)
00040                         if (windows[j] && !windows[j]->handle)
00041                         {
00042                                 if (windows[j]->scene)
00043                                 {
00044                                         QList<QGraphicsItem*> items = windows[j]->scene->items();
00045                                         ItemHandle * handle;
00046 
00047                                         for (int i=0; i < items.size(); ++i)
00048                                                 if (handle = getHandle(items[i]))
00049                                                 {
00050                                                         handle = handle->root();
00051                                                         if (handle && !handles.contains(handle))
00052                                                         {
00053                                                                 handles << handle;
00054                                                                 handles << handle->allChildren();
00055                                                         }
00056                                                 }
00057                                 }
00058                                 else
00059                                 if (windows[j]->editor)
00060                                 {
00061                                         QList<ItemHandle*> items = windows[j]->editor->allItems;
00062                                         ItemHandle * handle;
00063 
00064                                         for (int i=0; i < items.size(); ++i)
00065                                                 if (handle = items[i])
00066                                                 {
00067                                                         handle = handle->root();
00068                                                         if (handle && !handles.contains(handle))
00069                                                         {
00070                                                                 handles << handle;
00071                                                                 handles << handle->allChildren();
00072                                                         }
00073                                                 }
00074                                 }
00075                         }
00076 
00077                 update(handles);
00078                 
00079                 network->emitHistoryChanged(n);
00080         }
00081 
00082         void SymbolsTable::update(const QList<ItemHandle*>& items)
00083         {
00084                 nonuniqueHandles.clear();
00085                 uniqueHandlesWithDot.clear();
00086                 uniqueHandlesWithUnderscore.clear();
00087                 uniqueDataWithDot.clear();
00088                 uniqueDataWithUnderscore.clear();
00089                 nonuniqueData.clear();
00090                 handlesByFamily.clear();
00091                 handlesAddress.clear();
00092 
00093                 ItemHandle * handle = 0;
00094                 for (int i=0; i < items.size(); ++i)
00095                 {
00096                         if ((handle = items[i]) && !handlesAddress.contains((void*)handle))
00097                         {
00098                                 handle->network = network;
00099 
00100                                 handlesAddress[(void*)handle] = handle->fullName();
00101 
00102                                 uniqueHandlesWithDot[handle->fullName()] = handle;
00103                                 uniqueHandlesWithUnderscore[handle->fullName(QObject::tr("_"))] = handle;
00104                                 if (handle != &globalHandle)
00105                                 {
00106                                         nonuniqueHandles.insertMulti(handle->fullName(),handle);
00107                                         nonuniqueHandles.insertMulti(handle->fullName(QObject::tr("_")),handle);
00108                                         nonuniqueHandles.insertMulti(handle->name,handle);
00109                                 }
00110 
00111                                 if (handle->family())
00112                                 {
00113                                         QStringList synonyms = handle->family()->synonyms;                                      
00114                                         handlesByFamily.insertMulti(handle->family()->name(), handle);
00115                                         for (int j=0; j < synonyms.size(); ++j)
00116                                                 handlesByFamily.insertMulti(synonyms[j], handle);
00117                                 }
00118 
00119                                 QList<QString> keys = handle->numericalDataNames();
00120                                 for (int j=0; j < keys.size(); ++j)
00121                                 {
00122                                         DataTable<qreal>& nDat = handle->numericalDataTable( keys[j] );
00123 
00124                                         for (int k=0; k < nDat.rows(); ++k)
00125                                         {
00126                                                 if (!nDat.rowName(k).isEmpty())
00127                                                 {
00128                                                         if (!handle->name.isEmpty())
00129                                                         {
00130                                                                 uniqueDataWithDot[handle->fullName() + QObject::tr(".") + nDat.rowName(k)] = 
00131                                                                         QPair<ItemHandle*,QString>(handle,keys[j]);
00132                                                                 uniqueDataWithUnderscore[handle->fullName(QObject::tr("_")) + QObject::tr("_") + nDat.rowName(k)] = 
00133                                                                         QPair<ItemHandle*,QString>(handle,keys[j]);
00134                                                                 
00135                                                                 nonuniqueData.insertMulti(handle->fullName() + QObject::tr(".") + nDat.rowName(k),
00136                                                                         QPair<ItemHandle*,QString>(handle,keys[j]));
00137                                                                 nonuniqueData.insertMulti(handle->fullName(QObject::tr("_")) + QObject::tr("_") + nDat.rowName(k), 
00138                                                                         QPair<ItemHandle*,QString>(handle,keys[j]));
00139                                                         }
00140                                                         else
00141                                                         {
00142                                                                 uniqueDataWithDot[nDat.rowName(k)] = QPair<ItemHandle*,QString>(handle,keys[j]);
00143                                                                 uniqueDataWithUnderscore[nDat.rowName(k)] = QPair<ItemHandle*,QString>(handle,keys[j]);
00144                                                         }
00145                                                         nonuniqueData.insertMulti(nDat.rowName(k),      QPair<ItemHandle*,QString>(handle,keys[j]));
00146                                                 }
00147                                         }
00148 
00149                                         /*
00150                                         for (int k=0; k < nDat.columns(); ++k)
00151                                         {                                               
00152                                                 if (!nDat.columnName(k).isEmpty())
00153                                                 {
00154                                                         if (!handle->name.isEmpty())
00155                                                         {
00156                                                                 uniqueDataWithDot.insertMulti(handle->fullName() + QObject::tr(".") + nDat.columnName(k),
00157                                                                         QPair<ItemHandle*,QString>(handle,keys[j]));
00158                                                                 uniqueDataWithUnderscore.insertMulti(handle->fullName(QObject::tr("_")) + QObject::tr("_") + nDat.columnName(k),
00159                                                                         QPair<ItemHandle*,QString>(handle,keys[j]));
00160                                                         }
00161                                                         nonuniqueData.insertMulti(handle->fullName() + QObject::tr(".") + nDat.columnName(k),
00162                                                                         QPair<ItemHandle*,QString>(handle,keys[j]));
00163                                                         nonuniqueData.insertMulti(handle->fullName(QObject::tr("_")) + QObject::tr("_") + nDat.columnName(k), 
00164                                                                 QPair<ItemHandle*,QString>(handle,keys[j]));
00165                                                         nonuniqueData.insertMulti(nDat.columnName(k),
00166                                                                 QPair<ItemHandle*,QString>(handle,keys[j]));
00167                                                 }
00168                                         }
00169                                         */
00170                                 }
00171 
00172                                 keys = handle->textDataNames();
00173                                 for (int j=0; j < keys.size(); ++j)
00174                                 {
00175                                         DataTable<QString>& sDat = handle->textDataTable( keys[j] );
00176 
00177                                         for (int k=0; k < sDat.rows(); ++k)
00178                                         {
00179                                                 if (!sDat.rowName(k).isEmpty())
00180                                                 {
00181                                                         if (!handle->name.isEmpty())
00182                                                         {
00183                                                                 uniqueDataWithDot[handle->fullName() + QObject::tr(".") + sDat.rowName(k)] =
00184                                                                         QPair<ItemHandle*,QString>(handle,keys[j]);
00185                                                                 uniqueDataWithUnderscore[handle->fullName(QObject::tr("_")) + QObject::tr("_") + sDat.rowName(k)] =
00186                                                                         QPair<ItemHandle*,QString>(handle,keys[j]);
00187                                                                 
00188                                                                 nonuniqueData.insertMulti(handle->fullName() + QObject::tr(".") + sDat.rowName(k),
00189                                                                         QPair<ItemHandle*,QString>(handle,keys[j]));
00190                                                                 nonuniqueData.insertMulti(handle->fullName(QObject::tr("_")) + QObject::tr("_") + sDat.rowName(k),
00191                                                                         QPair<ItemHandle*,QString>(handle,keys[j]));
00192                                                         }
00193                                                         else
00194                                                         {
00195                                                                 uniqueDataWithDot[sDat.rowName(k)] = QPair<ItemHandle*,QString>(handle,keys[j]);
00196                                                                 uniqueDataWithUnderscore[sDat.rowName(k)] = QPair<ItemHandle*,QString>(handle,keys[j]);
00197                                                         }
00198                                                         nonuniqueData.insertMulti(sDat.rowName(k),
00199                                                                 QPair<ItemHandle*,QString>(handle,keys[j]));
00200                                                 }
00201                                         }
00202                                         
00203                                         for (int k=0; k < sDat.columns(); ++k)
00204                                         {
00205                                                 /*
00206                                                 if (!sDat.columnName(k).isEmpty())
00207                                                 {
00208                                                         if (!handle->name.isEmpty())
00209                                                         {
00210                                                                 uniqueDataWithDot.insertMulti(handle->fullName() + QObject::tr(".") + sDat.columnName(k),
00211                                                                         QPair<ItemHandle*,QString>(handle,keys[j]));
00212                                                                 uniqueDataWothUnderscore.insertMulti(handle->fullName(QObject::tr("_")) + QObject::tr("_") + sDat.columnName(k),
00213                                                                         QPair<ItemHandle*,QString>(handle,keys[j]));
00214                                                         }
00215                                                         nonuniqueData.insertMulti(handle->fullName() + QObject::tr(".") + sDat.columnName(k),
00216                                                                 QPair<ItemHandle*,QString>(handle,keys[j]));
00217                                                         nonuniqueData.insertMulti(handle->fullName(QObject::tr("_")) + QObject::tr("_") + sDat.columnName(k),
00218                                                                 QPair<ItemHandle*,QString>(handle,keys[j]));
00219                                                         nonuniqueData.insertMulti(sDat.columnName(k),
00220                                                                 QPair<ItemHandle*,QString>(handle,keys[j]));
00221                                                 }
00222                                                 */
00223                                                 
00224                                                 for (int l=0; l < sDat.rows(); ++l)
00225                                                         nonuniqueData.insertMulti(sDat.at(l,k),
00226                                                                 QPair<ItemHandle*,QString>(handle,keys[j]));
00227                                         }
00228                                 }
00229                         
00230                         }
00231                 }
00232                 
00233                 QList<NetworkWindow*> windows = network->networkWindows;
00234                 for (int i=0; i < windows.size(); ++i)
00235                         if (windows[i] && windows[i]->handle && !handlesAddress.contains(windows[i]->handle))
00236                                 windows[i]->close();
00237         }
00238         
00239         static void expandLeftFirst(ItemFamily * family, QList<ItemFamily*>& families)
00240         {
00241                 if (family && !families.contains(family))
00242                 {
00243                         families << family; 
00244                         QList<ItemFamily*> children = family->children();
00245                         for (int i=0; i < children.size(); ++i)
00246                                 expandLeftFirst(children[i],families); 
00247 
00248 
00249                 }
00250         }
00251         
00252         QList<ItemHandle*> SymbolsTable::allHandlesSortedByFamily() const
00253         {
00254                 QList<ItemFamily*> allRootFamilies;
00255                 ItemFamily * root = 0;
00256                 
00257                 QStringList keys (uniqueHandlesWithDot.keys());
00258                 QList<ItemHandle*> allHandles = uniqueHandlesWithDot.values();
00259                 
00260                 for (int i=0; i < allHandles.size(); ++i)
00261                 {
00262                         if (allHandles[i] && allHandles[i]->family())
00263                         {
00264                                 root = allHandles[i]->family()->root();
00265                                 if (!allRootFamilies.contains(root))
00266                                         allRootFamilies << root;
00267                         }
00268                 }
00269 
00270                 QList<ItemFamily*> sortedFamilies;
00271                 
00272                 for (int i=0; i < allRootFamilies.size(); ++i)
00273                         expandLeftFirst(allRootFamilies[i],sortedFamilies);
00274                 
00275                 allHandles.clear();
00276                 for (int i=0; i < sortedFamilies.size(); ++i)
00277                 {
00278                         QList<ItemHandle*> items = handlesByFamily.values(sortedFamilies[i]->name());
00279                         QStringList names;
00280                         for (int j=0; j < items.size(); ++j) 
00281                                 names += items[j]->fullName();
00282                         names.sort();
00283                         for (int j=0; j < names.size(); ++j)
00284                                 allHandles += uniqueHandlesWithDot[ names[j] ];
00285                 }
00286                 
00287                 return allHandles;
00288         }
00289         
00290         QList<ItemHandle*> SymbolsTable::allHandlesSortedByName() const
00291         {
00292                 QStringList names = uniqueHandlesWithDot.keys();
00293                 names.sort();
00294                 
00295                 QList<ItemHandle*> allHandles;
00296                 
00297                 for (int i=0; i < names.size(); ++i)
00298                         allHandles << uniqueHandlesWithDot[ names[i] ];
00299 
00300                 return allHandles;
00301         }
00302 
00303         bool SymbolsTable::isValidPointer(void * p) const
00304         {
00305                 return (p!=0 && !MainWindow::invalidPointers.contains(p) && handlesAddress.contains(p));
00306         }
00307 
00308 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines