HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r7:1abdb58baffd

Added lost SocExplorerPlot wrapper and win32 libelf binary.

Jeandet Alexis -

r7:1abdb58baffd default

parent child

Context file:

r7:1abdb58baffd

Collapse all files

src/common/elf/libelfWin32/bin/libelf.a created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

.hgignore +1 0

             # use glob syntax.
             syntax: glob
             moc_*
             Makefil*
             qrc_*
             *.qm
             *.tex
             *.html
             *log*
             *.dot
             *.css
             *.md5
             *.eps
             *.pdf
             *.toc
             *.map
             *.sty
             *.3
             *.js
             *.aux
             *.idx
             *.orig
             *.o
             *.dll
             *.a
             *.bin
             *~
             *.pro.user
             src/PythonQt/tests/PythonQtTest
             src/PythonQt/generator/pythonqt_generator
             src/plugins/common/.preprocessed.tmp
             *.exe
+            src/common/.preprocessed.tmp
             syntax: regexp
             bin/*

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp +100 0

             #include "PySocExplorer0.h"
             #include <PythonQtConversion.h>
             #include <PythonQtMethodInfo.h>
             #include <PythonQtSignalReceiver.h>
             #include <QVariant>
             MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget*  parent)
             {
             return new MemSizeWdgt(parent); }
             MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int  defaultSize, QWidget*  parent)
             {
             return new MemSizeWdgt(defaultSize, parent); }
             int  PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
             {
               return ( theWrappedObject->getsize());
             }
             void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int  max)
             {
               ( theWrappedObject->setMaximum(max));
             }
             void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
             {
               ( theWrappedObject->show());
             }
             void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
             {
               ( theWrappedObject->updateSizeValue());
             }
             PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
               PythonQtPrivate* priv = PythonQt::priv();
               if (priv) { priv->shellClassDeleted(this); }
             }
             QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget*  parent)
             {
             return new PythonQtShell_QHexEdit(parent); }
             QColor  PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->addressAreaColor());
             }
             int  PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->addressOffset());
             }
             int  PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->cursorPosition());
             }
             QByteArray  PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->data());
             }
             const QFont*  PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
             {
               return &( theWrappedObject->font());
             }
             QColor  PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->highlightingColor());
             }
             int  PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from) const
             {
               return ( theWrappedObject->indexOf(ba, from));
             }
             void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int  i, char  ch)
             {
               ( theWrappedObject->insert(i, ch));
             }
             void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int  i, const QByteArray&  ba)
             {
               ( theWrappedObject->insert(i, ba));
             }
             bool  PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->isReadOnly());
             }
             int  PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from) const
             {
               return ( theWrappedObject->lastIndexOf(ba, from));
             }
             bool  PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->overwriteMode());
             }
             void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int  pos, int  len)
             {
               ( theWrappedObject->remove(pos, len));
             }
             void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int  pos, int  len, const QByteArray&  after)
             {
               ( theWrappedObject->replace(pos, len, after));
             }
             QColor  PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->selectionColor());
             }
             QString  PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->selectionToReadableString());
             }
             void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor&  color)
             {
               ( theWrappedObject->setAddressAreaColor(color));
             }
             void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int  offset)
             {
               ( theWrappedObject->setAddressOffset(offset));
             }
             void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int  cusorPos)
             {
               ( theWrappedObject->setCursorPosition(cusorPos));
             }
             void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray&  data)
             {
               ( theWrappedObject->setData(data));
             }
             void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont&  arg__1)
             {
               ( theWrappedObject->setFont(arg__1));
             }
             void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor&  color)
             {
               ( theWrappedObject->setHighlightingColor(color));
             }
             void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool  arg__1)
             {
               ( theWrappedObject->setOverwriteMode(arg__1));
             }
             void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool  arg__1)
             {
               ( theWrappedObject->setReadOnly(arg__1));
             }
             void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor&  color)
             {
               ( theWrappedObject->setSelectionColor(color));
             }
             QString  PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->toReadableString());
             }
             QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget*  parent)
             {
             return new QHexSpinBox(parent); }
             void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
             {
               ( theWrappedObject->show());
             }
             QString  PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int  value) const
             {
               return ( theWrappedObject->textFromValue(value));
             }
             QValidator::State  PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString&  input, int&  pos) const
             {
               return ( theWrappedObject->validate(input, pos));
             }
             int  PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString&  text) const
             {
               return ( theWrappedObject->valueFromText(text));
             }
+            PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
+              PythonQtPrivate* priv = PythonQt::priv();
+              if (priv) { priv->shellClassDeleted(this); }
+            }
+            SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget*  parent)
+            {
+            return new PythonQtShell_SocExplorerPlot(parent); }
+            int  PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
+            {
+              return ( theWrappedObject->addGraph());
+            }
+            void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y)
+            {
+              ( theWrappedObject->addGraphData(graphIndex, x, y));
+            }
+            void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QVariant  x, QVariant  y)
+            {
+              ( theWrappedObject->addGraphData(graphIndex, x, y));
+            }
+            QPen  PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex)
+            {
+              return ( theWrappedObject->getGraphPen(graphIndex));
+            }
+            void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
+            {
+              ( theWrappedObject->rescaleAxis());
+            }
+            void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y)
+            {
+              ( theWrappedObject->setGraphData(graphIndex, x, y));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  lineStyle)
+            {
+              ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  name)
+            {
+              ( theWrappedObject->setGraphName(graphIndex, name));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex, QPen  pen)
+            {
+              ( theWrappedObject->setGraphPen(graphIndex, pen));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  scatterStyle)
+            {
+              ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont  font)
+            {
+              ( theWrappedObject->setLegendFont(font));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont  font)
+            {
+              ( theWrappedObject->setLegendSelectedFont(font));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString  title)
+            {
+              ( theWrappedObject->setTitle(title));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString  label)
+            {
+              ( theWrappedObject->setXaxisLabel(label));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper)
+            {
+              ( theWrappedObject->setXaxisRange(lower, upper));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString  label)
+            {
+              ( theWrappedObject->setYaxisLabel(label));
+            }
+            void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper)
+            {
+              ( theWrappedObject->setYaxisRange(lower, upper));
+            }
+            void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
+            {
+              ( theWrappedObject->show());
+            }
             TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject*  parent)
             {
             return new TCP_Terminal_Client(parent); }
             void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
             {
               ( theWrappedObject->connectToServer());
             }
             void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString&  IP, int  port)
             {
               ( theWrappedObject->connectToServer(IP, port));
             }
             bool  PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
             {
               return ( theWrappedObject->isConnected());
             }
             void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString&  text)
             {
               ( theWrappedObject->sendText(text));
             }
             void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
             {
               ( theWrappedObject->startServer());
             }
             void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int  port)
             {
               ( theWrappedObject->startServer(port));
             }
             XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
             {
             return new XByteArray(); }
             int  PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
             {
               return ( theWrappedObject->addressOffset());
             }
             int  PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
             {
               return ( theWrappedObject->addressWidth());
             }
             QChar  PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int  index)
             {
               return ( theWrappedObject->asciiChar(index));
             }
             QByteArray*  PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
             {
               return &( theWrappedObject->data());
             }
             bool  PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int  i)
             {
               return ( theWrappedObject->dataChanged(i));
             }
             QByteArray  PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int  i, int  len)
             {
               return ( theWrappedObject->dataChanged(i, len));
             }
             QByteArray*  PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int  i, char  ch)
             {
               return &( theWrappedObject->insert(i, ch));
             }
             QByteArray*  PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int  i, const QByteArray&  ba)
             {
               return &( theWrappedObject->insert(i, ba));
             }
             int  PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
             {
               return ( theWrappedObject->realAddressNumbers());
             }
             QByteArray*  PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int  pos, int  len)
             {
               return &( theWrappedObject->remove(pos, len));
             }
             QByteArray*  PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int  index, char  ch)
             {
               return &( theWrappedObject->replace(index, ch));
             }
             QByteArray*  PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int  index, const QByteArray&  ba)
             {
               return &( theWrappedObject->replace(index, ba));
             }
             QByteArray*  PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int  index, int  length, const QByteArray&  ba)
             {
               return &( theWrappedObject->replace(index, length, ba));
             }
             void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int  offset)
             {
               ( theWrappedObject->setAddressOffset(offset));
             }
             void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int  width)
             {
               ( theWrappedObject->setAddressWidth(width));
             }
             void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray  data)
             {
               ( theWrappedObject->setData(data));
             }
             void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int  i, bool  state)
             {
               ( theWrappedObject->setDataChanged(i, state));
             }
             void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int  i, const QByteArray&  state)
             {
               ( theWrappedObject->setDataChanged(i, state));
             }
             int  PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
             {
               return ( theWrappedObject->size());
             }
             QString  PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int  start, int  end)
             {
               return ( theWrappedObject->toRedableString(start, end));
             }
             elfparser* PythonQtWrapper_elfparser::new_elfparser()
             {
             return new elfparser(); }
             int  PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->closeFile());
             }
             QString  PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->getArchitecture());
             }
             bool  PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int  index, char**  buffer)
             {
               return ( theWrappedObject->getSectionData(index, buffer));
             }
             QString  PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int  index)
             {
               return ( theWrappedObject->getSectionName(index));
             }
             QString  PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int  index)
             {
               return ( theWrappedObject->getSectionType(index));
             }
             int  PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->getSectioncount());
             }
             QString  PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int  index)
             {
               return ( theWrappedObject->getSegmentFlags(index));
             }
             QString  PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int  index)
             {
               return ( theWrappedObject->getSegmentType(index));
             }
             int  PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->getSegmentcount());
             }
             QString  PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->getType());
             }
             bool  PythonQtWrapper_elfparser::static_elfparser_isElf(const QString&  File)
             {
               return (elfparser::isElf(File));
             }
             bool  PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->iself());
             }
             bool  PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->isopened());
             }
             int  PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString&  name)
             {
               return ( theWrappedObject->setFilename(name));
             }

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h +42 0

             #include <PythonQt.h>
             #include <QObject>
             #include <QVariant>
+            #include <SocExplorerPlot.h>
             #include <elfparser.h>
             #include <memsizewdgt.h>
             #include <qhexedit.h>
             #include <qhexspinbox.h>
             #include <tcp_terminal_client.h>
             #include <xbytearray.h>
             class PythonQtWrapper_MemSizeWdgt : public QObject
             { Q_OBJECT
             public:
             public slots:
             MemSizeWdgt* new_MemSizeWdgt(QWidget*  parent = 0);
             MemSizeWdgt* new_MemSizeWdgt(int  defaultSize, QWidget*  parent = 0);
             void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
                int  getsize(MemSizeWdgt* theWrappedObject);
                void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int  max);
                void show(MemSizeWdgt* theWrappedObject);
                void updateSizeValue(MemSizeWdgt* theWrappedObject);
             };
             class PythonQtShell_QHexEdit : public QHexEdit
             {
             public:
                 PythonQtShell_QHexEdit(QWidget*  parent = 0):QHexEdit(parent),_wrapper(NULL) {};
                ~PythonQtShell_QHexEdit();
               PythonQtInstanceWrapper* _wrapper;
             };
             class PythonQtWrapper_QHexEdit : public QObject
             { Q_OBJECT
             public:
             public slots:
             QHexEdit* new_QHexEdit(QWidget*  parent = 0);
             void delete_QHexEdit(QHexEdit* obj) { delete obj; }
                QColor  addressAreaColor(QHexEdit* theWrappedObject);
                int  addressOffset(QHexEdit* theWrappedObject);
                int  cursorPosition(QHexEdit* theWrappedObject);
                QByteArray  data(QHexEdit* theWrappedObject);
                const QFont*  font(QHexEdit* theWrappedObject) const;
                QColor  highlightingColor(QHexEdit* theWrappedObject);
                int  indexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from = 0) const;
                void insert(QHexEdit* theWrappedObject, int  i, char  ch);
                void insert(QHexEdit* theWrappedObject, int  i, const QByteArray&  ba);
                bool  isReadOnly(QHexEdit* theWrappedObject);
                int  lastIndexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from = 0) const;
                bool  overwriteMode(QHexEdit* theWrappedObject);
                void remove(QHexEdit* theWrappedObject, int  pos, int  len = 1);
                void replace(QHexEdit* theWrappedObject, int  pos, int  len, const QByteArray&  after);
                QColor  selectionColor(QHexEdit* theWrappedObject);
                QString  selectionToReadableString(QHexEdit* theWrappedObject);
                void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor&  color);
                void setAddressOffset(QHexEdit* theWrappedObject, int  offset);
                void setCursorPosition(QHexEdit* theWrappedObject, int  cusorPos);
                void setData(QHexEdit* theWrappedObject, const QByteArray&  data);
                void setFont(QHexEdit* theWrappedObject, const QFont&  arg__1);
                void setHighlightingColor(QHexEdit* theWrappedObject, const QColor&  color);
                void setOverwriteMode(QHexEdit* theWrappedObject, bool  arg__1);
                void setReadOnly(QHexEdit* theWrappedObject, bool  arg__1);
                void setSelectionColor(QHexEdit* theWrappedObject, const QColor&  color);
                QString  toReadableString(QHexEdit* theWrappedObject);
             };
             class PythonQtWrapper_QHexSpinBox : public QObject
             { Q_OBJECT
             public:
             public slots:
             QHexSpinBox* new_QHexSpinBox(QWidget*  parent = 0);
             void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
                void show(QHexSpinBox* theWrappedObject);
                QString  textFromValue(QHexSpinBox* theWrappedObject, int  value) const;
                QValidator::State  validate(QHexSpinBox* theWrappedObject, QString&  input, int&  pos) const;
                int  valueFromText(QHexSpinBox* theWrappedObject, const QString&  text) const;
             };
+            class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
+            {
+            public:
+                PythonQtShell_SocExplorerPlot(QWidget*  parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
+               ~PythonQtShell_SocExplorerPlot();
+              PythonQtInstanceWrapper* _wrapper;
+            };
+            class PythonQtWrapper_SocExplorerPlot : public QObject
+            { Q_OBJECT
+            public:
+            public slots:
+            SocExplorerPlot* new_SocExplorerPlot(QWidget*  parent = 0);
+            void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
+               int  addGraph(SocExplorerPlot* theWrappedObject);
+               void addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y);
+               void addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QVariant  x, QVariant  y);
+               QPen  getGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex);
+               void rescaleAxis(SocExplorerPlot* theWrappedObject);
+               void setGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y);
+               void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  lineStyle);
+               void setGraphName(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  name);
+               void setGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex, QPen  pen);
+               void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  scatterStyle);
+               void setLegendFont(SocExplorerPlot* theWrappedObject, QFont  font);
+               void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont  font);
+               void setTitle(SocExplorerPlot* theWrappedObject, QString  title);
+               void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString  label);
+               void setXaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper);
+               void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString  label);
+               void setYaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper);
+               void show(SocExplorerPlot* theWrappedObject);
+            };
             class PythonQtWrapper_TCP_Terminal_Client : public QObject
             { Q_OBJECT
             public:
             public slots:
             TCP_Terminal_Client* new_TCP_Terminal_Client(QObject*  parent = 0);
             void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
                void connectToServer(TCP_Terminal_Client* theWrappedObject);
                void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString&  IP, int  port);
                bool  isConnected(TCP_Terminal_Client* theWrappedObject);
                void sendText(TCP_Terminal_Client* theWrappedObject, const QString&  text);
                void startServer(TCP_Terminal_Client* theWrappedObject);
                void startServer(TCP_Terminal_Client* theWrappedObject, int  port);
             };
             class PythonQtWrapper_XByteArray : public QObject
             { Q_OBJECT
             public:
             public slots:
             XByteArray* new_XByteArray();
             void delete_XByteArray(XByteArray* obj) { delete obj; }
                int  addressOffset(XByteArray* theWrappedObject);
                int  addressWidth(XByteArray* theWrappedObject);
                QChar  asciiChar(XByteArray* theWrappedObject, int  index);
                QByteArray*  data(XByteArray* theWrappedObject);
                bool  dataChanged(XByteArray* theWrappedObject, int  i);
                QByteArray  dataChanged(XByteArray* theWrappedObject, int  i, int  len);
                QByteArray*  insert(XByteArray* theWrappedObject, int  i, char  ch);
                QByteArray*  insert(XByteArray* theWrappedObject, int  i, const QByteArray&  ba);
                int  realAddressNumbers(XByteArray* theWrappedObject);
                QByteArray*  remove(XByteArray* theWrappedObject, int  pos, int  len);
                QByteArray*  replace(XByteArray* theWrappedObject, int  index, char  ch);
                QByteArray*  replace(XByteArray* theWrappedObject, int  index, const QByteArray&  ba);
                QByteArray*  replace(XByteArray* theWrappedObject, int  index, int  length, const QByteArray&  ba);
                void setAddressOffset(XByteArray* theWrappedObject, int  offset);
                void setAddressWidth(XByteArray* theWrappedObject, int  width);
                void setData(XByteArray* theWrappedObject, QByteArray  data);
                void setDataChanged(XByteArray* theWrappedObject, int  i, bool  state);
                void setDataChanged(XByteArray* theWrappedObject, int  i, const QByteArray&  state);
                int  size(XByteArray* theWrappedObject);
                QString  toRedableString(XByteArray* theWrappedObject, int  start = 0, int  end = -1);
             };
             class PythonQtWrapper_elfparser : public QObject
             { Q_OBJECT
             public:
             public slots:
             elfparser* new_elfparser();
             void delete_elfparser(elfparser* obj) { delete obj; }
                int  closeFile(elfparser* theWrappedObject);
                QString  getArchitecture(elfparser* theWrappedObject);
                bool  getSectionData(elfparser* theWrappedObject, int  index, char**  buffer);
                QString  getSectionName(elfparser* theWrappedObject, int  index);
                QString  getSectionType(elfparser* theWrappedObject, int  index);
                int  getSectioncount(elfparser* theWrappedObject);
                QString  getSegmentFlags(elfparser* theWrappedObject, int  index);
                QString  getSegmentType(elfparser* theWrappedObject, int  index);
                int  getSegmentcount(elfparser* theWrappedObject);
                QString  getType(elfparser* theWrappedObject);
                bool  static_elfparser_isElf(const QString&  File);
                bool  iself(elfparser* theWrappedObject);
                bool  isopened(elfparser* theWrappedObject);
                int  setFilename(elfparser* theWrappedObject, const QString&  name);
             };

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer_init.cpp +1 0

             #include <PythonQt.h>
             #include "PySocExplorer0.h"
             void PythonQt_init_PySocExplorer(PyObject* module) {
             PythonQt::priv()->registerCPPClass("MemSizeWdgt", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, NULL, module, 0);
             PythonQt::priv()->registerCPPClass("QHexEdit", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
             PythonQt::priv()->registerCPPClass("QHexSpinBox", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, NULL, module, 0);
+            PythonQt::priv()->registerCPPClass("SocExplorerPlot", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
             PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, NULL, module, 0);
             PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
             PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages