static void resolveLibrary()
{
QLibrary lib;
#ifdef LIBRESOLV_SO
lib.setFileName(QStringLiteral(LIBRESOLV_SO));
if (!lib.load())
#endif
{
lib.setFileName(QLatin1String("resolv"));
if (!lib.load())
return;
}
local_dn_expand = dn_expand_proto(lib.resolve("__dn_expand"));
if (!local_dn_expand)
local_dn_expand = dn_expand_proto(lib.resolve("dn_expand"));
local_res_nclose = res_nclose_proto(lib.resolve("__res_nclose"));
if (!local_res_nclose)
local_res_nclose = res_nclose_proto(lib.resolve("res_9_nclose"));
if (!local_res_nclose)
local_res_nclose = res_nclose_proto(lib.resolve("res_nclose"));
local_res_ninit = res_ninit_proto(lib.resolve("__res_ninit"));
if (!local_res_ninit)
local_res_ninit = res_ninit_proto(lib.resolve("res_9_ninit"));
if (!local_res_ninit)
local_res_ninit = res_ninit_proto(lib.resolve("res_ninit"));
local_res_nquery = res_nquery_proto(lib.resolve("__res_nquery"));
if (!local_res_nquery)
local_res_nquery = res_nquery_proto(lib.resolve("res_9_nquery"));
if (!local_res_nquery)
local_res_nquery = res_nquery_proto(lib.resolve("res_nquery"));
}
bool load(const char* dllname)
{
if (library(dllname)) {
DBG("'%s' is already loaded\n", dllname);
return true;
}
std::list<std::string> libnames = sLibNamesMap[dllname];
if (libnames.empty())
libnames.push_back(dllname);
std::list<std::string>::const_iterator it;
QLibrary *dll = new QLibrary();
for (it = libnames.begin(); it != libnames.end(); ++it) {
dll->setFileName((*it).c_str());
if (dll->load())
break;
DBG("%s\n", dll->errorString().toLocal8Bit().constData()); //why qDebug use toUtf8() and printf use toLocal8Bit()?
}
if (it == libnames.end()) {
DBG("No dll loaded\n");
delete dll;
return false;
}
DBG("'%s' is loaded~~~\n", dll->fileName().toUtf8().constData());
sDllMap[dllname] = dll; //map.insert will not replace the old one
return true;
}
Garmin::IDevice * CDeviceGarmin::getDevice()
{
Garmin::IDevice * (*func)(const char*) = 0;
Garmin::IDevice * dev = 0;
#if defined(Q_OS_MAC)
// MacOS X: plug-ins are stored in the bundle folder
QString libname = QString("%1/lib%2" XSTR(SHARED_LIB_EXT))
.arg(QCoreApplication::applicationDirPath().replace(QRegExp("MacOS$"), "Resources/Drivers"))
.arg(devkey);
#else
QString libname = QString("%1/lib%2" XSTR(SHARED_LIB_EXT)).arg(XSTR(PLUGINDIR)).arg(devkey);
#endif
QString funcname = QString("init%1").arg(devkey);
QLibrary lib;
lib.setFileName(libname);
bool lib_loaded = lib.load();
if (lib_loaded)
{
func = (Garmin::IDevice * (*)(const char*))lib.resolve(funcname.toLatin1());
}
if(!lib_loaded || func == 0)
{
QMessageBox warn;
warn.setIcon(QMessageBox::Warning);
warn.setWindowTitle(tr("Error ..."));
warn.setText(tr("Failed to load driver."));
warn.setDetailedText(lib.errorString());
warn.setStandardButtons(QMessageBox::Ok);
warn.exec();
return 0;
}
dev = func(INTERFACE_VERSION);
if(dev == 0)
{
QMessageBox warn;
warn.setIcon(QMessageBox::Warning);
warn.setWindowTitle(tr("Error ..."));
warn.setText(tr("Driver version mismatch."));
QString detail = QString(
tr("The version of your driver plugin \"%1\" does not match the version QLandkarteGT expects (\"%2\").")
).arg(libname).arg(INTERFACE_VERSION);
warn.setDetailedText(detail);
warn.setStandardButtons(QMessageBox::Ok);
warn.exec();
func = 0;
}
if(dev)
{
dev->setPort(port.toLatin1());
dev->setGuiCallback(GUICallback,this);
}
return dev;
}
PlazaClient::PlazaClient(QWidget *parent)
:QWidget(parent)
,ui(new Ui::wgtPlazaMainUI)
,m_process(NULL)
{
ui->setupUi(this);
connect(ui->btnStartGame,SIGNAL(clicked()),this,SLOT(sltStartGame()));
connect(ui->btnSendData,SIGNAL(clicked()),this,SLOT(sltSendData()));
connect(ui->btnCloseGame,SIGNAL(clicked()),this,SLOT(sltGameClosed()));
connect(qApp,SIGNAL(aboutToQuit()),this,SLOT());
QLibrary *libChannelModule = new QLibrary(this);
#if defined(Q_OS_WIN)
#if defined(QT_DEBUG)
libChannelModule->setFileName("H:/MyProjects/QtBasis/IPCTest/build-Debug/ChannelModule/debug/ChannelModule.dll");
#elif defined(QT_RELEASE)
libChannelModule->setFileName("H:/MyProjects/QtBasis/IPCTest/build-Release/ChannelModule/release/ChannelModule.dll");
#endif
#elif defined(Q_OS_LINUX)
#if defined(QT_DEBUG)
libChannelModule->setFileName("H:/MyProjects/QtBasis/IPCTest/build-Debug/ChannelModule/debug/ChannelModule.dll");
#elif defined(QT_RELEASE)
libChannelModule->setFileName("H:/MyProjects/QtBasis/IPCTest/build-Release/ChannelModule/release/ChannelModule.dll");
#endif
#endif
if(!libChannelModule->load())
{
qDebug() << "PlazaUI initial failed:ChannelModule load failed.ErrorString:" << libChannelModule->errorString() << endl;
}
else
{
pCreate f = (pCreate)libChannelModule->resolve("create");
if(f)
{
m_pChannelModule = f();
}
else
{
qDebug() << Utility::instance()->strErrorPosition(QString::fromUtf8(__FILE__), QString::fromUtf8(__FUNCTION__), __LINE__) << libChannelModule->errorString() << endl;
}
}
}
//----------------------------------------------------------------------------
void ctkPluginFrameworkContext::init()
{
log() << "initializing";
if (firstInit && ctkPluginConstants::FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT
== props[ctkPluginConstants::FRAMEWORK_STORAGE_CLEAN])
{
deleteFWDir();
firstInit = false;
}
// Pre-load libraries
// This may speed up installing new plug-ins if they have dependencies on
// one of these libraries. It prevents repeated loading and unloading of the
// pre-loaded libraries during caching of the plug-in meta-data.
if (props[ctkPluginConstants::FRAMEWORK_PRELOAD_LIBRARIES].isValid())
{
QStringList preloadLibs = props[ctkPluginConstants::FRAMEWORK_PRELOAD_LIBRARIES].toStringList();
QLibrary::LoadHints loadHints;
QVariant loadHintsVariant = props[ctkPluginConstants::FRAMEWORK_PLUGIN_LOAD_HINTS];
if (loadHintsVariant.isValid())
{
loadHints = loadHintsVariant.value<QLibrary::LoadHints>();
}
foreach(QString preloadLib, preloadLibs)
{
QLibrary lib;
QStringList nameAndVersion = preloadLib.split(":");
QString libraryName;
if (nameAndVersion.count() == 1)
{
libraryName = nameAndVersion.front();
lib.setFileName(nameAndVersion.front());
}
else if (nameAndVersion.count() == 2)
{
libraryName = nameAndVersion.front() + "." + nameAndVersion.back();
lib.setFileNameAndVersion(nameAndVersion.front(), nameAndVersion.back());
}
else
{
qWarning() << "Wrong syntax in" << preloadLib << ". Use <lib-name>[:version]. Skipping.";
continue;
}
lib.setLoadHints(loadHints);
log() << "Pre-loading library" << lib.fileName() << "with hints [" << static_cast<int>(loadHints) << "]";
if (!lib.load())
{
qWarning() << "Pre-loading library" << lib.fileName() << "failed:" << lib.errorString() << "\nCheck your library search paths.";
}
}
static bool resolveLibraryInternal()
{
#if QT_CONFIG(library) && !defined(Q_OS_QNX)
QLibrary lib;
#ifdef LIBRESOLV_SO
lib.setFileName(QStringLiteral(LIBRESOLV_SO));
if (!lib.load())
#endif
{
lib.setFileName(QLatin1String("resolv"));
if (!lib.load())
return false;
}
local_res_init = res_init_proto(lib.resolve("__res_init"));
if (!local_res_init)
local_res_init = res_init_proto(lib.resolve("res_init"));
local_res_ninit = res_ninit_proto(lib.resolve("__res_ninit"));
if (!local_res_ninit)
local_res_ninit = res_ninit_proto(lib.resolve("res_ninit"));
if (!local_res_ninit) {
// if we can't get a thread-safe context, we have to use the global _res state
local_res = res_state_ptr(lib.resolve("_res"));
} else {
local_res_nclose = res_nclose_proto(lib.resolve("res_nclose"));
if (!local_res_nclose)
local_res_nclose = res_nclose_proto(lib.resolve("__res_nclose"));
if (!local_res_nclose)
local_res_ninit = 0;
}
#endif
return true;
}
void SupportLibraryLoader::loadLibraries() const{
std::map<quint32, QString> order;
QLibrary lib;
bool ok = order.size() > 0;
for(auto name : _order){
QFileInfo file;
if (QFileInfo(name.second).exists()) {
file = QFileInfo(name.second);
} else {
file = QFileInfo(_configLocation.absolutePath() + "/../" + name.second);
}
QString path = file.canonicalFilePath();
lib.setFileName(path);
ok = lib.load();
if ( !ok){
kernel()->issues()->log(TR("Could not load library ") + path + ",error :" + lib.errorString());
}
}
}
void SupportLibraryLoader::loadLibraries() const{
std::map<quint32, QString> order;
QLibrary lib;
bool ok = order.size() > 0;
for(auto name : _order){
QFileInfo file;
if (QFileInfo(name.second).exists()) {
file = QFileInfo(name.second);
} else {
file = QFileInfo(_configLocation.absolutePath() + "/../" + name.second);
}
QString path = file.canonicalFilePath();
lib.setFileName(path);
ok = lib.load();
if ( !ok){
ERROR2(ERR_COULD_NOT_LOAD_2, TR("name"), "connector");
}
}
}
void tst_QLibrary::errorString()
{
QFETCH(int, operation);
QFETCH(QString, fileName);
QFETCH(bool, success);
QFETCH(QString, errorString);
QLibrary lib;
if (!(operation & DontSetFileName)) {
lib.setFileName(fileName);
}
bool ok = false;
switch (operation & OperationMask) {
case Load:
ok = lib.load();
break;
case Unload:
ok = lib.load(); //###
ok = lib.unload();
break;
case Resolve: {
ok = lib.load();
QCOMPARE(ok, true);
if (success) {
ok = lib.resolve("mylibversion");
} else {
ok = lib.resolve("nosuchsymbol");
}
break;}
default:
QFAIL(qPrintable(QString("Unknown operation: %1").arg(operation)));
break;
}
QRegExp re(errorString);
QString libErrorString = lib.errorString();
QVERIFY(!lib.isLoaded() || lib.unload());
QVERIFY2(re.exactMatch(libErrorString), qPrintable(libErrorString));
QCOMPARE(ok, success);
}
void tst_QLibrary::loadHints()
{
QFETCH( QString, lib );
QFETCH( int, loadHints);
QFETCH( bool, result );
//QLibrary library( lib );
QLibrary library;
QLibrary::LoadHints lh(loadHints);
if (int(loadHints) != 0) {
lh |= library.loadHints();
library.setLoadHints(lh);
}
library.setFileName(lib);
QCOMPARE(library.loadHints(), lh);
bool ok = library.load();
if ( result ) {
QVERIFY( ok );
QVERIFY(library.unload());
} else {
QVERIFY( !ok );
}
}
void Init( bool b, int rate2, int bits2, int chn2, int /*buff*/ )
{
mustReset = false;
if ( !b )
{
Save.odczytajopcje();
fs.Init();
fs.ApplyB();
}
PlErr = false;
if ( b )
{
if ( !isOpen )
{
if ( !pa_lib.isLoaded() )
{
QString libName = "libpulse-simple" + libExt;
#ifdef Q_WS_X11
libName += ".0";
#endif
pa_lib.setFileName( libName );
if ( !pa_lib.load() )
{
errStr = pa_lib.errorString();
PlErr = true;
return;
}
qmplay_pa_simple_new = ( _qmplay_pa_simple_new )pa_lib.resolve( "pa_simple_new" );
qmplay_pa_simple_free = ( _qmplay_pa_simple_free )pa_lib.resolve( "pa_simple_free" );
qmplay_pa_simple_write = ( _qmplay_pa_simple_write )pa_lib.resolve( "pa_simple_write" );
qmplay_pa_simple_read = ( _qmplay_pa_simple_read )pa_lib.resolve( "pa_simple_read" );
qmplay_pa_simple_flush = ( _qmplay_pa_simple_flush )pa_lib.resolve( "pa_simple_flush" );
if ( !qmplay_pa_simple_new || !qmplay_pa_simple_free || !qmplay_pa_simple_write || !qmplay_pa_simple_read || !qmplay_pa_simple_flush )
{
pa_lib.unload();
errStr = "błąd podczas pobierania funkcji z biblioteki: " + libName;
PlErr = true;
return;
}
}
switch ( bits2 )
{
case 8:
ss.format = PA_SAMPLE_U8;
break;
case 16:
ss.format = PA_SAMPLE_S16NE;
break;
case 24:
ss.format = PA_SAMPLE_S24NE;
break;
case 32:
ss.format = PA_SAMPLE_S32NE;
break;
}
ss.channels = chn2;
ss.rate = rate2;
attr.maxlength = ( uint32_t ) -1;
attr.tlength = delay * ( rate2 * ( bits2/8 ) * chn2 );
attr.prebuf = ( uint32_t ) -1;
attr.minreq = ( uint32_t ) -1;
attr.fragsize = attr.tlength;
pa_channel_map *chn_map = NULL;
if ( chn2 > 2 && chn2 <= 8 )
{
chn_map = new pa_channel_map;
chn_map->channels = chn2;
chn_map->map[ 0 ] = PA_CHANNEL_POSITION_FRONT_LEFT;
chn_map->map[ 1 ] = PA_CHANNEL_POSITION_FRONT_RIGHT;
chn_map->map[ 2 ] = PA_CHANNEL_POSITION_FRONT_CENTER;
chn_map->map[ 3 ] = PA_CHANNEL_POSITION_LFE;
chn_map->map[ 4 ] = PA_CHANNEL_POSITION_REAR_LEFT;
chn_map->map[ 5 ] = PA_CHANNEL_POSITION_REAR_RIGHT;
chn_map->map[ 6 ] = PA_CHANNEL_POSITION_SIDE_LEFT;
chn_map->map[ 7 ] = PA_CHANNEL_POSITION_SIDE_RIGHT;
}
pulse = qmplay_pa_simple_new( NULL, "QMPlay", PA_STREAM_PLAYBACK, NULL, "Output", &ss, chn_map, &attr, NULL );
delete chn_map;
if ( !pulse )
{
pa_lib.unload();
errStr = "błąd podczas otwierania wyjścia PulseAudio";
PlErr = true;
return;
}
if ( REC )
{
pulseREC = qmplay_pa_simple_new( NULL, "QMPlay", PA_STREAM_RECORD, NULL, "Input", &ss, chn_map, &attr, NULL );
if ( !pulseREC )
{
qmplay_pa_simple_free( pulse );
pa_lib.unload();
errStr = "błąd podczas otwierania wejścia PulseAudio";
PlErr = true;
return;
}
}
isOpen = true;
}
}
}
ModulePackage::ModulePackage(std::unique_ptr<QFile> file)
{
enum {
HEAD,
BRACE,
BODY
} state = HEAD;
enum {
OPERATOR,
FUNCTION,
TERMINAL
} type;
OperatorModule::StaticInfo opStatics;
FunctionModule::StaticInfo funcStatics;
OperatorInterface opInter;
FunctionInterface funcInter;
QList<QByteArray> head;
QString description;
QLibrary lib;
name_ = QFileInfo(*file).baseName();
if (file->open(QFile::ReadOnly)) {
while (!file->atEnd()) {
QByteArray line = file->readLine().trimmed();
if (! line.isEmpty()) {
switch (state) {
case HEAD:
head = line.split(':');
head[0] = head.at(0).trimmed();
head[1] = head.at(1).trimmed().toUpper();
if (head.at(1) == "OPERATOR") {
type = OPERATOR;
//opInter = new OperatorInterface;
} else if (head.at(1) == "FUNCTION") {
type = FUNCTION;
//funcInter = new FunctionInterface;
} else if (head.at(1) == "TERMINAL") {
type = TERMINAL;
}
state = BRACE;
break;
case BRACE:
if (line == "{") state = BODY;
break;
case BODY:
if (line == "}") {
switch (type) {
case OPERATOR:
modules.operators.append(OperatorModule(head.at(0), description, this, opInter, opStatics));
break;
case FUNCTION:
modules.functions.append(FunctionModule(head.at(0), description, this, funcInter, funcStatics));
break;
case TERMINAL:
modules.terminals.append(TerminalModule(head.at(0), description, this, (std::unique_ptr<CAS::AbstractArithmetic>(*)(const std::string &))lib.resolve(head[0] + "_jmodule")));
break;
}
state = HEAD;
} else {
auto colonPos = line.indexOf(':');
auto key = line.left(colonPos).trimmed();
auto value = line.right(line.length() - colonPos - 2).trimmed();
if (key == "description") {
description = value;
} else if (key == "matches") {
if (type == OPERATOR) {
opStatics.matches = std::make_shared<QString>(value);
} else if (type == FUNCTION) {
QList<QByteArray> matchParts = value.split(',');
funcStatics.matches = std::make_shared<QPair<QString, unsigned int>>(QString(matchParts.at(0)), matchParts.at(1).toUInt());
}
} else if (key == "priority") {
if (type == OPERATOR) opStatics.priority = value.toUInt();
else if (type == FUNCTION) funcStatics.priority = value.toUInt();
} else if (type == OPERATOR && key == "associativity") {
if (value == "left") opStatics.associativity = OperatorInterface::LEFT;
else if (value == "right") opStatics.associativity = OperatorInterface::RIGHT;
} else if (key == "lib") {
lib.setFileName(value);
std::string dbg = QString(head[0]).toStdString();
if (type == OPERATOR) opInter = ((OperatorInterface(*)())lib.resolve(head[0] + "_jmodule"))();
else if (type == FUNCTION) funcInter = ((FunctionInterface(*)())lib.resolve(head[0] + "_jmodule"))();
}
}
}
}
}
}
}
//
// Returns 'true' if all seems OK.
//
bool FTNoIR_Protocol::checkServerInstallationOK()
{
if (!SCClientLib.isLoaded())
{
qDebug() << "SCCheckClientDLL says: Starting Function";
SCClientLib.setFileName("SimConnect.DLL");
ActivationContext ctx(142);
if (!SCClientLib.load()) {
qDebug() << "SC load" << SCClientLib.errorString();
return false;
}
} else {
qDebug() << "SimConnect already loaded";
}
//
// Get the functions from the DLL.
//
simconnect_open = (importSimConnect_Open) SCClientLib.resolve("SimConnect_Open");
if (simconnect_open == NULL) {
qDebug() << "FTNoIR_Protocol::checkServerInstallationOK() says: SimConnect_Open function not found in DLL!";
return false;
}
simconnect_set6DOF = (importSimConnect_CameraSetRelative6DOF) SCClientLib.resolve("SimConnect_CameraSetRelative6DOF");
if (simconnect_set6DOF == NULL) {
qDebug() << "FTNoIR_Protocol::checkServerInstallationOK() says: SimConnect_CameraSetRelative6DOF function not found in DLL!";
return false;
}
simconnect_close = (importSimConnect_Close) SCClientLib.resolve("SimConnect_Close");
if (simconnect_close == NULL) {
qDebug() << "FTNoIR_Protocol::checkServerInstallationOK() says: SimConnect_Close function not found in DLL!";
return false;
}
//return true;
simconnect_calldispatch = (importSimConnect_CallDispatch) SCClientLib.resolve("SimConnect_CallDispatch");
if (simconnect_calldispatch == NULL) {
qDebug() << "FTNoIR_Protocol::checkServerInstallationOK() says: SimConnect_CallDispatch function not found in DLL!";
return false;
}
simconnect_subscribetosystemevent = (importSimConnect_SubscribeToSystemEvent) SCClientLib.resolve("SimConnect_SubscribeToSystemEvent");
if (simconnect_subscribetosystemevent == NULL) {
qDebug() << "FTNoIR_Protocol::checkServerInstallationOK() says: SimConnect_SubscribeToSystemEvent function not found in DLL!";
return false;
}
simconnect_mapclienteventtosimevent = (importSimConnect_MapClientEventToSimEvent) SCClientLib.resolve("SimConnect_MapClientEventToSimEvent");
if (simconnect_subscribetosystemevent == NULL) {
qDebug() << "FTNoIR_Protocol::checkServerInstallationOK() says: SimConnect_MapClientEventToSimEvent function not found in DLL!";
return false;
}
simconnect_addclienteventtonotificationgroup = (importSimConnect_AddClientEventToNotificationGroup) SCClientLib.resolve("SimConnect_AddClientEventToNotificationGroup");
if (simconnect_subscribetosystemevent == NULL) {
qDebug() << "FTNoIR_Protocol::checkServerInstallationOK() says: SimConnect_AddClientEventToNotificationGroup function not found in DLL!";
return false;
}
simconnect_setnotificationgrouppriority = (importSimConnect_SetNotificationGroupPriority) SCClientLib.resolve("SimConnect_SetNotificationGroupPriority");
if (simconnect_subscribetosystemevent == NULL) {
qDebug() << "FTNoIR_Protocol::checkServerInstallationOK() says: SimConnect_SetNotificationGroupPriority function not found in DLL!";
return false;
}
qDebug() << "FTNoIR_Protocol::checkServerInstallationOK() says: SimConnect functions resolved in DLL!";
return true;
}
