SIM/qucs_s
1
0
Fork 0
mirror of https://github.com/ra3xdh/qucs_s synced 2025-03-28 21:13:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Everything compiles and qucs_s application runs

Browse Source
This commit is contained in:
Vadim Kuznetsov 2022-02-14 15:37:11 +01:00
parent 53059f4fed
commit 9aa8865d02
29 changed files with 2991 additions and 488 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
qucs/CMakeLists.txt
View File

@ -255,7 +255,7 @@ ADD_EXECUTABLE( ${QUCS_NAME} MACOSX_BUNDLE WIN32
#
# Tell CMake which libraries we need to link our executable against.
#
TARGET_LINK_LIBRARIES( ${QUCS_NAME} components diagrams dialogs paintings extsimkernels spicecomponents ${QT_LIBRARIES} )
TARGET_LINK_LIBRARIES( ${QUCS_NAME} components diagrams dialogs paintings extsimkernels spicecomponents qt3_compat ${QT_LIBRARIES} )
#
# Prepare the installation

6
qucs/dialogs/importdialog.cpp
View File

@ -99,7 +99,7 @@ ImportDialog::ImportDialog(QWidget *parent)
ImportDialog::~ImportDialog()
{
if(Process.Running) Process.kill();
if(Process.state() == QProcess::Running) Process.kill();
delete all;
}
@ -256,7 +256,7 @@ void ImportDialog::slotImport()
qDebug() << "Command:" << Program << CommandLine.join(" ");
Process.start(Program, CommandLine);
if(!Process.Running)
if(!Process.state() != QProcess::Running)
MsgText->appendPlainText(tr("ERROR: Cannot start converter!"));
}
@ -286,7 +286,7 @@ void ImportDialog::slotType(int index)
// ------------------------------------------------------------------------
void ImportDialog::slotAbort()
{
if(Process.Running) Process.kill();
if(Process.state() == QProcess::Running) Process.kill();
AbortButt->setDisabled(true);
ImportButt->setDisabled(false);
}

40
qucs/main.cpp
View File

@ -138,7 +138,7 @@ bool loadSettings()
if(settings.contains("Nprocs")) QucsSettings.NProcs = settings.value("Nprocs").toInt();
else QucsSettings.NProcs = 4;
if(settings.contains("S4Q_workdir")) QucsSettings.S4Qworkdir = settings.value("S4Q_workdir").toString();
else QucsSettings.S4Qworkdir = QDir::convertSeparators(QDir::homePath()+"/.qucs/spice4qucs");
else QucsSettings.S4Qworkdir = QDir::toNativeSeparators(QDir::homePath()+"/.qucs/spice4qucs");
if(settings.contains("SimParameters")) QucsSettings.SimParameters = settings.value("SimParameters").toString();
else QucsSettings.SimParameters = "";
if(settings.contains("OctaveExecutable")) {
@ -270,8 +270,9 @@ bool saveApplSettings()
* <http://qt-project.org/doc/qt-4.8/debug.html#warning-and-debugging-messages>
* <http://qt-project.org/doc/qt-4.8/qtglobal.html#qInstallMsgHandler>
*/
void qucsMessageOutput(QtMsgType type, const char *msg)
void qucsMessageOutput(QtMsgType type, const QMessageLogContext &, const QString &str)
{
const char *msg = str.toUtf8().data();
switch (type) {
case QtDebugMsg:
fprintf(stderr, "Debug: %s\n", msg);
@ -284,6 +285,8 @@ void qucsMessageOutput(QtMsgType type, const char *msg)
break;
case QtFatalMsg:
fprintf(stderr, "Fatal: %s\n", msg);
case QtInfoMsg:
fprintf(stderr,"Info %s\n", msg);
abort();
}
@ -301,7 +304,7 @@ Schematic *openSchematic(QString schematic)
file.close();
}
else {
fprintf(stderr, "Error: Could not load schematic %s\n", schematic.ascii());
fprintf(stderr, "Error: Could not load schematic %s\n", schematic.toLatin1().data());
return NULL;
}
@ -313,7 +316,7 @@ Schematic *openSchematic(QString schematic)
// load schematic file if possible
if(!sch->loadDocument()) {
fprintf(stderr, "Error: Could not load schematic %s\n", schematic.ascii());
fprintf(stderr, "Error: Could not load schematic %s\n", schematic.toLatin1().data());
delete sch;
return NULL;
}
@ -340,7 +343,7 @@ int doNetlist(QString schematic, QString netlist)
NetlistFile.setFileName(netlist);
if(!NetlistFile.open(QIODevice::WriteOnly)) {
fprintf(stderr, "Error: Could not load netlist %s\n", netlist.ascii());
fprintf(stderr, "Error: Could not load netlist %s\n", netlist.toLatin1().data());
return -1;
}
@ -591,7 +594,7 @@ void createIcons() {
image.save("./bitmaps_generated/" + QString(File) + ".png");
fprintf(stdout, "[%s] %s\n", category.toAscii().data(), File);
fprintf(stdout, "[%s] %s\n", category.toLatin1().data(), File);
}
nComps++;
} // module
@ -683,7 +686,7 @@ void createDocData() {
QTextStream out(&file);
out << compData.join("\n");
file.close();
fprintf(stdout, "[%s] %s %s \n", category.toAscii().data(), c->Model.toAscii().data(), file.name().toAscii().data());
fprintf(stdout, "[%s] %s %s \n", category.toLatin1().data(), c->Model.toLatin1().data(), file.fileName().toLatin1().data());
QStringList compProps;
compProps << "# Note: auto-generated file (changes will be lost on update)";
@ -705,7 +708,7 @@ void createDocData() {
outProps << compProps.join("\n");
compProps.clear();
file.close();
fprintf(stdout, "[%s] %s %s \n", category.toAscii().data(), c->Model.toAscii().data(), fileProps.name().toAscii().data());
fprintf(stdout, "[%s] %s %s \n", category.toLatin1().data(), c->Model.toLatin1().data(), fileProps.fileName().toLatin1().data());
} // module
} // category
fprintf(stdout, "Created data for %i components from %i categories\n", nComps, nCats);
@ -739,7 +742,7 @@ void createListComponentEntry(){
Component *c = (Component* ) e;
QString qucsEntry = c->save();
fprintf(stdout, "%s; qucs ; %s\n", c->Model.toAscii().data(), qucsEntry.toAscii().data());
fprintf(stdout, "%s; qucs ; %s\n", c->Model.toLatin1().data(), qucsEntry.toLatin1().data());
// add dummy ports/wires, avoid segfault
int port = 0;
@ -752,12 +755,12 @@ void createListComponentEntry(){
// skip Subcircuit, segfault, there is nothing to netlist
if (c->Model == "Sub" or c->Model == ".Opt") {
fprintf(stdout, "WARNING, qucsator netlist not generated for %s\n\n", c->Model.toAscii().data());
fprintf(stdout, "WARNING, qucsator netlist not generated for %s\n\n", c->Model.toLatin1().data());
continue;
}
QString qucsatorEntry = c->getNetlist();
fprintf(stdout, "%s; qucsator; %s\n", c->Model.toAscii().data(), qucsatorEntry.toAscii().data());
fprintf(stdout, "%s; qucsator; %s\n", c->Model.toLatin1().data(), qucsatorEntry.toLatin1().data());
} // module
} // category
}
@ -769,7 +772,7 @@ void createListComponentEntry(){
// #########################################################################
int main(int argc, char *argv[])
{
qInstallMsgHandler(qucsMessageOutput);
qInstallMessageHandler(qucsMessageOutput);
// set the Qucs version string
QucsVersion = VersionTriplet(PACKAGE_VERSION);
@ -790,7 +793,7 @@ int main(int argc, char *argv[])
QucsSettings.dy = h*3/4;
// default
QucsSettings.QucsHomeDir.setPath(QDir::homeDirPath()+QDir::convertSeparators ("/.qucs"));
QucsSettings.QucsHomeDir.setPath(QDir::homePath()+QDir::toNativeSeparators ("/.qucs"));
QucsSettings.QucsWorkDir.setPath(QucsSettings.QucsHomeDir.canonicalPath());
// load existing settings (if any)
@ -903,12 +906,15 @@ int main(int argc, char *argv[])
// set codecs
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
// QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
QTranslator tor( 0 );
QString lang = QucsSettings.Language;
if(lang.isEmpty())
lang = QTextCodec::locale();
if(lang.isEmpty()) {
QLocale loc;
lang = loc.name();
// lang = QTextCodec::locale();
}
tor.load( QString("qucs_") + lang, QucsSettings.LangDir);
a.installTranslator( &tor );
@ -1054,7 +1060,7 @@ int main(int argc, char *argv[])
}
QucsMain = new QucsApp();
a.setMainWidget(QucsMain);
//1a.setMainWidget(QucsMain);
QucsMain->show();
int result = a.exec();

1
qucs/messagedock.cpp
View File

@ -22,6 +22,7 @@
#include "textdoc.h"
#include <QDockWidget>
#include <QTextBlock>
#include <QDebug>
/*!

2
qucs/misc.cpp
View File

@ -435,7 +435,7 @@ VersionTriplet::VersionTriplet(const QString& version) {
if (version.isEmpty()) {
major = minor = patch = 0;
} else {
QStringList vl = QStringList::split('.', version);
QStringList vl = version.split('.');
major = vl.at(0).toUInt();
minor = vl.at(1).toUInt();
patch = vl.at(2).toUInt();

98
qucs/mouseactions.cpp
View File

@ -38,7 +38,7 @@
#include "extsimkernels/customsimdialog.h"
#include <QTextStream>
#include <Q3PtrList>
#include <qt3_compat/q3ptrlist.h>
#include <QMouseEvent>
#include <QClipboard>
#include <QApplication>
@ -75,7 +75,7 @@ MouseActions::MouseActions(QucsApp* App_)
// initialize menu appearing by right mouse button click on component
ComponentMenu = new QMenu(QucsMain);
focusMEvent = new QMouseEvent(QEvent::MouseButtonPress, QPoint(0,0),
Qt::NoButton, Qt::NoButton);
Qt::NoButton, Qt::NoButton, Qt::NoModifier);
}
@ -500,7 +500,7 @@ void MouseActions::MMoveMoving2(Schematic *Doc, QMouseEvent *Event)
// ((Wire*)pe)->Label->paintScheme(&painter);
drawn = true;
if((Event->state() & Qt::ControlModifier) == 0)
if((Event->modifiers().testFlag(Qt::ControlModifier)) == 0)
Doc->setOnGrid(MAx2, MAy2); // use grid only if CTRL key not pressed
MAx1 = MAx2 - MAx1;
MAy1 = MAy2 - MAy1;
@ -778,8 +778,9 @@ void MouseActions::rightPressMenu(Schematic *Doc, QMouseEvent *Event, float fX,
while(true) {
if(focusElement) {
focusElement->isSelected = true;
ComponentMenu->insertItem(
QObject::tr("Edit Properties"), QucsMain, SLOT(slotEditElement()));
QAction *editProp = new QAction(QObject::tr("Edit Properties"), QucsMain);
QObject::connect(editProp,SIGNAL(triggered(bool)),QucsMain,SLOT(slotEditElement()));
ComponentMenu->addAction(editProp);
if((focusElement->Type & isComponent) == 0) break;
}
@ -788,85 +789,92 @@ void MouseActions::rightPressMenu(Schematic *Doc, QMouseEvent *Event, float fX,
//ComponentMenu->addAction(QucsMain->symEdit);
//to QucsMain->symEdit->addTo(ComponentMenu);
// see http://qt-project.org/doc/qt-4.8/qaction-qt3.html#addTo
QucsMain->symEdit->addTo(ComponentMenu);
QucsMain->fileSettings->addTo(ComponentMenu);
ComponentMenu->addAction(QucsMain->symEdit);
ComponentMenu->addAction(QucsMain->fileSettings);
}
if(!QucsMain->moveText->isOn())
QucsMain->moveText->addTo(ComponentMenu);
if(!QucsMain->moveText->isChecked())
ComponentMenu->addAction(QucsMain->moveText);
break;
}
while(true) {
if(focusElement)
if(focusElement->Type == isGraph) break;
if(!QucsMain->onGrid->isOn())
QucsMain->onGrid->addTo(ComponentMenu);
QucsMain->editCopy->addTo(ComponentMenu);
if(!QucsMain->editPaste->isOn())
QucsMain->editPaste->addTo(ComponentMenu);
if(!QucsMain->onGrid->isChecked())
ComponentMenu->addAction(QucsMain->onGrid);
ComponentMenu->addAction(QucsMain->editCopy);
if(!QucsMain->editPaste->isChecked())
ComponentMenu->addAction(QucsMain->editPaste);
break;
}
while (true) {
if (focusElement) {
if (focusElement->Type == isDiagram) {
ComponentMenu->insertItem(QObject::tr("Export as image"), QucsMain,
SLOT(slotSaveDiagramToGraphicsFile()));
QAction *actExport = new QAction(QObject::tr("Export as image"), QucsMain);
QObject::connect(actExport,SIGNAL(triggered(bool)),QucsMain,SLOT(slotSaveDiagramToGraphicsFile()));
ComponentMenu->addAction(actExport);
}
if (focusElement->Type & isComponent) {
Component *pc = (Component *)focusElement;
if (pc->Model == "EDD") {
ComponentMenu->insertItem(QObject::tr("Create XSPICE IFS"), QucsMain,
SLOT(slotEDDtoIFS()));
ComponentMenu->insertItem(QObject::tr("Create XSPICE MOD"), QucsMain,
SLOT(slotEDDtoMOD()));
QAction *actEDDtoIFS = new QAction(QObject::tr("Create XSPICE IFS"), QucsMain);
QObject::connect(actEDDtoIFS,SIGNAL(triggered(bool)),QucsMain,SLOT(slotEDDtoIFS()));
ComponentMenu->addAction(actEDDtoIFS);
QAction *actEDDtoMOD = new QAction(QObject::tr("Create XSPICE MOD"), QucsMain);
QObject::connect(actEDDtoMOD,SIGNAL(triggered(bool)),QucsMain,SLOT(slotEDDtoMOD()));
ComponentMenu->addAction(actEDDtoMOD);
}
}
}
break;
}
if(!QucsMain->editDelete->isOn())
QucsMain->editDelete->addTo(ComponentMenu);
if(!QucsMain->editDelete->isChecked())
ComponentMenu->addAction(QucsMain->editDelete);
if(focusElement) if(focusElement->Type == isMarker) {
ComponentMenu->insertSeparator();
ComponentMenu->addSeparator();
QString s = QObject::tr("power matching");
if( ((Marker*)focusElement)->pGraph->Var == "Sopt" )
s = QObject::tr("noise matching");
ComponentMenu->insertItem(s, QucsMain, SLOT(slotPowerMatching()));
if( ((Marker*)focusElement)->pGraph->Var.left(2) == "S[" )
ComponentMenu->insertItem(QObject::tr("2-port matching"), QucsMain,
SLOT(slot2PortMatching()));
QAction *actPwrMatching = new QAction(s, QucsMain);
QObject::connect(actPwrMatching,SIGNAL(triggered(bool)),QucsMain,SLOT(slotPowerMatching()));
ComponentMenu->addAction(actPwrMatching);
if( ((Marker*)focusElement)->pGraph->Var.left(2) == "S[" ) {
QAction *act2PortMatching = new QAction(QObject::tr("2-port matching"), QucsMain);
QObject::connect(act2PortMatching,SIGNAL(triggered(bool)),QucsMain,SLOT(slot2PortMatching()));
ComponentMenu->addAction(act2PortMatching);
}
}
do {
if(focusElement) {
if(focusElement->Type == isDiagram) break;
if(focusElement->Type == isGraph) {
QucsMain->graph2csv->addTo(ComponentMenu);
ComponentMenu->addAction(QucsMain->graph2csv);
break;
}
}
ComponentMenu->insertSeparator();
ComponentMenu->addSeparator();
if(focusElement) if(focusElement->Type & isComponent)
if(!QucsMain->editActivate->isOn())
QucsMain->editActivate->addTo(ComponentMenu);
if(!QucsMain->editRotate->isOn())
QucsMain->editRotate->addTo(ComponentMenu);
if(!QucsMain->editMirror->isOn())
QucsMain->editMirror->addTo(ComponentMenu);
if(!QucsMain->editMirrorY->isOn())
QucsMain->editMirrorY->addTo(ComponentMenu);
if(!QucsMain->editActivate->isChecked())
ComponentMenu->addAction(QucsMain->editActivate);
if(!QucsMain->editRotate->isChecked())
ComponentMenu->addAction(QucsMain->editRotate);
if(!QucsMain->editMirror->isChecked())
ComponentMenu->addAction(QucsMain->editMirror);
if(!QucsMain->editMirrorY->isChecked())
ComponentMenu->addAction(QucsMain->editMirrorY);
// right-click menu to go into hierarchy
if(focusElement) {
if(focusElement->Type & isComponent)
if(((Component*)focusElement)->Model == "Sub")
if(!QucsMain->intoH->isOn())
QucsMain->intoH->addTo(ComponentMenu);
if(!QucsMain->intoH->isChecked())
ComponentMenu->addAction(QucsMain->intoH);
}
// right-click menu to pop out of hierarchy
if(!focusElement)
if(!QucsMain->popH->isOn())
QucsMain->popH->addTo(ComponentMenu);
if(!QucsMain->popH->isChecked())
ComponentMenu->addAction(QucsMain->popH);
} while(false);
*focusMEvent = *Event; // remember event for "edit component" action
@ -948,7 +956,7 @@ void MouseActions::MPressLabel(Schematic *Doc, QMouseEvent*, float fX, float fY)
void MouseActions::MPressSelect(Schematic *Doc, QMouseEvent *Event, float fX, float fY)
{
bool Ctrl;
if(Event->state() & Qt::ControlModifier) Ctrl = true;
if(Event->modifiers().testFlag(Qt::ControlModifier)) Ctrl = true;
else Ctrl = false;
int No=0;
@ -1554,7 +1562,7 @@ void MouseActions::MPressZoomIn(Schematic *Doc, QMouseEvent*, float fX, float fY
void MouseActions::MReleaseSelect(Schematic *Doc, QMouseEvent *Event)
{
bool ctrl;
if(Event->state() & Qt::ControlModifier) ctrl = true;
if(Event->modifiers().testFlag(Qt::ControlModifier)) ctrl = true;
else ctrl = false;
if(!ctrl) Doc->deselectElements(focusElement);
@ -1582,7 +1590,7 @@ void MouseActions::MReleaseSelect2(Schematic *Doc, QMouseEvent *Event)
if(Event->button() != Qt::LeftButton) return;
bool Ctrl;
if(Event->state() & Qt::ControlModifier) Ctrl = true;
if(Event->modifiers().testFlag(Qt::ControlModifier)) Ctrl = true;
else Ctrl = false;
// selects all elements within the rectangle
@ -1783,7 +1791,7 @@ void MouseActions::MReleasePaste(Schematic *Doc, QMouseEvent *Event)
break;
case isDiagram:
Doc->Diagrams->append((Diagram*)pe);
((Diagram*)pe)->loadGraphData(Info.dirPath() + QDir::separator() +
((Diagram*)pe)->loadGraphData(Info.absolutePath() + QDir::separator() +
Doc->DataSet);
Doc->enlargeView(pe->cx, pe->cy-pe->y2, pe->cx+pe->x2, pe->cy);
break;

2
qucs/mouseactions.h
View File

@ -20,7 +20,7 @@
#include "element.h"
#include <Q3PtrList>
#include <qt3_compat/qt_compat.h>
class Wire;
class Schematic;

14
qucs/octave_window.cpp
View File

@ -16,6 +16,8 @@
#include <QDebug>
#include <QMessageBox>
#include "misc.h"
#ifdef __MINGW32__
#define executableSuffix ".exe"
@ -39,9 +41,9 @@ OctaveWindow::OctaveWindow(QDockWidget *parent_): QWidget()
output = new QTextEdit(this);
output->setReadOnly(true);
output->setUndoRedoEnabled(false);
output->setTextFormat(Qt::LogText);
output->toPlainText();
output->setLineWrapMode(QTextEdit::NoWrap);
output->setPaletteBackgroundColor(QucsSettings.BGColor);
misc::setWidgetBackgroundColor(output,QucsSettings.BGColor);
allLayout->addWidget(output);
input = new QLineEdit(this);
@ -128,7 +130,7 @@ bool OctaveWindow::startOctave()
// ------------------------------------------------------------------------
void OctaveWindow::adjustDirectory()
{
sendCommand("cd \"" + QucsSettings.QucsWorkDir.absPath() + "\"");
sendCommand("cd \"" + QucsSettings.QucsWorkDir.absolutePath() + "\"");
}
// ------------------------------------------------------------------------
@ -139,16 +141,18 @@ void OctaveWindow::sendCommand(const QString& cmd)
output->setTextColor(QColor(Qt::blue));
output->append(cmd);
QString cmdstr = cmd + "\n";
QByteArray ba = cmdstr.toLatin1();
const char *c_cmdstr = ba.data();
//output->insertAt(cmdstr, par, idx);
//output->scrollToBottom();
octProcess.write(cmdstr);
octProcess.write(c_cmdstr);
}
// ------------------------------------------------------------------------
void OctaveWindow::runOctaveScript(const QString& name)
{
QFileInfo info(name);
sendCommand(info.baseName(true));
sendCommand(info.baseName());
}
// ------------------------------------------------------------------------

6
qucs/printerwriter.cpp
View File

@ -33,9 +33,9 @@ PrinterWriter::PrinterWriter()
{
//default setting
Printer = new QPrinter(QPrinter::HighResolution);
Printer->setOptionEnabled(QPrinter::PrintSelection, true);
/*Printer->setOptionEnabled(QPrinter::PrintSelection, true);
Printer->setOptionEnabled(QPrinter::PrintPageRange, false);
Printer->setOptionEnabled(QPrinter::PrintToFile, true);
Printer->setOptionEnabled(QPrinter::PrintToFile, true);*/
Printer->setPaperSize(QPrinter::A4);
Printer->setColorMode(QPrinter::Color);
@ -114,7 +114,7 @@ PrinterWriter::print(QWidget *doc)
return;
}
for (int z = Printer->numCopies(); z > 0; --z) {
if (Printer->aborted()) {
if (Printer->printerState() == QPrinter::Aborted) {
break;
}

2
qucs/projectView.cpp
View File

@ -104,7 +104,7 @@ ProjectView::refresh()
m_model->item(category, 0)->appendRow(data);
for(it = files.begin(); it != files.end(); ++it) {
fileName = (*it).toAscii();
fileName = (*it).toLatin1();
extName = QFileInfo(workPath.filePath(fileName)).suffix();
columnData.clear();

7
qucs/qt3_compat/CMakeLists.txt
View File

@ -12,16 +12,23 @@ q3ptrcollection.h
q3ptrdict.h
q3scrollview.h
qt_compat.h
q3ptrlist.h
q3glist.h
q3gvector.h
q3valuelist.h
)
SET(QT3_COMPAT_SRCS
q3frame.cpp
q3gdict.cpp
q3gvector.cpp
q3glist.cpp
q3scrollview.cpp
)
SET(QT3_COMPAT_MOC_HDRS
q3scrollview.h
q3frame.h
)
QT5_WRAP_CPP( QT3_COMPAT_SRCS ${QT3_COMPAT_MOC_HDRS} )

1270
qucs/qt3_compat/q3glist.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

272
qucs/qt3_compat/q3glist.h Normal file
View File

@ -0,0 +1,272 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef Q3GLIST_H
#define Q3GLIST_H
#include "q3ptrcollection.h"
class Q3LNode
{
friend class Q3GList;
friend class Q3GListIterator;
friend class Q3GListStdIterator;
public:
Q3PtrCollection::Item getData() { return data; }
private:
Q3PtrCollection::Item data;
Q3LNode *prev;
Q3LNode *next;
Q3LNode( Q3PtrCollection::Item d ) { data = d; }
};
class Q3GListIteratorList; // internal helper class
class Q3GList : public Q3PtrCollection // doubly linked generic list
{
friend class Q3GListIterator;
friend class Q3GListIteratorList;
friend class Q3GVector; // needed by Q3GVector::toList
public:
uint count() const; // return number of nodes
#ifndef QT_NO_DATASTREAM
QDataStream &read( QDataStream & ); // read list from stream
QDataStream &write( QDataStream & ) const; // write list to stream
#endif
protected:
Q3GList(); // create empty list
Q3GList( const Q3GList & ); // make copy of other list
virtual ~Q3GList();
Q3GList &operator=( const Q3GList & ); // assign from other list
bool operator==( const Q3GList& ) const;
void inSort( Q3PtrCollection::Item ); // add item sorted in list
void append( Q3PtrCollection::Item ); // add item at end of list
bool insertAt( uint index, Q3PtrCollection::Item ); // add item at i'th position
void relinkNode( Q3LNode * ); // relink as first item
bool removeNode( Q3LNode * ); // remove node
bool remove( Q3PtrCollection::Item = 0 ); // remove item (0=current)
bool removeRef( Q3PtrCollection::Item = 0 ); // remove item (0=current)
bool removeFirst(); // remove first item
bool removeLast(); // remove last item
bool removeAt( uint ); // remove item at i'th position
bool replaceAt( uint, Q3PtrCollection::Item ); // replace item at position i with item
Q3PtrCollection::Item takeNode( Q3LNode * ); // take out node
Q3PtrCollection::Item take(); // take out current item
Q3PtrCollection::Item takeAt( uint index ); // take out item at i'th pos
Q3PtrCollection::Item takeFirst(); // take out first item
Q3PtrCollection::Item takeLast(); // take out last item
void sort(); // sort all items;
void clear(); // remove all items
int findRef( Q3PtrCollection::Item, bool = true ); // find exact item in list
int find( Q3PtrCollection::Item, bool = true ); // find equal item in list
uint containsRef( Q3PtrCollection::Item ) const; // get number of exact matches
uint contains( Q3PtrCollection::Item ) const; // get number of equal matches
Q3PtrCollection::Item at( uint index ); // access item at i'th pos
int at() const; // get current index
Q3LNode *currentNode() const; // get current node
Q3PtrCollection::Item get() const; // get current item
Q3PtrCollection::Item cfirst() const; // get ptr to first list item
Q3PtrCollection::Item clast() const; // get ptr to last list item
Q3PtrCollection::Item first(); // set first item in list curr
Q3PtrCollection::Item last(); // set last item in list curr
Q3PtrCollection::Item next(); // set next item in list curr
Q3PtrCollection::Item prev(); // set prev item in list curr
void toVector( Q3GVector * ) const; // put items in vector
virtual int compareItems( Q3PtrCollection::Item, Q3PtrCollection::Item );
#ifndef QT_NO_DATASTREAM
virtual QDataStream &read( QDataStream &, Q3PtrCollection::Item & );
virtual QDataStream &write( QDataStream &, Q3PtrCollection::Item ) const;
#endif
Q3LNode* begin() const { return firstNode; }
Q3LNode* end() const { return 0; }
Q3LNode* erase( Q3LNode* it );
private:
void prepend( Q3PtrCollection::Item ); // add item at start of list
void heapSortPushDown( Q3PtrCollection::Item* heap, int first, int last );
Q3LNode *firstNode; // first node
Q3LNode *lastNode; // last node
Q3LNode *curNode; // current node
int curIndex; // current index
uint numNodes; // number of nodes
Q3GListIteratorList *iterators; // list of iterators
Q3LNode *locate( uint ); // get node at i'th pos
Q3LNode *unlink(); // unlink node
};
inline uint Q3GList::count() const
{
return numNodes;
}
inline bool Q3GList::removeFirst()
{
first();
return remove();
}
inline bool Q3GList::removeLast()
{
last();
return remove();
}
inline int Q3GList::at() const
{
return curIndex;
}
inline Q3PtrCollection::Item Q3GList::at( uint index )
{
Q3LNode *n = locate( index );
return n ? n->data : 0;
}
inline Q3LNode *Q3GList::currentNode() const
{
return curNode;
}
inline Q3PtrCollection::Item Q3GList::get() const
{
return curNode ? curNode->data : 0;
}
inline Q3PtrCollection::Item Q3GList::cfirst() const
{
return firstNode ? firstNode->data : 0;
}
inline Q3PtrCollection::Item Q3GList::clast() const
{
return lastNode ? lastNode->data : 0;
}
/*****************************************************************************
Q3GList stream functions
*****************************************************************************/
#ifndef QT_NO_DATASTREAM
QDataStream &operator>>( QDataStream &, Q3GList & );
QDataStream &operator<<( QDataStream &, const Q3GList & );
#endif
/*****************************************************************************
Q3GListIterator class
*****************************************************************************/
class Q3GListIterator // Q3GList iterator
{
friend class Q3GList;
friend class Q3GListIteratorList;
protected:
Q3GListIterator( const Q3GList & );
Q3GListIterator( const Q3GListIterator & );
Q3GListIterator &operator=( const Q3GListIterator & );
~Q3GListIterator();
bool atFirst() const; // test if at first item
bool atLast() const; // test if at last item
Q3PtrCollection::Item toFirst(); // move to first item
Q3PtrCollection::Item toLast(); // move to last item
Q3PtrCollection::Item get() const; // get current item
Q3PtrCollection::Item operator()(); // get current and move to next
Q3PtrCollection::Item operator++(); // move to next item (prefix)
Q3PtrCollection::Item operator+=(uint); // move n positions forward
Q3PtrCollection::Item operator--(); // move to prev item (prefix)
Q3PtrCollection::Item operator-=(uint); // move n positions backward
protected:
Q3GList *list; // reference to list
private:
Q3LNode *curNode; // current node in list
};
inline bool Q3GListIterator::atFirst() const
{
return curNode == list->firstNode;
}
inline bool Q3GListIterator::atLast() const
{
return curNode == list->lastNode;
}
inline Q3PtrCollection::Item Q3GListIterator::get() const
{
return curNode ? curNode->data : 0;
}
class Q3GListStdIterator
{
public:
inline Q3GListStdIterator( Q3LNode* n ) : node( n ){}
inline operator Q3LNode* () { return node; }
protected:
inline Q3LNode *next() { return node->next; }
Q3LNode *node;
};
#endif // Q3GLIST_H

598
qucs/qt3_compat/q3gvector.cpp Normal file
View File

@ -0,0 +1,598 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qglobal.h"
#if defined(Q_CC_BOR)
// needed for qsort() because of a std namespace problem on Borland
#include "qplatformdefs.h"
#endif
#define Q3GVECTOR_CPP
#include "q3gvector.h"
#include "q3glist.h"
#include "qstring.h"
#include "qdatastream.h"
#include <stdlib.h>
#define QT_NO_THREAD
#ifndef QT_NO_THREAD
# include "private/qmutexpool_p.h"
#endif
QT_BEGIN_NAMESPACE
#define USE_MALLOC // comment to use new/delete
#undef NEW
#undef DELETE
#if defined(USE_MALLOC)
#define NEW(type,size) ((type*)malloc(size*sizeof(type)))
#define DELETE(array) (free((char*)array))
#else
#define NEW(type,size) (new type[size])
#define DELETE(array) (delete[] array)
#define DONT_USE_REALLOC // comment to use realloc()
#endif
/*!
\class Q3GVector
\reentrant
\brief The Q3GVector class is an internal class for implementing Qt
collection classes.
\internal
Q3GVector is an internal class that acts as a base class for the
Q3PtrVector collection class.
Q3GVector has some virtual functions that may be reimplemented in
subclasses to customize behavior.
\list
\i compareItems() compares two collection/vector items.
\i read() reads a collection/vector item from a QDataStream.
\i write() writes a collection/vector item to a QDataStream.
\endlist
*/
/*****************************************************************************
Default implementation of virtual functions
*****************************************************************************/
/*!
This virtual function compares two list items.
Returns:
<ul>
<li> 0 if \a d1 == \a d2
<li> non-zero if \a d1 != \a d2
</ul>
This function returns \e int rather than \e bool so that
reimplementations can return one of three values and use it to sort
by:
<ul>
<li> 0 if \a d1 == \a d2
<li> \> 0 (positive integer) if \a d1 \> \a d2
<li> \< 0 (negative integer) if \a d1 \< \a d2
</ul>
The Q3PtrVector::sort() and Q3PtrVector::bsearch() functions require that
compareItems() is implemented as described here.
This function should not modify the vector because some const
functions call compareItems().
*/
int Q3GVector::compareItems( Item d1, Item d2 )
{
return d1 != d2; // compare pointers
}
#ifndef QT_NO_DATASTREAM
/*!
Reads a collection/vector item from the stream \a s and returns a reference
to the stream.
The default implementation sets \a d to 0.
\sa write()
*/
QDataStream &Q3GVector::read( QDataStream &s, Item &d )
{ // read item from stream
d = 0;
return s;
}
/*!
Writes a collection/vector item to the stream \a s and returns a reference
to the stream.
The default implementation does nothing.
\sa read()
*/
QDataStream &Q3GVector::write( QDataStream &s, Item ) const
{ // write item to stream
return s;
}
#endif // QT_NO_DATASTREAM
/*****************************************************************************
Q3GVector member functions
*****************************************************************************/
Q3GVector::Q3GVector() // create empty vector
{
vec = 0;
len = numItems = 0;
}
Q3GVector::Q3GVector( uint size ) // create vectors with nullptrs
{
len = size;
numItems = 0;
if ( len == 0 ) { // zero length
vec = 0;
return;
}
vec = NEW(Item,len);
Q_CHECK_PTR( vec );
memset( (void*)vec, 0, len*sizeof(Item) ); // fill with nulls
}
Q3GVector::Q3GVector( const Q3GVector &a ) // make copy of other vector
: Q3PtrCollection( a )
{
len = a.len;
numItems = a.numItems;
if ( len == 0 ) {
vec = 0;
return;
}
vec = NEW( Item, len );
Q_CHECK_PTR( vec );
for ( uint i = 0; i < len; i++ ) {
if ( a.vec[i] ) {
vec[i] = newItem( a.vec[i] );
Q_CHECK_PTR( vec[i] );
} else {
vec[i] = 0;
}
}
}
Q3GVector::~Q3GVector()
{
clear();
}
Q3GVector& Q3GVector::operator=( const Q3GVector &v )
{
if ( &v == this )
return *this;
clear();
len = v.len;
numItems = v.numItems;
if ( len == 0 ) {
vec = 0;
return *this;
}
vec = NEW( Item, len );
Q_CHECK_PTR( vec );
for ( uint i = 0; i < len; i++ ) {
if ( v.vec[i] ) {
vec[i] = newItem( v.vec[i] );
Q_CHECK_PTR( vec[i] );
} else {
vec[i] = 0;
}
}
return *this;
}
bool Q3GVector::insert( uint index, Item d ) // insert item at index
{
#if defined(QT_CHECK_RANGE)
if ( index >= len ) { // range error
qWarning( "Q3GVector::insert: Index %d out of range", index );
return false;
}
#endif
if ( vec[index] ) { // remove old item
deleteItem( vec[index] );
numItems--;
}
if ( d ) {
vec[index] = newItem( d );
Q_CHECK_PTR( vec[index] );
numItems++;
return vec[index] != 0;
} else {
vec[index] = 0; // reset item
}
return true;
}
bool Q3GVector::remove( uint index ) // remove item at index
{
#if defined(QT_CHECK_RANGE)
if ( index >= len ) { // range error
qWarning( "Q3GVector::remove: Index %d out of range", index );
return false;
}
#endif
if ( vec[index] ) { // valid item
deleteItem( vec[index] ); // delete it
vec[index] = 0; // reset pointer
numItems--;
}
return true;
}
Q3PtrCollection::Item Q3GVector::take( uint index ) // take out item
{
#if defined(QT_CHECK_RANGE)
if ( index >= len ) { // range error
qWarning( "Q3GVector::take: Index %d out of range", index );
return 0;
}
#endif
Item d = vec[index]; // don't delete item
if ( d )
numItems--;
vec[index] = 0;
return d;
}
void Q3GVector::clear() // clear vector
{
if ( vec ) {
for ( uint i=0; i<len; i++ ) { // delete each item
if ( vec[i] )
deleteItem( vec[i] );
}
DELETE(vec);
vec = 0;
len = numItems = 0;
}
}
bool Q3GVector::resize( uint newsize ) // resize array
{
if ( newsize == len ) // nothing to do
return true;
if ( vec ) { // existing data
if ( newsize < len ) { // shrink vector
uint i = newsize;
while ( i < len ) { // delete lost items
if ( vec[i] ) {
deleteItem( vec[i] );
numItems--;
}
i++;
}
}
if ( newsize == 0 ) { // vector becomes empty
DELETE(vec);
vec = 0;
len = numItems = 0;
return true;
}
#if defined(DONT_USE_REALLOC)
if ( newsize == 0 ) {
DELETE(vec);
vec = 0;
return false;
}
Item *newvec = NEW(Item,newsize); // manual realloc
memcpy( newvec, vec, (len < newsize ? len : newsize)*sizeof(Item) );
DELETE(vec);
vec = newvec;
#else
vec = (Item*)realloc( (char *)vec, newsize*sizeof(Item) );
#endif
} else { // create new vector
vec = NEW(Item,newsize);
len = numItems = 0;
}
Q_CHECK_PTR( vec );
if ( !vec ) // no memory
return false;
if ( newsize > len ) // init extra space added
memset( (void*)&vec[len], 0, (newsize-len)*sizeof(Item) );
len = newsize;
return true;
}
bool Q3GVector::fill( Item d, int flen ) // resize and fill vector
{
if ( flen < 0 )
flen = len; // default: use vector length
else if ( !resize( flen ) )
return false;
for ( uint i=0; i<(uint)flen; i++ ) // insert d at every index
insert( i, d );
return true;
}
static Q3GVector *sort_vec=0; // current sort vector
#if defined(Q_C_CALLBACKS)
extern "C" {
#endif
#ifdef Q_OS_WINCE
static int _cdecl cmp_vec( const void *n1, const void *n2 )
#else
static int cmp_vec( const void *n1, const void *n2 )
#endif
{
return sort_vec->compareItems( *((Q3PtrCollection::Item*)n1), *((Q3PtrCollection::Item*)n2) );
}
#if defined(Q_C_CALLBACKS)
}
#endif
void Q3GVector::sort() // sort vector
{
if ( count() == 0 ) // no elements
return;
register Item *start = &vec[0];
register Item *end = &vec[len-1];
Item tmp;
for (;;) { // put all zero elements behind
while ( start < end && *start != 0 )
start++;
while ( end > start && *end == 0 )
end--;
if ( start < end ) {
tmp = *start;
*start = *end;
*end = tmp;
} else {
break;
}
}
#ifndef QT_NO_THREAD
QMutexLocker locker(QMutexPool::globalInstanceGet(&sort_vec));
#endif
sort_vec = (Q3GVector*)this;
qsort( vec, count(), sizeof(Item), cmp_vec );
sort_vec = 0;
}
int Q3GVector::bsearch( Item d ) const // binary search; when sorted
{
if ( !len )
return -1;
if ( !d ) {
#if defined(QT_CHECK_NULL)
qWarning( "Q3GVector::bsearch: Cannot search for null object" );
#endif
return -1;
}
int n1 = 0;
int n2 = len - 1;
int mid = 0;
bool found = false;
while ( n1 <= n2 ) {
int res;
mid = (n1 + n2)/2;
if ( vec[mid] == 0 ) // null item greater
res = -1;
else
res = ((Q3GVector*)this)->compareItems( d, vec[mid] );
if ( res < 0 )
n2 = mid - 1;
else if ( res > 0 )
n1 = mid + 1;
else { // found it
found = true;
break;
}
}
if ( !found )
return -1;
// search to first of equal items
while ( (mid - 1 >= 0) && !((Q3GVector*)this)->compareItems(d, vec[mid-1]) )
mid--;
return mid;
}
int Q3GVector::findRef( Item d, uint index) const // find exact item in vector
{
#if defined(QT_CHECK_RANGE)
if ( index > len ) { // range error
qWarning( "Q3GVector::findRef: Index %d out of range", index );
return -1;
}
#endif
for ( uint i=index; i<len; i++ ) {
if ( vec[i] == d )
return i;
}
return -1;
}
int Q3GVector::find( Item d, uint index ) const // find equal item in vector
{
#if defined(QT_CHECK_RANGE)
if ( index >= len ) { // range error
qWarning( "Q3GVector::find: Index %d out of range", index );
return -1;
}
#endif
for ( uint i=index; i<len; i++ ) {
if ( vec[i] == 0 && d == 0 ) // found null item
return i;
if ( vec[i] && ((Q3GVector*)this)->compareItems( vec[i], d ) == 0 )
return i;
}
return -1;
}
uint Q3GVector::containsRef( Item d ) const // get number of exact matches
{
uint count = 0;
for ( uint i=0; i<len; i++ ) {
if ( vec[i] == d )
count++;
}
return count;
}
uint Q3GVector::contains( Item d ) const // get number of equal matches
{
uint count = 0;
for ( uint i=0; i<len; i++ ) {
if ( vec[i] == 0 && d == 0 ) // count null items
count++;
if ( vec[i] && ((Q3GVector*)this)->compareItems( vec[i], d ) == 0 )
count++;
}
return count;
}
bool Q3GVector::insertExpand( uint index, Item d )// insert and grow if necessary
{
if ( index >= len ) {
if ( !resize( index+1 ) ) // no memory
return false;
}
insert( index, d );
return true;
}
void Q3GVector::toList( Q3GList *list ) const // store items in list
{
list->clear();
for ( uint i=0; i<len; i++ ) {
if ( vec[i] )
list->append( vec[i] );
}
}
void Q3GVector::warningIndexRange( uint i )
{
#if defined(QT_CHECK_RANGE)
qWarning( "Q3GVector::operator[]: Index %d out of range", i );
#else
Q_UNUSED( i )
#endif
}
/*****************************************************************************
Q3GVector stream functions
*****************************************************************************/
#ifndef QT_NO_DATASTREAM
QDataStream &operator>>( QDataStream &s, Q3GVector &vec )
{ // read vector
return vec.read( s );
}
QDataStream &operator<<( QDataStream &s, const Q3GVector &vec )
{ // write vector
return vec.write( s );
}
QDataStream &Q3GVector::read( QDataStream &s ) // read vector from stream
{
uint num;
s >> num; // read number of items
clear(); // clear vector
resize( num );
for (uint i=0; i<num; i++) { // read all items
Item d;
read( s, d );
Q_CHECK_PTR( d );
if ( !d ) // no memory
break;
vec[i] = d;
}
return s;
}
QDataStream &Q3GVector::write( QDataStream &s ) const
{ // write vector to stream
uint num = count();
s << num; // number of items to write
num = size();
for (uint i=0; i<num; i++) { // write non-null items
if ( vec[i] )
write( s, vec[i] );
}
return s;
}
/* Returns whether v equals this vector or not */
bool Q3GVector::operator==( const Q3GVector &v ) const
{
if ( size() != v.size() )
return false;
if ( count() != v.count() )
return false;
for ( int i = 0; i < (int)size(); ++i ) {
if ( ( (Q3GVector*)this )->compareItems( at( i ), v.at( i ) ) != 0 )
return false;
}
return true;
}
#endif // QT_NO_DATASTREAM
QT_END_NAMESPACE

126
qucs/qt3_compat/q3gvector.h Normal file
View File

@ -0,0 +1,126 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef Q3GVECTOR_H
#define Q3GVECTOR_H
#include "q3ptrcollection.h"
class Q3GVector : public Q3PtrCollection // generic vector
{
friend class Q3GList; // needed by Q3GList::toVector
public:
#ifndef QT_NO_DATASTREAM
QDataStream &read( QDataStream & ); // read vector from stream
QDataStream &write( QDataStream & ) const; // write vector to stream
#endif
virtual int compareItems( Item, Item );
protected:
Q3GVector(); // create empty vector
Q3GVector( uint size ); // create vector with nullptrs
Q3GVector( const Q3GVector &v ); // make copy of other vector
~Q3GVector();
Q3GVector &operator=( const Q3GVector &v ); // assign from other vector
bool operator==( const Q3GVector &v ) const;
Item *data() const { return vec; }
uint size() const { return len; }
uint count() const { return numItems; }
bool insert( uint index, Item ); // insert item at index
bool remove( uint index ); // remove item
Item take( uint index ); // take out item
void clear(); // clear vector
bool resize( uint newsize ); // resize vector
bool fill( Item, int flen ); // resize and fill vector
void sort(); // sort vector
int bsearch( Item ) const; // binary search (when sorted)
int findRef( Item, uint index ) const; // find exact item in vector
int find( Item, uint index ) const; // find equal item in vector
uint containsRef( Item ) const; // get number of exact matches
uint contains( Item ) const; // get number of equal matches
Item at( uint index ) const // return indexed item
{
#if defined(QT_CHECK_RANGE)
if ( index >= len )
warningIndexRange( index );
#endif
return vec[index];
}
bool insertExpand( uint index, Item ); // insert, expand if necessary
void toList( Q3GList * ) const; // put items in list
#ifndef QT_NO_DATASTREAM
virtual QDataStream &read( QDataStream &, Item & );
virtual QDataStream &write( QDataStream &, Item ) const;
#endif
private:
Item *vec;
uint len;
uint numItems;
static void warningIndexRange( uint );
};
/*****************************************************************************
Q3GVector stream functions
*****************************************************************************/
#ifndef QT_NO_DATASTREAM
QDataStream &operator>>( QDataStream &, Q3GVector & );
QDataStream &operator<<( QDataStream &, const Q3GVector & );
#endif
#endif // Q3GVECTOR_H

2
qucs/qt3_compat/q3ptrcollection.h
View File

@ -67,7 +67,7 @@ protected:
bool del_item; // default false
virtual Item newItem(Item); // create object
virtual Item newItem(Item d) { return d; } // create object
virtual void deleteItem(Item) = 0; // delete object
};

190
qucs/qt3_compat/q3ptrlist.h Normal file
View File

@ -0,0 +1,190 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef Q3PTRLIST_H
#define Q3PTRLIST_H
#include "q3glist.h"
template<class type>
class Q3PtrListStdIterator : public Q3GListStdIterator
{
public:
inline Q3PtrListStdIterator( Q3LNode* n ): Q3GListStdIterator(n) {}
type *operator*() { return node ? (type *)node->getData() : 0; }
inline Q3PtrListStdIterator<type> operator++()
{ node = next(); return *this; }
inline Q3PtrListStdIterator<type> operator++(int)
{ Q3LNode* n = node; node = next(); return Q3PtrListStdIterator<type>( n ); }
inline bool operator==( const Q3PtrListStdIterator<type>& it ) const { return node == it.node; }
inline bool operator!=( const Q3PtrListStdIterator<type>& it ) const { return node != it.node; }
};
template<class type>
class Q3PtrList
#ifdef qdoc
: public Q3PtrCollection
#else
: public Q3GList
#endif
{
public:
Q3PtrList() {}
Q3PtrList( const Q3PtrList<type> &l ) : Q3GList(l) {}
~Q3PtrList() { clear(); }
Q3PtrList<type> &operator=(const Q3PtrList<type> &l)
{ return (Q3PtrList<type>&)Q3GList::operator=(l); }
bool operator==( const Q3PtrList<type> &list ) const
{ return Q3GList::operator==( list ); }
bool operator!=( const Q3PtrList<type> &list ) const
{ return !Q3GList::operator==( list ); }
uint count() const { return Q3GList::count(); }
bool isEmpty() const { return Q3GList::count() == 0; }
bool insert( uint i, const type *d){ return Q3GList::insertAt(i,(Q3PtrCollection::Item)d); }
void inSort( const type *d ) { Q3GList::inSort((Q3PtrCollection::Item)d); }
void prepend( const type *d ) { Q3GList::insertAt(0,(Q3PtrCollection::Item)d); }
void append( const type *d ) { Q3GList::append((Q3PtrCollection::Item)d); }
bool remove( uint i ) { return Q3GList::removeAt(i); }
bool remove() { return Q3GList::remove((Q3PtrCollection::Item)0); }
bool remove( const type *d ) { return Q3GList::remove((Q3PtrCollection::Item)d); }
bool removeRef( const type *d ) { return Q3GList::removeRef((Q3PtrCollection::Item)d); }
void removeNode( Q3LNode *n ) { Q3GList::removeNode(n); }
bool removeFirst() { return Q3GList::removeFirst(); }
bool removeLast() { return Q3GList::removeLast(); }
type *take( uint i ) { return (type *)Q3GList::takeAt(i); }
type *take() { return (type *)Q3GList::take(); }
type *takeNode( Q3LNode *n ) { return (type *)Q3GList::takeNode(n); }
void clear() { Q3GList::clear(); }
void sort() { Q3GList::sort(); }
int find( const type *d ) { return Q3GList::find((Q3PtrCollection::Item)d); }
int findNext( const type *d ) { return Q3GList::find((Q3PtrCollection::Item)d,false); }
int findRef( const type *d ) { return Q3GList::findRef((Q3PtrCollection::Item)d); }
int findNextRef( const type *d ){ return Q3GList::findRef((Q3PtrCollection::Item)d,false);}
uint contains( const type *d ) const { return Q3GList::contains((Q3PtrCollection::Item)d); }
uint containsRef( const type *d ) const
{ return Q3GList::containsRef((Q3PtrCollection::Item)d); }
bool replace( uint i, const type *d ) { return Q3GList::replaceAt( i, (Q3PtrCollection::Item)d ); }
type *at( uint i ) { return (type *)Q3GList::at(i); }
int at() const { return Q3GList::at(); }
type *current() const { return (type *)Q3GList::get(); }
Q3LNode *currentNode() const { return Q3GList::currentNode(); }
type *getFirst() const { return (type *)Q3GList::cfirst(); }
type *getLast() const { return (type *)Q3GList::clast(); }
type *first() { return (type *)Q3GList::first(); }
type *last() { return (type *)Q3GList::last(); }
type *next() { return (type *)Q3GList::next(); }
type *prev() { return (type *)Q3GList::prev(); }
void toVector( Q3GVector *vec )const{ Q3GList::toVector(vec); }
// standard iterators
typedef Q3PtrListStdIterator<type> Iterator;
typedef Q3PtrListStdIterator<type> ConstIterator;
inline Iterator begin() { return Q3GList::begin(); }
inline ConstIterator begin() const { return Q3GList::begin(); }
inline ConstIterator constBegin() const { return Q3GList::begin(); }
inline Iterator end() { return Q3GList::end(); }
inline ConstIterator end() const { return Q3GList::end(); }
inline ConstIterator constEnd() const { return Q3GList::end(); }
inline Iterator erase( Iterator it ) { return Q3GList::erase( it ); }
// stl syntax compatibility
typedef Iterator iterator;
typedef ConstIterator const_iterator;
#ifdef qdoc
protected:
virtual int compareItems( Q3PtrCollection::Item, Q3PtrCollection::Item );
virtual QDataStream& read( QDataStream&, Q3PtrCollection::Item& );
virtual QDataStream& write( QDataStream&, Q3PtrCollection::Item ) const;
#endif
private:
void deleteItem( Item d );
};
#if !defined(Q_BROKEN_TEMPLATE_SPECIALIZATION)
template<> inline void Q3PtrList<void>::deleteItem( Q3PtrCollection::Item )
{
}
#endif
template<class type> inline void Q3PtrList<type>::deleteItem( Q3PtrCollection::Item d )
{
if ( del_item ) delete (type *)d;
}
template<class type>
class Q3PtrListIterator : public Q3GListIterator
{
public:
Q3PtrListIterator(const Q3PtrList<type> &l) :Q3GListIterator((Q3GList &)l) {}
~Q3PtrListIterator() {}
uint count() const { return list->count(); }
bool isEmpty() const { return list->count() == 0; }
bool atFirst() const { return Q3GListIterator::atFirst(); }
bool atLast() const { return Q3GListIterator::atLast(); }
type *toFirst() { return (type *)Q3GListIterator::toFirst(); }
type *toLast() { return (type *)Q3GListIterator::toLast(); }
operator type *() const { return (type *)Q3GListIterator::get(); }
type *operator*() { return (type *)Q3GListIterator::get(); }
// No good, since Q3PtrList<char> (ie. QStrList fails...
//
// MSVC++ gives warning
// Sunpro C++ 4.1 gives error
// type *operator->() { return (type *)Q3GListIterator::get(); }
type *current() const { return (type *)Q3GListIterator::get(); }
type *operator()() { return (type *)Q3GListIterator::operator()();}
type *operator++() { return (type *)Q3GListIterator::operator++(); }
type *operator+=(uint j) { return (type *)Q3GListIterator::operator+=(j);}
type *operator--() { return (type *)Q3GListIterator::operator--(); }
type *operator-=(uint j) { return (type *)Q3GListIterator::operator-=(j);}
Q3PtrListIterator<type>& operator=(const Q3PtrListIterator<type>&it)
{ Q3GListIterator::operator=(it); return *this; }
};
#endif // Q3PTRLIST_H

23
qucs/qt3_compat/q3scrollview.cpp
View File

@ -98,29 +98,10 @@ void QSVChildRec::hideOrShow(Q3ScrollView* sv, QWidget* clipped_viewport)
}
}
class QAbstractScrollAreaWidget : public QWidget
{
Q_OBJECT
public:
QAbstractScrollAreaWidget(Q3ScrollView* parent=0, const char* name=0, Qt::WindowFlags f = 0)
: QWidget(parent, f)
{
setAutoFillBackground(true);
}
};
class QClipperWidget : public QWidget
{
Q_OBJECT
public:
QClipperWidget(QWidget * parent=0, const char * name=0, Qt::WindowFlags f=0)
: QWidget (parent,f) {}
};
QT_BEGIN_INCLUDE_NAMESPACE
#include "q3scrollview.moc"
//#include "q3scrollview.moc"
QT_END_INCLUDE_NAMESPACE
class Q3ScrollViewData {
@ -1111,6 +1092,7 @@ void Q3ScrollView::resizeEvent(QResizeEvent* event)
d->inresize = true;
updateScrollBars();
d->inresize = inresize;
d->scrollbar_timer.setSingleShot(true);
d->scrollbar_timer.start(0);
d->hideOrShowAll(this);
@ -2166,6 +2148,7 @@ void Q3ScrollView::resizeContents(int w, int h)
d->vwidth = w;
d->vheight = h;
d->scrollbar_timer.setSingleShot(true);
d->scrollbar_timer.start(0);
if (d->children.isEmpty() && d->policy == Default)

22
qucs/qt3_compat/q3scrollview.h
View File

@ -228,5 +228,27 @@ public:
};
class QAbstractScrollAreaWidget : public QWidget
{
Q_OBJECT
public:
QAbstractScrollAreaWidget(Q3ScrollView* parent=0, const char* name=0, Qt::WindowFlags f = 0)
: QWidget(parent, f)
{
Q_UNUSED(name);
setAutoFillBackground(true);
}
};
class QClipperWidget : public QWidget
{
Q_OBJECT
public:
QClipperWidget(QWidget * parent=0, const char * name=0, Qt::WindowFlags f=0)
: QWidget (parent,f) { Q_UNUSED(name); }
};
#endif // Q3SCROLLVIEW_H

238
qucs/qt3_compat/q3valuelist.h Normal file
View File

@ -0,0 +1,238 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef Q3VALUELIST_H
#define Q3VALUELIST_H
#include <QtCore/qalgorithms.h>
#include <QtCore/qdatastream.h>
#include <QtCore/qlinkedlist.h>
#include <QtCore/qlist.h>
#ifndef QT_NO_STL
#include <iterator>
#include <list>
#endif
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
QT_MODULE(Qt3SupportLight)
template <typename T>
class Q3ValueListIterator : public QLinkedList<T>::iterator
{
public:
inline Q3ValueListIterator() :
QLinkedList<T>::iterator() {}
inline Q3ValueListIterator(const Q3ValueListIterator &o) :
QLinkedList<T>::iterator(o) {}
inline Q3ValueListIterator(const typename QLinkedList<T>::iterator &o) :
QLinkedList<T>::iterator(o) {}
};
template <typename T>
class Q3ValueListConstIterator : public QLinkedList<T>::const_iterator
{
public:
inline Q3ValueListConstIterator() {}
inline Q3ValueListConstIterator(const Q3ValueListConstIterator &o) :
QLinkedList<T>::const_iterator(o) {}
inline Q3ValueListConstIterator(const typename QLinkedList<T>::const_iterator &o) :
QLinkedList<T>::const_iterator(o) {}
inline Q3ValueListConstIterator(const typename QLinkedList<T>::iterator &o) :
QLinkedList<T>::const_iterator(o) {}
};
template <typename T>
class Q3ValueList : public QLinkedList<T>
{
public:
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
#ifndef QT_NO_STL
typedef ptrdiff_t difference_type;
#else
typedef int difference_type;
#endif
typedef Q3ValueListIterator<T> Iterator;
typedef Q3ValueListConstIterator<T> ConstIterator;
typedef Q3ValueListIterator<T> iterator;
typedef Q3ValueListConstIterator<T> const_iterator;
typedef typename QLinkedList<T>::size_type size_type;
/**
* API
*/
Q3ValueList() {}
Q3ValueList(const Q3ValueList<T>& l) : QLinkedList<T>(l) {}
Q3ValueList(const QLinkedList<T>& l) : QLinkedList<T>(l) {}
Q3ValueList(const QList<T>& l)
{
for (int i = 0; i < l.size(); ++i) append(l.at(i));
}
#ifndef QT_NO_STL
Q3ValueList(const std::list<T>& l)
{
qCopy(l.begin(), l.end(), std::back_inserter(*this));
}
#endif
~Q3ValueList() {}
Q3ValueList<T>& operator= (const Q3ValueList<T>& l)
{
QLinkedList<T>::operator=(l);
return *this;
}
Q3ValueList<T>& operator= (const QList<T>& l)
{
this->clear();
for (int i = 0; i < l.size(); ++i) append(l.at(i));
return *this;
}
#ifndef QT_NO_STL
Q3ValueList<T>& operator= (const std::list<T>& l)
{
this->detach();
qCopy(l.begin(), l.end(), std::back_inserter(*this));
return *this;
}
bool operator== (const std::list<T>& l) const
{
if (this->size() != l.size())
return false;
typename Q3ValueList<T>::const_iterator it2 = this->begin();
#if !defined(Q_CC_MIPS)
typename
#endif
std::list<T>::const_iterator it = l.begin();
for (; it2 != this->end(); ++it2, ++it)
if (!((*it2) == (*it)))
return false;
return true;
}
#endif
bool operator== (const Q3ValueList<T>& l) const { return QLinkedList<T>::operator==(l); }
bool operator!= (const Q3ValueList<T>& l) const { return QLinkedList<T>::operator!=(l); }
operator QList<T>() const {
QList<T> list;
for (typename Q3ValueList<T>::const_iterator it = QLinkedList<T>::constBegin();
it != QLinkedList<T>::constEnd(); ++it)
list.append(*it);
return list;
}
inline Q3ValueList<T>& operator<< (const T& x) { append(x); return *this; }
void insert(typename Q3ValueList<T>::Iterator pos,
typename Q3ValueList<T>::size_type n,
const T& x);
typename Q3ValueList<T>::Iterator insert(typename Q3ValueList<T>::Iterator pos,
const T& x)
{ return QLinkedList<T>::insert(pos, x); }
typename Q3ValueList<T>::Iterator remove(typename Q3ValueList<T>::Iterator pos)
{ return QLinkedList<T>::erase(pos); }
int remove(const T &value)
{ return QLinkedList<T>::removeAll(value); }
inline Q3ValueList<T> operator+ (const Q3ValueList<T>& l) const
{ return static_cast<Q3ValueList<T> >(QLinkedList<T>::operator+(l)); }
inline Q3ValueList<T>& operator+= (const Q3ValueList<T>& l)
{ QLinkedList<T>::operator+=(l); return *this; }
typename Q3ValueList<T>::Iterator fromLast()
{ return (this->isEmpty() ? this->end() : --this->end()); }
typename Q3ValueList<T>::ConstIterator fromLast() const
{ return (this->isEmpty() ? this->end() : --this->end()); }
typename Q3ValueList<T>::Iterator append(const T& x)
{ QLinkedList<T>::append(x); return --this->end(); }
typename Q3ValueList<T>::Iterator prepend(const T& x)
{ QLinkedList<T>::prepend(x); return this->begin(); }
typename Q3ValueList<T>::Iterator at(typename Q3ValueList<T>::size_type i)
{ Q_ASSERT(i < this->size()); this->detach(); return this->begin()+i; }
typename Q3ValueList<T>::ConstIterator at(typename Q3ValueList<T>::size_type i) const
{ Q_ASSERT(i < this->size()); return this->begin()+i; }
typename Q3ValueList<T>::size_type contains(const T& x) const
{ return QLinkedList<T>::count(x); }
Q3ValueList<T>& operator+= (const T& x) { append(x); return *this; }
T& operator[] (typename Q3ValueList<T>::size_type i) { return *at(i); }
const T& operator[] (typename Q3ValueList<T>::size_type i) const { return *at(i); }
};
template <typename T>
Q_OUTOFLINE_TEMPLATE void Q3ValueList<T>::insert(typename Q3ValueList<T>::Iterator pos,
typename Q3ValueList<T>::size_type n, const T& x)
{
for (; n > 0; --n)
this->insert(pos, x);
}
#ifndef QT_NO_DATASTREAM
template <typename T>
Q_OUTOFLINE_TEMPLATE QDataStream& operator>>(QDataStream& s, Q3ValueList<T>& l)
{
return operator>>(s, static_cast<QLinkedList<T> &>(l));
}
template <typename T>
Q_OUTOFLINE_TEMPLATE QDataStream& operator<<(QDataStream& s, const Q3ValueList<T>& l)
{
return operator<<(s, static_cast<const QLinkedList<T> &>(l));
}
#endif
QT_END_NAMESPACE
QT_END_HEADER
#endif // Q3VALUELIST_H

241
qucs/qt3_compat/qt_compat.h
View File

@ -20,246 +20,7 @@
#ifndef QUCS_CONTAINER_H
#define QUCS_CONTAINER_H
#include <QList>
#include <QDebug>
// TODO: trace.h
#include <iostream>
#define incomplete() ( \
std::cerr << "@@#\n@@@\nincomplete:" \
<< __FILE__ << ":" << __LINE__ << ":" << __func__ << "\n" )
#ifdef DO_TRACE
#define untested() ( std::cerr << "@@#\n@@@:"<< __FILE__ << ":"<< __LINE__ \
<<":" << __func__ << "\n" )
#else
#define untested()
#endif
#define itested()
// implement Q3Ptrlist for use in old code.
// just don't use it in new code.
template <class T>
class Q3PtrList {
public:
typedef QList<T*> container_type;
typedef typename container_type::const_iterator const_iterator;
typedef typename container_type::iterator iterator;
public:
Q3PtrList() : _autodelete(false) { };
Q3PtrList(const T &val) : _autodelete(false) { untested();
localList(val);
cur = localList.end();
};
~Q3PtrList() {
if(_autodelete){
for(auto x : localList){
delete x;
}
}else{
}
};
T* at(unsigned int i) {
if (i < (unsigned int)localList.count()) {
cur = localList.begin()+i;
return *cur;
} else {
cur = localList.end();
return nullptr;
}
};
int at() { untested();
incomplete();
return -1;
};
void setAutoDelete(bool b) {
_autodelete = b;
};
T* first() { // pointer to first element
cur = localList.begin();
if (localList.count() == 0)
return nullptr;
return *cur;
};
T* last() { // pointer to last element
if (localList.count()) { untested();
cur = localList.end()-1; // yikes. no rbegin. use std::list?!
return *cur;
} else { untested();
return nullptr;
}
};
void append(T *t) {
localList.append(t);
};
int contains(T *) { untested();
incomplete();
return -1;
};
int findNext(T *) { untested();
incomplete();
return -1;
};
int findNextRef(T *) { untested();
incomplete();
return -1;
};
bool isEmpty() { untested();
incomplete();
return false;
};
int findPrev() { untested();
incomplete();
return -1;
};
bool replace(int, T*) { untested();
incomplete();
return true;
};
int containsRef(T *t) { untested();
int n = 0;
for (int i = 0; i < localList.count(); i++){ untested();
if (t == localList[i]) { untested();
n++;
}
}
return n;
};
int findRef(T *t) {
auto i=0;
for (cur=localList.begin(); cur!=localList.end(); ++cur){
if (t == *cur){
return i;
}
++i;
}
return -1;
};
bool removeRef(T *t) { untested();
int nr = findRef(t);
if (nr >= 0) { untested();
remove(nr);
return true;
}
return false;
};
void prepend(T *t) { untested();
localList.insert(0, t);
};
T* take(uint index) { untested();
return localList.takeAt(index);
};
T* take() { untested();
if (cur != localList.end()){ untested();
auto t=*cur;
auto newcur=cur;
++newcur;
localList.erase(cur);
cur=newcur;
return t;
} else { untested();
return nullptr;
}
};
T* getFirst() { itested();
return localList.first();
};
T* getLast() { itested();
return localList.last();
};
T* next() { // get pointer to next element, correct the current
if (cur == localList.end()){ untested();
return nullptr;
}else{
cur++;
if (cur==localList.end()){
return nullptr;
}else{
return *cur;
}
}
};
T* prev() { // get pointer to prev element, correct the current
if (cur == localList.end()) { untested();
return nullptr;
}else if (cur == localList.begin()){ untested();
cur=localList.end();
return nullptr;
}else{ untested();
cur--;
return *cur;
}
};
T* current() { // get pointer to current element
if (cur==localList.end()){ untested();
return nullptr;
}else{ untested();
return *cur;
}
};
unsigned int count() {
return (unsigned int)localList.count();
};
void remove(int i) { //
if (i >= 0 && i < localList.count()) { untested();
localList.removeAt(i);
}
};
void remove() { // remove the current element
if (cur!=localList.end()){ untested();
auto next=cur;
++next;
if(_autodelete){ untested();
delete *cur;
}
localList.erase(cur);
}else{ untested();
}
};
void removeLast() { untested();
int c = localList.count() -1;
if (c >= 0) { untested();
localList.removeAt(c);
}
};
void removeFirst() { untested();
int c = localList.count() -1;
if (c >= 0) { untested();
localList.removeAt(0);
}
};
void insert(unsigned int i, T *t) { untested();
localList.insert(i, t);
cur=localList.begin()+i;
};
int find(T *t) { untested();
for (int i = 0; i < localList.count(); i++){ untested();
if (t == localList[i]) { untested();
return i;
}
}
return -1;
};
const_iterator begin() const{ untested();
return localList.begin();
}
const_iterator end() const{ untested();
return localList.end();
}
iterator begin(){
return localList.begin();
}
iterator end(){
return localList.end();
}
void clear(){
return localList.clear();
}
private:
QList<T*> localList; // why not std::list!?
bool _autodelete;
typename QList<T*>::iterator cur;
};
#include "q3ptrlist.h"
#endif

28
qucs/qucs.cpp
View File

@ -183,9 +183,11 @@ QucsApp::QucsApp()
lastExportFilename = QDir::homePath() + QDir::separator() + "export.png";
// load documents given as command line arguments
for(int z=1; z<qApp->argc(); z++) {
QString arg = qApp->argv()[z];
if(*(arg) != '-') {
for(int z=1; z<qApp->arguments().size(); z++) {
QString arg = qApp->arguments()[z];
QByteArray ba = arg.toLatin1();
const char *c_arg = ba.data();
if(*(c_arg) != '-') {
QFileInfo Info(arg);
QucsSettings.QucsWorkDir.setPath(Info.absoluteDir().absolutePath());
arg = QucsSettings.QucsWorkDir.filePath(Info.fileName());
@ -605,9 +607,9 @@ QucsDoc * QucsApp::findDoc (QString File, int * Pos)
{
QucsDoc * d;
int No = 0;
File = QDir::convertSeparators (File);
File = QDir::toNativeSeparators (File);
while ((d = getDoc (No++)) != 0)
if (QDir::convertSeparators (d->DocName) == File) {
if (QDir::toNativeSeparators (d->DocName) == File) {
if (Pos) *Pos = No - 1;
return d;
}
@ -1287,7 +1289,7 @@ void QucsApp::slotMenuProjClose()
slotResetWarnings();
setWindowTitle("Qucs " PACKAGE_VERSION + tr(" - Project: "));
QucsSettings.QucsWorkDir.setPath(QDir::homePath()+QDir::convertSeparators ("/.qucs"));
QucsSettings.QucsWorkDir.setPath(QDir::homePath()+QDir::toNativeSeparators ("/.qucs"));
octave->adjustDirectory();
Content->setProjPath("");
@ -2886,8 +2888,8 @@ void QucsApp::slotSimSettings()
void QucsApp::slotSimulateWithSpice()
{
if (!isTextDocument(DocumentTab->currentPage())) {
Schematic *sch = (Schematic*)DocumentTab->currentPage();
if (!isTextDocument(DocumentTab->currentWidget())) {
Schematic *sch = (Schematic*)DocumentTab->currentWidget();
ExternSimDialog *SimDlg = new ExternSimDialog(sch);
connect(SimDlg,SIGNAL(simulated()),this,SLOT(slotAfterSpiceSimulation()));
@ -2905,7 +2907,7 @@ void QucsApp::slotSimulateWithSpice()
void QucsApp::slotAfterSpiceSimulation()
{
Schematic *sch = (Schematic*)DocumentTab->currentPage();
Schematic *sch = (Schematic*)DocumentTab->currentWidget();
sch->reloadGraphs();
sch->viewport()->update();
if(sch->SimRunScript) {
@ -2917,8 +2919,8 @@ void QucsApp::slotAfterSpiceSimulation()
void QucsApp::slotBuildVAModule()
{
if (!isTextDocument(DocumentTab->currentPage())) {
Schematic *Sch = (Schematic*)DocumentTab->currentPage();
if (!isTextDocument(DocumentTab->currentWidget())) {
Schematic *Sch = (Schematic*)DocumentTab->currentWidget();
QFileInfo inf(Sch->DocName);
QString filename = QFileDialog::getSaveFileName(this,tr("Save Verilog-A module"),
@ -2947,8 +2949,8 @@ void QucsApp::slotBuildVAModule()
void QucsApp::slotBuildXSPICEIfs(int mode)
{
if (!isTextDocument(DocumentTab->currentPage())) {
Schematic *Sch = (Schematic*)DocumentTab->currentPage();
if (!isTextDocument(DocumentTab->currentWidget())) {
Schematic *Sch = (Schematic*)DocumentTab->currentWidget();
QFileInfo inf(Sch->DocName);

129
qucs/qucs_actions.cpp
View File

@ -26,7 +26,7 @@
#include <limits.h>
#include <QProcess>
#include <Q3PtrList>
#include <qt3_compat/q3ptrlist.h>
#include <QRegExpValidator>
#include <QLineEdit>
#include <QAction>
@ -85,7 +85,7 @@ bool QucsApp::performToggleAction(bool on, QAction *Action,
return false;
}
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
do {
if(Function) if((Doc->*Function)()) {
Action->blockSignals(true);
@ -152,13 +152,13 @@ void QucsApp::slotEditMirrorY(bool on)
// \todo update the status or tooltip message
void QucsApp::slotEditActivate (bool on)
{
TextDoc * Doc = (TextDoc *) DocumentTab->currentPage ();
TextDoc * Doc = (TextDoc *) DocumentTab->currentWidget();
if (isTextDocument (Doc)) {
//TODO Doc->clearParagraphBackground (Doc->tmpPosX);
Doc->commentSelected ();
editActivate->blockSignals (true);
editActivate->setOn (false); // release toolbar button
editActivate->setChecked(false); // release toolbar button
editActivate->blockSignals (false);
}
else
@ -171,7 +171,7 @@ void QucsApp::slotEditActivate (bool on)
// Is called if "Delete"-Button is pressed.
void QucsApp::slotEditDelete(bool on)
{
TextDoc *Doc = (TextDoc*)DocumentTab->currentPage();
TextDoc *Doc = (TextDoc*)DocumentTab->currentWidget();
if(isTextDocument(Doc)) {
Doc->viewport()->setFocus();
//Doc->del();
@ -220,7 +220,7 @@ void QucsApp::slotMoveText(bool on)
// Is called, when "Zoom in" action is triggered.
void QucsApp::slotZoomIn(bool on)
{
TextDoc *Doc = (TextDoc*)DocumentTab->currentPage();
TextDoc *Doc = (TextDoc*)DocumentTab->currentWidget();
if(isTextDocument(Doc)) {
Doc->zoomBy(1.5f);
magPlus->blockSignals(true);
@ -243,7 +243,7 @@ void QucsApp::slotEscape()
// Is called when the select toolbar button is pressed.
void QucsApp::slotSelect(bool on)
{
QWidget *w = DocumentTab->currentPage();
QWidget *w = DocumentTab->currentWidget();
if(isTextDocument(w)) {
((TextDoc*)w)->viewport()->setFocus();
select->blockSignals(true);
@ -253,7 +253,7 @@ void QucsApp::slotSelect(bool on)
}
// goto to insertWire mode if ESC pressed during wiring
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(MouseMoveAction == &MouseActions::MMoveWire2) {
MouseMoveAction = &MouseActions::MMoveWire1;
MousePressAction = &MouseActions::MPressWire1;
@ -275,39 +275,39 @@ void QucsApp::slotSelect(bool on)
// --------------------------------------------------------------------
void QucsApp::slotEditCut()
{
statusBar()->message(tr("Cutting selection..."));
statusBar()->showMessage(tr("Cutting selection..."));
slotHideEdit(); // disable text edit of component property
QWidget *Doc = DocumentTab->currentPage();
QWidget *Doc = DocumentTab->currentWidget();
if(isTextDocument (Doc)) {
((TextDoc *)Doc)->cut();
} else {
((Schematic *)Doc)->cut();
}
statusBar()->message(tr("Ready."));
statusBar()->showMessage(tr("Ready."));
}
// --------------------------------------------------------------------
void QucsApp::slotEditCopy()
{
statusBar()->message(tr("Copying selection to clipboard..."));
statusBar()->showMessage(tr("Copying selection to clipboard..."));
QWidget *Doc = DocumentTab->currentPage();
QWidget *Doc = DocumentTab->currentWidget();
if(isTextDocument (Doc)) {
((TextDoc *)Doc)->copy();
} else {
((Schematic *)Doc)->copy();
}
statusBar()->message(tr("Ready."));
statusBar()->showMessage(tr("Ready."));
}
// -----------------------------------------------------------------------
void QucsApp::slotEditPaste(bool on)
{
// get the current document
QWidget *Doc = DocumentTab->currentPage();
QWidget *Doc = DocumentTab->currentWidget();
// if the current document is a text document paste in
// the contents of the clipboard as text
@ -366,7 +366,7 @@ void QucsApp::slotEditPaste(bool on)
// -----------------------------------------------------------------------
void QucsApp::slotInsertEntity ()
{
TextDoc * Doc = (TextDoc *) DocumentTab->currentPage ();
TextDoc * Doc = (TextDoc *) DocumentTab->currentWidget ();
Doc->viewport()->setFocus ();
//TODO Doc->clearParagraphBackground (Doc->tmpPosX);
Doc->insertSkeleton ();
@ -404,7 +404,7 @@ void QucsApp::slotInsertEquation(bool on)
view->selElem = new Equation();
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(view->drawn) Doc->viewport()->update();
view->drawn = false;
MouseMoveAction = &MouseActions::MMoveElement;
@ -437,7 +437,7 @@ void QucsApp::slotInsertGround(bool on)
view->selElem = new Ground();
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(view->drawn) Doc->viewport()->update();
view->drawn = false;
MouseMoveAction = &MouseActions::MMoveElement;
@ -470,7 +470,7 @@ void QucsApp::slotInsertPort(bool on)
view->selElem = new SubCirPort();
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(view->drawn) Doc->viewport()->update();
view->drawn = false;
MouseMoveAction = &MouseActions::MMoveElement;
@ -481,7 +481,7 @@ void QucsApp::slotInsertPort(bool on)
// Is called, when "Undo"-Button is pressed.
void QucsApp::slotEditUndo()
{
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(isTextDocument(Doc)) {
((TextDoc*)Doc)->viewport()->setFocus();
((TextDoc*)Doc)->undo();
@ -499,7 +499,7 @@ void QucsApp::slotEditUndo()
// Is called, when "Undo"-Button is pressed.
void QucsApp::slotEditRedo()
{
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(isTextDocument(Doc)) {
((TextDoc*)Doc)->viewport()->setFocus();
((TextDoc*)Doc)->redo();
@ -519,7 +519,7 @@ void QucsApp::slotAlignTop()
{
slotHideEdit(); // disable text edit of component property
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(!Doc->aligning(0))
QMessageBox::information(this, tr("Info"),
tr("At least two elements must be selected !"));
@ -533,7 +533,7 @@ void QucsApp::slotAlignBottom()
{
slotHideEdit(); // disable text edit of component property
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(!Doc->aligning(1))
QMessageBox::information(this, tr("Info"),
tr("At least two elements must be selected !"));
@ -547,7 +547,7 @@ void QucsApp::slotAlignLeft()
{
slotHideEdit(); // disable text edit of component property
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(!Doc->aligning(2))
QMessageBox::information(this, tr("Info"),
tr("At least two elements must be selected !"));
@ -561,7 +561,7 @@ void QucsApp::slotAlignRight()
{
slotHideEdit(); // disable text edit of component property
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(!Doc->aligning(3))
QMessageBox::information(this, tr("Info"),
tr("At least two elements must be selected !"));
@ -575,7 +575,7 @@ void QucsApp::slotDistribHoriz()
{
slotHideEdit(); // disable text edit of component property
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
Doc->distributeHorizontal();
Doc->viewport()->update();
view->drawn = false;
@ -587,7 +587,7 @@ void QucsApp::slotDistribVert()
{
slotHideEdit(); // disable text edit of component property
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
Doc->distributeVertical();
Doc->viewport()->update();
view->drawn = false;
@ -599,7 +599,7 @@ void QucsApp::slotCenterHorizontal()
{
slotHideEdit(); // disable text edit of component property
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(!Doc->aligning(4))
QMessageBox::information(this, tr("Info"),
tr("At least two elements must be selected !"));
@ -613,7 +613,7 @@ void QucsApp::slotCenterVertical()
{
slotHideEdit(); // disable text edit of component property
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
if(!Doc->aligning(5))
QMessageBox::information(this, tr("Info"),
tr("At least two elements must be selected !"));
@ -627,7 +627,7 @@ void QucsApp::slotSelectAll()
{
slotHideEdit(); // disable text edit of component property
QWidget *Doc = DocumentTab->currentPage();
QWidget *Doc = DocumentTab->currentWidget();
if(isTextDocument(Doc)) {
((TextDoc*)Doc)->viewport()->setFocus();
//((TextDoc*)Doc)->selectAll(true);
@ -646,7 +646,7 @@ void QucsApp::slotSelectMarker()
{
slotHideEdit(); // disable text edit of component property
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
Doc->selectMarkers();
Doc->viewport()->update();
view->drawn = false;
@ -670,16 +670,16 @@ void QucsApp::editFile(const QString& File)
{
slotHideEdit(); // disable text edit of component property
statusBar()->message(tr("Opening file..."));
statusBar()->showMessage(tr("Opening file..."));
QFileInfo finfo(File);
if(!finfo.exists())
statusBar()->message(tr("Opening aborted, file not found."), 2000);
statusBar()->showMessage(tr("Opening aborted, file not found."), 2000);
else {
gotoPage(File);
lastDirOpenSave = File; // remember last directory and file
statusBar()->message(tr("Ready."));
statusBar()->showMessage(tr("Ready."));
}
}
}
@ -861,14 +861,14 @@ void QucsApp::slotGettingStarted()
// Is called when the find action is triggered.
void QucsApp::slotEditFind()
{
SearchDia->initSearch(DocumentTab->currentPage(),
((TextDoc *)DocumentTab->currentPage())->textCursor().selectedText(), false);
SearchDia->initSearch(DocumentTab->currentWidget(),
((TextDoc *)DocumentTab->currentWidget())->textCursor().selectedText(), false);
}
// --------------------------------------------------------------
void QucsApp::slotChangeProps()
{
QWidget *Doc = DocumentTab->currentPage();
QWidget *Doc = DocumentTab->currentWidget();
if(isTextDocument(Doc)) {
((TextDoc*)Doc)->viewport()->setFocus();
@ -899,7 +899,7 @@ void QucsApp::slotAddToProject()
lastDir.isEmpty() ? QString(".") : lastDir, QucsFileFilter);
if(List.isEmpty()) {
statusBar()->message(tr("No files copied."), 2000);
statusBar()->showMessage(tr("No files copied."), 2000);
return;
}
@ -910,7 +910,7 @@ void QucsApp::slotAddToProject()
QStringList FileList = List; // make a copy as recommended by Qt
QStringList::Iterator it = FileList.begin();
QFileInfo Info(*it);
lastDir = Info.dirPath(true); // remember last directory
lastDir = Info.absolutePath(); // remember last directory
// copy all files to project directory
int Num;
@ -918,7 +918,7 @@ void QucsApp::slotAddToProject()
while(it != FileList.end()) {
Info.setFile(*it);
origFile.setFileName(*it);
destFile.setFileName(QucsSettings.QucsWorkDir.absPath() +
destFile.setFileName(QucsSettings.QucsWorkDir.absolutePath() +
QDir::separator() + Info.fileName());
if(!origFile.open(QIODevice::ReadOnly)) {
@ -946,12 +946,12 @@ void QucsApp::slotAddToProject()
// copy data
do {
Num = origFile.readBlock(Buffer, 0x10000);
Num = origFile.read(Buffer, 0x10000);
if(Num < 0) {
QMessageBox::critical(this, tr("Error"), tr("Cannot read \"%1\" !").arg(*it));
break;
}
Num = destFile.writeBlock(Buffer, Num);
Num = destFile.write(Buffer, Num);
if(Num < 0) {
QMessageBox::critical(this, tr("Error"), tr("Cannot write \"%1\" !").arg(*it));
break;
@ -965,7 +965,7 @@ void QucsApp::slotAddToProject()
free(Buffer);
slotUpdateTreeview();
statusBar()->message(tr("Ready."));
statusBar()->showMessage(tr("Ready."));
}
// -----------------------------------------------------------
@ -978,18 +978,18 @@ void QucsApp::slotCursorLeft(bool left)
if(!editText->isHidden()) return; // for edit of component property ?
Q3PtrList<Element> movingElements;
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
int markerCount = Doc->copySelectedElements(&movingElements);
if((movingElements.count() - markerCount) < 1) {
if(markerCount > 0) { // only move marker if nothing else selected
Doc->markerLeftRight(left, &movingElements);
} else if(left) {
if(Doc->scrollLeft(Doc->horizontalScrollBar()->lineStep()))
Doc->scrollBy(-Doc->horizontalScrollBar()->lineStep(), 0);
if(Doc->scrollLeft(Doc->horizontalScrollBar()->singleStep()))
Doc->scrollBy(-Doc->horizontalScrollBar()->singleStep(), 0);
}else{ // right
if(Doc->scrollRight(-Doc->horizontalScrollBar()->lineStep()))
Doc->scrollBy(Doc->horizontalScrollBar()->lineStep(), 0);
if(Doc->scrollRight(-Doc->horizontalScrollBar()->singleStep()))
Doc->scrollBy(Doc->horizontalScrollBar()->singleStep(), 0);
}
Doc->viewport()->update();
@ -1014,10 +1014,10 @@ void QucsApp::slotCursorUp(bool up)
if(Begin < 0) return; // no selection list ?
int End = pp->Description.indexOf(editText->text(), Begin); // current
if(End < 0) return; // should never happen
End = pp->Description.findRev(',', End);
End = pp->Description.lastIndexOf(',', End);
if(End < Begin) return; // was first item ?
End--;
int Pos = pp->Description.findRev(',', End);
int Pos = pp->Description.lastIndexOf(',', End);
if(Pos < Begin) Pos = Begin; // is first item ?
Pos++;
if(pp->Description.at(Pos) == ' ') Pos++; // remove leading space
@ -1047,18 +1047,18 @@ void QucsApp::slotCursorUp(bool up)
}
Q3PtrList<Element> movingElements;
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
int markerCount = Doc->copySelectedElements(&movingElements);
if((movingElements.count() - markerCount) < 1) { // all selections are markers
if(markerCount > 0) { // only move marker if nothing else selected
Doc->markerUpDown(up, &movingElements);
} else if(up) { // nothing selected at all
if(Doc->scrollUp(Doc->verticalScrollBar()->lineStep()))
Doc->scrollBy(0, -Doc->verticalScrollBar()->lineStep());
if(Doc->scrollUp(Doc->verticalScrollBar()->singleStep()))
Doc->scrollBy(0, -Doc->verticalScrollBar()->singleStep());
} else { // down
if(Doc->scrollDown(-Doc->verticalScrollBar()->lineStep()))
Doc->scrollBy(0, Doc->verticalScrollBar()->lineStep());
if(Doc->scrollDown(-Doc->verticalScrollBar()->singleStep()))
Doc->scrollBy(0, Doc->verticalScrollBar()->singleStep());
}
Doc->viewport()->update();
@ -1079,8 +1079,8 @@ void QucsApp::slotApplyCompText()
{
QString s;
QFont f = QucsSettings.font;
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
f.setPointSizeFloat( Doc->Scale * float(f.pointSize()) );
Schematic *Doc = (Schematic*)DocumentTab->currentWidget();
f.setPointSizeF( Doc->Scale * float(f.pointSize()) );
editText->setFont(f);
Property *pp = 0;
@ -1176,10 +1176,13 @@ void QucsApp::slotApplyCompText()
z = editText->fontMetrics().lineSpacing();
view->MAy2 += n*z;
editText->setText(s);
editText->setPaletteBackgroundColor(QucsSettings.BGColor);
misc::setWidgetBackgroundColor(editText,QucsSettings.BGColor);
editText->setFocus();
editText->selectAll();
editText->reparent(Doc->viewport(), 0, QPoint(view->MAx2, view->MAy2), true);
editText->setParent(Doc->viewport());
editText->move(QPoint(view->MAx2, view->MAy2));
editText->show();
//editText->reparent(Doc->viewport(), 0, QPoint(view->MAx2, view->MAy2), true);
}
// -----------------------------------------------------------
@ -1247,8 +1250,8 @@ void QucsApp::slotExportGraphAsCsv()
return;
QFileInfo Info(s);
lastDir = Info.dirPath(true); // remember last directory
if(Info.extension().isEmpty())
lastDir = Info.absolutePath(); // remember last directory
if(Info.suffix().isEmpty())
s += ".csv";
QFile File(s);
@ -1418,7 +1421,7 @@ void QucsApp::slotLoadModule()
// pick up new category 'verilog-a user components' from `Module::category`
//set new category into view
QucsApp::fillComboBox(true);
CompChoose->setCurrentItem(CompChoose->count()-1);
CompChoose->setCurrentIndex(CompChoose->count()-1);
slotSetCompView(CompChoose->count()-1);
// icons of dynamically registered components ready to be dragged
@ -1427,7 +1430,7 @@ void QucsApp::slotLoadModule()
// remove any previously registerd icons from the listview
int foundCat = CompChoose->findText(QObject::tr("verilog-a user devices"));
if (foundCat != -1) {
CompChoose->setCurrentItem(foundCat);
CompChoose->setCurrentIndex(foundCat);
CompComps->clear();
}
}

63
qucs/qucs_init.cpp
View File

@ -20,6 +20,7 @@
#endif
#include "main.h"
#include "misc.h"
#include "qucs.h"
#include "octave_window.h"
@ -687,36 +688,36 @@ void QucsApp::initMenuBar()
for (int i = 0; i < MaxRecentFiles; ++i) {
recentFilesMenu->addAction(fileRecentAction[i]);
}
recentFilesMenu->insertSeparator();
recentFilesMenu->addSeparator();
recentFilesMenu->addAction(fileClearRecent);
fileMenu->insertSeparator();
fileMenu->addSeparator();
fileMenu->addAction(fileSave);
fileMenu->addAction(fileSaveAll);
fileMenu->addAction(fileSaveAs);
fileMenu->addAction(exportAsImage);
fileMenu->addAction(filePrint);
fileMenu->addAction(filePrintFit);
fileMenu->insertSeparator();
fileMenu->addSeparator();
fileMenu->addAction(fileExamples);
fileMenu->insertSeparator();
fileMenu->addSeparator();
fileMenu->addAction(fileSettings);
fileMenu->addAction(symEdit);
fileMenu->insertSeparator();
fileMenu->addSeparator();
fileMenu->addAction(applSettings);
fileMenu->addAction(refreshSchPath);
fileMenu->insertSeparator();
fileMenu->addSeparator();
fileMenu->addAction(fileQuit);
editMenu = new QMenu(tr("&Edit")); // menuBar entry editMenu
editMenu->addAction(undo);
editMenu->addAction(redo);
editMenu->insertSeparator();
editMenu->addSeparator();
editMenu->addAction(editCut);
editMenu->addAction(editCopy);
editMenu->addAction(editPaste);
editMenu->addAction(editDelete);
editMenu->insertSeparator();
editMenu->addSeparator();
editMenu->addAction(select);
editMenu->addAction(selectAll);
editMenu->addAction(selectMarker);
@ -726,7 +727,7 @@ void QucsApp::initMenuBar()
editMenu->addAction(editMirror);
editMenu->addAction(editMirrorY);
editMenu->addAction(editActivate);
editMenu->insertSeparator();
editMenu->addSeparator();
editMenu->addAction(intoH);
editMenu->addAction(popH);
@ -735,15 +736,15 @@ void QucsApp::initMenuBar()
alignMenu = new QMenu(tr("P&ositioning")); // menuBar entry alignMenu
alignMenu->addAction(moveText);
alignMenu->addAction(onGrid);
alignMenu->insertSeparator();
alignMenu->addSeparator();
alignMenu->addAction(centerHor);
alignMenu->addAction(centerVert);
alignMenu->insertSeparator();
alignMenu->addSeparator();
alignMenu->addAction(alignTop);
alignMenu->addAction(alignBottom);
alignMenu->addAction(alignLeft);
alignMenu->addAction(alignRight);
alignMenu->insertSeparator();
alignMenu->addSeparator();
alignMenu->addAction(distrHor);
alignMenu->addAction(distrVert);
@ -765,17 +766,17 @@ void QucsApp::initMenuBar()
projMenu->addAction(addToProj);
projMenu->addAction(projClose);
projMenu->addAction(projDel);
projMenu->insertSeparator();
projMenu->addSeparator();
projMenu->addAction(createLib);
projMenu->addAction(createPkg);
projMenu->addAction(extractPkg);
projMenu->insertSeparator();
projMenu->addSeparator();
projMenu->addAction(importData);
projMenu->addAction(graph2csv);
// TODO only enable if document is VA file
if (QucsSettings.DefaultSimulator == spicecompat::simQucsator) {
// There is no VA-modules builder available for Ngspice etc.
projMenu->insertSeparator();
projMenu->addSeparator();
projMenu->addAction(buildModule);
projMenu->addAction(loadModule);
}
@ -790,7 +791,7 @@ void QucsApp::initMenuBar()
toolMenu->addAction(callMatch);
toolMenu->addAction(callAtt);
toolMenu->addAction(callRes);
toolMenu->insertSeparator();
toolMenu->addSeparator();
cmMenu = new QMenu(tr("Compact modelling"));
cmMenu->addAction(buildVAModule);
@ -813,8 +814,8 @@ void QucsApp::initMenuBar()
viewMenu->addAction(magOne);
viewMenu->addAction(magPlus);
viewMenu->addAction(magMinus);
viewMenu->insertSeparator();
viewMenu->setCheckable(true);
viewMenu->addSeparator();
//viewMenu->setCheckable(true);
viewMenu->addAction(viewToolBar);
viewMenu->addAction(viewStatusBar);
viewMenu->addAction(viewBrowseDock);
@ -825,7 +826,7 @@ void QucsApp::initMenuBar()
helpMenu->addAction(helpIndex);
helpMenu->addAction(helpQucsIndex);
helpMenu->addAction(helpGetStart);
helpMenu->insertSeparator();
helpMenu->addSeparator();
@ -843,7 +844,7 @@ void QucsApp::initMenuBar()
QAction* helpTechnicalActions = new QAction(entries[i], this);
helpTechnicalActions->setObjectName ( entries[i] );
helpTechnicalActions->setStatusTip(tr("Open ")+entries[i]);
helpTechnicalActions->setWhatsThis(tr(entries[i]+"\n\nOpen "+entries[i]));
helpTechnicalActions->setWhatsThis(entries[i]+tr("\n\nOpen ")+entries[i]);
connect(helpTechnicalActions, SIGNAL(triggered()), SLOT(slotHelpTechnical()));
helpTechnical->addAction(helpTechnicalActions);
}
@ -863,7 +864,7 @@ void QucsApp::initMenuBar()
QAction* helpReportActions = new QAction(entries[i], this);
helpReportActions->setObjectName ( entries[i] );
helpReportActions->setStatusTip(tr("Open ")+entries[i]);
helpReportActions->setWhatsThis(tr(entries[i]+"\n\nOpen "+entries[i]));
helpReportActions->setWhatsThis(entries[i]+tr("\n\nOpen ")+entries[i]);
connect(helpReportActions, SIGNAL(triggered()), SLOT(slotHelpReport()));
helpReport->addAction(helpReportActions);
}
@ -882,14 +883,14 @@ void QucsApp::initMenuBar()
QAction* helpTutorialActions = new QAction(entries[i], this);
helpTutorialActions->setObjectName ( entries[i] );
helpTutorialActions->setStatusTip(tr("Open ")+entries[i]);
helpTutorialActions->setWhatsThis(tr(entries[i]+"\n\nOpen "+entries[i]));
helpTutorialActions->setWhatsThis(entries[i]+tr("\n\nOpen ")+entries[i]);
connect(helpTutorialActions, SIGNAL(triggered()), SLOT(slotHelpTutorial()));
helpTutorial->addAction(helpTutorialActions);
}
}
helpMenu->insertSeparator();
helpMenu->addSeparator();
helpMenu->addAction(helpAboutApp);
helpMenu->addAction(helpAboutQt);
@ -902,7 +903,7 @@ void QucsApp::initMenuBar()
menuBar()->addMenu(toolMenu);
menuBar()->addMenu(simMenu);
menuBar()->addMenu(viewMenu);
menuBar()->insertSeparator();
menuBar()->addSeparator();
menuBar()->addMenu(helpMenu);
}
@ -967,16 +968,16 @@ void QucsApp::initStatusBar()
{
// To reserve enough space, insert the longest text and rewrite it afterwards.
SimulatorLabel = new QLabel(spicecompat::getDefaultSimulatorName());
statusBar()->addWidget(SimulatorLabel, 0, true);
statusBar()->addPermanentWidget(SimulatorLabel, 0);
WarningLabel = new QLabel(tr("no warnings"), statusBar());
statusBar()->addWidget(WarningLabel, 0, true);
statusBar()->addPermanentWidget(WarningLabel, 0);
PositionLabel = new QLabel("0 : 0", statusBar());
PositionLabel->setAlignment(Qt::AlignRight);
statusBar()->addWidget(PositionLabel, 0, true);
statusBar()->addPermanentWidget(PositionLabel, 0);
statusBar()->message(tr("Ready."), 2000);
statusBar()->showMessage(tr("Ready."), 2000);
}
// ----------------------------------------------------------
@ -993,9 +994,9 @@ void QucsApp::slotShowWarnings()
ResultState++;
if(ResultState & 1)
WarningLabel->setPaletteForegroundColor(Qt::red);
misc::setWidgetForegroundColor(WarningLabel,Qt::red);
else
WarningLabel->setPaletteForegroundColor(Qt::black);
misc::setWidgetForegroundColor(WarningLabel,Qt::black);
if(ResultState < 9)
QTimer::singleShot(500, this, SLOT(slotShowWarnings()));
@ -1009,7 +1010,7 @@ void QucsApp::slotResetWarnings()
QFont f = WarningLabel->font(); // reset warning label
f.setWeight(QFont::Normal);
WarningLabel->setFont(f);
WarningLabel->setPaletteForegroundColor(Qt::black);
misc::setWidgetForegroundColor(WarningLabel,Qt::black);
WarningLabel->setText(tr("no warnings"));
}

10
qucs/qucsdoc.cpp
View File

@ -29,9 +29,9 @@ QucsDoc::QucsDoc(QucsApp *App_, const QString& Name_)
DocName = Name_;
QFileInfo Info(DocName);
if(!DocName.isEmpty()) {
DocName = Info.absFilePath();
QString base = Info.baseName(true);
QString ext = Info.extension(false);
DocName = Info.absoluteFilePath();
QString base = Info.baseName();
QString ext = Info.suffix();
if(ext == "m" || ext == "oct")
SimTime = "1";
@ -55,7 +55,7 @@ QucsDoc::QucsDoc(QucsApp *App_, const QString& Name_)
QString QucsDoc::fileSuffix (const QString& Name) {
QFileInfo Info (Name);
return Info.extension (false);
return Info.suffix();
}
QString QucsDoc::fileSuffix (void) {
@ -64,7 +64,7 @@ QString QucsDoc::fileSuffix (void) {
QString QucsDoc::fileBase (const QString& Name) {
QFileInfo Info (Name);
return Info.baseName (true);
return Info.baseName ();
}
QString QucsDoc::fileBase (void) {

21
qucs/schematic.cpp
View File

@ -24,7 +24,7 @@
#include <QDir>
#include <QTextStream>
#include <QDragLeaveEvent>
#include <Q3PtrList>
#include <qt3_compat/qt_compat.h>
#include <QPixmap>
#include <QDragEnterEvent>
#include <QDragMoveEvent>
@ -54,6 +54,8 @@
#include "components/verilogfile.h"
#include "components/vafile.h"
#include "misc.h"
// just dummies for empty lists
Q3PtrList<Wire> SymbolWires;
Q3PtrList<Node> SymbolNodes;
@ -66,6 +68,12 @@ Schematic::Schematic(QucsApp *App_, const QString& Name_)
{
symbolMode = false;
Components = new Q3PtrList<Component>;
Diagrams = new Q3PtrList<Diagram>;
Wires = new Q3PtrList<Wire>;
Nodes = new Q3PtrList<Node>;
Paintings = new Q3PtrList<Painting>;
// ...........................................................
GridX = GridY = 10;
ViewX1=ViewY1=0;
@ -102,7 +110,7 @@ Schematic::Schematic(QucsApp *App_, const QString& Name_)
setVScrollBarMode(Q3ScrollView::AlwaysOn);
setHScrollBarMode(Q3ScrollView::AlwaysOn);
viewport()->setPaletteBackgroundColor(QucsSettings.BGColor);
misc::setWidgetBackgroundColor(viewport(),QucsSettings.BGColor);
viewport()->setMouseTracking(true);
viewport()->setAcceptDrops(true); // enable drag'n drop
@ -2078,7 +2086,7 @@ void Schematic::contentsDropEvent(QDropEvent *Event)
// URI: file:/home/linuxuser/Desktop/example.sch
foreach(QUrl url, urls) {
App->gotoPage(QDir::convertSeparators(url.toLocalFile()));
App->gotoPage(QDir::toNativeSeparators(url.toLocalFile()));
}
d->DocChanged = changed;
@ -2130,10 +2138,11 @@ void Schematic::contentsDragEnterEvent(QDragEnterEvent *Event)
}
if(Event->format(1) == 0) { // only one MIME type ?
// if(Event->format(1) == 0) { // only one MIME type ?
// drag component from listview
if(Event->provides("application/x-qabstractitemmodeldatalist")) {
//if(Event->provides("application/x-qabstractitemmodeldatalist")) {
if (Event->mimeData()->hasFormat("application/x-qabstractitemmodeldatalist")) {
QListWidgetItem *Item = App->CompComps->currentItem();
if(Item) {
formerAction = App->activeAction;
@ -2145,7 +2154,7 @@ void Schematic::contentsDragEnterEvent(QDragEnterEvent *Event)
return;
}
}
}
// }
Event->ignore();
}

2
qucs/schematic_element.cpp
View File

@ -18,7 +18,7 @@
#include <limits.h>
#include "schematic.h"
#include <Q3PtrList>
#include <qt3_compat/qt_compat.h>
#include <QDebug>

37
qucs/schematic_file.cpp
View File

@ -24,7 +24,7 @@
#include <QDir>
#include <QStringList>
#include <QPlainTextEdit>
#include <Q3PtrList>
#include <qt3_compat/q3ptrlist.h>
#include <QTextStream>
#include <QList>
#include <QProcess>
@ -188,7 +188,7 @@ bool Schematic::pasteFromClipboard(QTextStream *stream, Q3PtrList<Element> *pe)
int Schematic::saveSymbolCpp (void)
{
QFileInfo info (DocName);
QString cppfile = info.dirPath () + QDir::separator() + DataSet;
QString cppfile = info.absolutePath () + QDir::separator() + DataSet;
QFile file (cppfile);
if (!file.open (QIODevice::WriteOnly)) {
@ -256,7 +256,7 @@ int Schematic::saveSymbolCpp (void)
int Schematic::saveSymbolJSON()
{
QFileInfo info (DocName);
QString jsonfile = info.dirPath () + QDir::separator()
QString jsonfile = info.absolutePath () + QDir::separator()
+ info.baseName() + "_sym.json";
qDebug() << "saveSymbolJson for " << jsonfile;
@ -453,7 +453,7 @@ int Schematic::saveDocument()
QStringList Arguments;
Arguments << QDir::toNativeSeparators(vaFile)
<< "-I" << QDir::toNativeSeparators(include.absolutePath())
<< "-e" << QDir::toNativeSeparators(include.absFilePath("qucsMODULEguiJSONsymbol.xml"))
<< "-e" << QDir::toNativeSeparators(include.absoluteFilePath("qucsMODULEguiJSONsymbol.xml"))
<< "-A" << "dyload";
// QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
@ -873,9 +873,9 @@ bool Schematic::loadDocument()
QMessageBox::StandardButton result;
result = QMessageBox::warning(0,
QObject::tr("Warning"),
QObject::tr("Wrong document version \n" +
DocName + "\n"
"Try to open it anyway?"),
QObject::tr("Wrong document version \n") +
DocName + "\n" +
QObject::tr("Try to open it anyway?"),
QMessageBox::Yes|QMessageBox::No);
if (result==QMessageBox::No) {
@ -1085,7 +1085,7 @@ int Schematic::testFile(const QString& DocName)
// To strongly speed up the file read operation the whole file is
// read into the memory in one piece.
QTextStream ReadWhole(&file);
QString FileString = ReadWhole.read();
QString FileString = ReadWhole.readAll();
file.close();
QTextStream stream(&FileString, QIODevice::ReadOnly);
@ -1147,7 +1147,7 @@ void Schematic::collectDigitalSignals(void)
if(it == Signals.end()) { // avoid redeclaration of signal
Signals.insert(pn->Name, DigSignal(pn->Name, pn->DType));
} else if (!pn->DType.isEmpty()) {
it.data().Type = pn->DType;
it.value().Type = pn->DType;
}
}
}
@ -1248,13 +1248,13 @@ bool Schematic::throughAllComps(QTextStream *stream, int& countInit,
SubMap::Iterator it = FileList.find(f);
if(it != FileList.end())
{
if (!it.data().PortTypes.isEmpty())
if (!it.value().PortTypes.isEmpty())
{
i = 0;
// apply in/out signal types of subcircuit
foreach(Port *pp, pc->Ports)
{
pp->Type = it.data().PortTypes[i];
pp->Type = it.value().PortTypes[i];
pp->Connection->DType = pp->Type;
i++;
}
@ -1298,7 +1298,8 @@ bool Schematic::throughAllComps(QTextStream *stream, int& countInit,
i++;
}
sub.PortTypes = d->PortTypes;
FileList.replace(f, sub);
FileList.insert(f,sub);
//FileList.replace(f, sub);
}
delete d;
if(!r)
@ -1519,7 +1520,7 @@ void Schematic::createSubNetlistPlain(QTextStream *stream, QPlainTextEdit *ErrTe
if(creatingLib) {
QString f = misc::properAbsFileName(DocName) + ".lst";
ofile.setFileName(f);
if(!ofile.open(IO_WriteOnly)) {
if(!ofile.open(QIODevice::WriteOnly)) {
ErrText->appendPlainText(tr("ERROR: Cannot create library file \"%s\".").arg(f));
return;
}
@ -1551,13 +1552,13 @@ void Schematic::createSubNetlistPlain(QTextStream *stream, QPlainTextEdit *ErrTe
(*it_name) = pc->Ports.first()->Connection->Name;
DigMap::Iterator it = Signals.find(*it_name);
if(it!=Signals.end())
(*it_type) = it.data().Type;
(*it_type) = it.value().Type;
// propagate type to port symbol
pc->Ports.first()->Connection->DType = *it_type;
if(!isAnalog) {
if (isVerilog) {
Signals.erase(*it_name); // remove node name
Signals.remove(*it_name); // remove node name
switch(pc->Props.at(1)->Value.at(0).toLatin1()) {
case 'a':
InOutPorts.append(*it_name);
@ -1571,7 +1572,7 @@ void Schematic::createSubNetlistPlain(QTextStream *stream, QPlainTextEdit *ErrTe
}
else {
// remove node name of output port
Signals.erase(*it_name);
Signals.remove(*it_name);
switch(pc->Props.at(1)->Value.at(0).toLatin1()) {
case 'a':
(*it_name) += " : inout"; // attribute "analog" is "inout"
@ -1595,8 +1596,8 @@ void Schematic::createSubNetlistPlain(QTextStream *stream, QPlainTextEdit *ErrTe
it_type = SubcircuitPortTypes.begin();
it_name != SubcircuitPortNames.end(); ) {
if(*it_name == " ") {
it_name = SubcircuitPortNames.remove(it_name);
it_type = SubcircuitPortTypes.remove(it_type);
it_name = SubcircuitPortNames.erase(it_name);
it_type = SubcircuitPortTypes.erase(it_type);
} else {
PortTypes.append(*it_type);
it_name++;

27
qucs/textdoc.cpp
View File

@ -22,6 +22,7 @@ Copyright (C) 2014 by Guilherme Brondani Torri <guitorri@gmail.com>
#include <QMessageBox>
#include "main.h"
#include "misc.h"
#include "qucs.h"
#include "textdoc.h"
#include "syntax.h"
@ -60,7 +61,7 @@ TextDoc::TextDoc(QucsApp *App_, const QString& Name_) : QPlainTextEdit(), QucsDo
viewport()->setFocus();
setWordWrapMode(QTextOption::NoWrap);
viewport()->setPaletteBackgroundColor(QucsSettings.BGColor);
misc::setWidgetBackgroundColor(viewport(),QucsSettings.BGColor);
connect(this, SIGNAL(textChanged()), SLOT(slotSetChanged()));
connect(this, SIGNAL(cursorPositionChanged()),
SLOT(slotCursorPosChanged()));
@ -99,7 +100,7 @@ TextDoc::~TextDoc()
void TextDoc::setLanguage (const QString& FileName)
{
QFileInfo Info (FileName);
QString ext = Info.extension (false);
QString ext = Info.suffix();
if (ext == "vhd" || ext == "vhdl")
setLanguage (LANG_VHDL);
else if (ext == "v")
@ -205,9 +206,9 @@ void TextDoc::setName (const QString& Name_)
QFileInfo Info (DocName);
DataSet = Info.baseName (true) + ".dat";
DataDisplay = Info.baseName (true) + ".dpl";
if(Info.extension(false) == "m" || Info.extension(false) == "oct")
DataSet = Info.baseName () + ".dat";
DataDisplay = Info.baseName () + ".dpl";
if(Info.suffix() == "m" || Info.suffix() == "oct")
SimTime = "1";
}
@ -225,26 +226,26 @@ void TextDoc::becomeCurrent (bool)
emit signalRedoState(document()->isRedoAvailable());
// update appropriate menu entries
App->symEdit->setMenuText (tr("Edit Text Symbol"));
App->symEdit->setText (tr("Edit Text Symbol"));
App->symEdit->setStatusTip (tr("Edits the symbol for this text document"));
App->symEdit->setWhatsThis (
tr("Edit Text Symbol\n\nEdits the symbol for this text document"));
if (language == LANG_VHDL) {
App->insEntity->setMenuText (tr("VHDL entity"));
App->insEntity->setText (tr("VHDL entity"));
App->insEntity->setStatusTip (tr("Inserts skeleton of VHDL entity"));
App->insEntity->setWhatsThis (
tr("VHDL entity\n\nInserts the skeleton of a VHDL entity"));
}
else if (language == LANG_VERILOG || language == LANG_VERILOGA) {
App->insEntity->setMenuText (tr("Verilog module"));
App->insEntity->setText (tr("Verilog module"));
App->insEntity->setStatusTip (tr("Inserts skeleton of Verilog module"));
App->insEntity->setWhatsThis (
tr("Verilog module\n\nInserts the skeleton of a Verilog module"));
App->buildModule->setEnabled(true);
}
else if (language == LANG_OCTAVE) {
App->insEntity->setMenuText (tr("Octave function"));
App->insEntity->setText (tr("Octave function"));
App->insEntity->setStatusTip (tr("Inserts skeleton of Octave function"));
App->insEntity->setWhatsThis (
tr("Octave function\n\nInserts the skeleton of a Octave function"));
@ -255,7 +256,7 @@ void TextDoc::becomeCurrent (bool)
bool TextDoc::baseSearch(const QString &str, bool CaseSensitive, bool wordOnly, bool backward)
{
QFlag flag = 0;
QTextDocument::FindFlags flag = 0;
bool finded;
if (CaseSensitive) {
@ -356,7 +357,7 @@ QMenu *TextDoc::createStandardContextMenu()
QMenu *popup = QPlainTextEdit::createStandardContextMenu();
if (language != LANG_OCTAVE) {
App->fileSettings->addTo((QWidget *)popup);
((QWidget *) popup)->addAction(App->fileSettings);
}
return popup;
}
@ -373,7 +374,7 @@ bool TextDoc::load ()
setLanguage (DocName);
QTextStream stream (&file);
insertPlainText(stream.read ());
insertPlainText(stream.readAll());
document()->setModified(false);
slotSetChanged ();
file.close ();
@ -560,7 +561,7 @@ QString TextDoc::getModuleName (void)
case LANG_OCTAVE:
{
QFileInfo Info (DocName);
return Info.baseName (true);
return Info.baseName ();
}
default:
return "";