int main(int argc, char* argv[])
{
try
{
log_init();
if (argc == 1)
{
std::cout << "load libm.so" << std::endl;
cxxtools::dl::Library lib("m");
std::cout << "sym cos" << std::endl;
function_type cosine = (function_type)(lib["cos"]);
std::cout << "call cos" << std::endl;
std::cout << "cos(2.0) = " << cosine(2.0) << std::endl;
}
else
{
std::cout << "load " << argv[1] << std::endl;
cxxtools::dl::Library lib(argv[1]);
for (int a = 2; argv[a]; ++a)
{
std::cout << "sym " << argv[a] << std::endl;
cxxtools::dl::Symbol sym = lib.getSymbol(argv[a]);
std::cout << " => " << static_cast<void*>(sym) << std::endl;
}
}
}
catch (const std::exception& e)
{
std::cerr << e.what() << std::endl;
}
}
getModule KonqSidebarTree::getPluginFactory(const QString &name)
{
if (!pluginFactories.contains(name))
{
QString libName = pluginInfo[name];
KLibrary lib(libName);
if (lib.load())
{
// get the create_ function
QString factory = "create_" + libName;
KLibrary::void_function_ptr create = lib.resolveFunction(QFile::encodeName(factory));
if (create)
{
getModule func = (getModule)create;
pluginFactories.insert(name, func);
kDebug()<<"Added a module";
}
else
{
kWarning()<<"No create function found in"<<libName;
}
}
else
kWarning() << "Module " << libName << " can't be loaded!" ;
}
return pluginFactories[name];
}
static void resolveLibrary()
{
#ifndef QT_NO_LIBRARY
QLibrary lib(QLatin1String("resolv"));
if (!lib.load())
return;
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
}
static bool winServiceInit()
{
if (!pOpenSCManager) {
QLibrary lib("advapi32");
// only resolve unicode versions
RESOLVEW(RegisterServiceCtrlHandler);
RESOLVE(SetServiceStatus);
RESOLVEW(ChangeServiceConfig2);
RESOLVE(CloseServiceHandle);
RESOLVEW(CreateService);
RESOLVEW(OpenSCManager);
RESOLVE(DeleteService);
RESOLVEW(OpenService);
RESOLVE(QueryServiceStatus);
RESOLVEW(StartServiceCtrlDispatcher);
RESOLVEW(StartService); // need only Ansi version
RESOLVE(ControlService);
RESOLVE(DeregisterEventSource);
RESOLVEW(ReportEvent);
RESOLVEW(RegisterEventSource);
RESOLVEW(QueryServiceConfig);
RESOLVEW(QueryServiceConfig2);
}
return pOpenSCManager != 0;
}
bool QQuickControlSettings::resolveCurrentStylePath()
{
if (!m_styleMap.contains(m_name)) {
qWarning() << "WARNING: Cannot find style" << m_name;
return false;
}
StyleData styleData = m_styleMap.value(m_name);
if (styleData.m_stylePluginPath.isEmpty())
return true; // It's not a plugin; don't have to do anything.
typedef bool (*StyleInitFunc)();
typedef const char *(*StylePathFunc)();
QLibrary lib(styleData.m_stylePluginPath);
if (!lib.load()) {
qWarning().nospace() << "WARNING: Cannot load plugin " << styleData.m_stylePluginPath
<< " for style " << m_name << ": " << lib.errorString();
return false;
}
// Check for the existence of this first, as we don't want to init if this doesn't exist.
StyleInitFunc initFunc = (StyleInitFunc) lib.resolve("qt_quick_controls_style_init");
if (initFunc)
initFunc();
StylePathFunc pathFunc = (StylePathFunc) lib.resolve("qt_quick_controls_style_path");
if (pathFunc) {
styleData.m_styleDirPath = QString::fromLocal8Bit(pathFunc());
m_styleMap[m_name] = styleData;
m_path = styleData.m_styleDirPath;
}
return true;
}
void FitDialog::loadPlugins()
{
typedef char* (*fitFunc)();
ApplicationWindow *app = (ApplicationWindow *)this->parent();
QString path = app->fitPluginsPath + "/";
QDir dir(path);
QStringList lst = dir.entryList(QDir::Files|QDir::NoSymLinks);
for (int i=0; i<lst.count(); i++)
{
QLibrary lib(path + lst[i]);
fitFunc name = (fitFunc) lib.resolve( "name" );
fitFunc function = (fitFunc) lib.resolve("function");
fitFunc params = (fitFunc) lib.resolve("parameters");
if ( name && function && params )
{
d_plugin_function_names << QString(name());
d_plugin_functions << QString(function());
d_plugin_params << QString(params());
d_plugin_files_list << lib.library();
}
}
}
void LiteLoaderInstaller::applyLaunchwrapper(std::shared_ptr<OneSixVersion> to)
{
const QString intendedVersion = m_launcherWrapperVersionMapping[m_mcVersion];
QMutableListIterator<std::shared_ptr<OneSixLibrary>> it(to->libraries);
while (it.hasNext())
{
it.next();
if (it.value()->rawName().startsWith("net.minecraft:launchwrapper:"))
{
if (it.value()->version() >= intendedVersion)
{
return;
}
else
{
it.remove();
}
}
}
std::shared_ptr<OneSixLibrary> lib(new OneSixLibrary(
"net.minecraft:launchwrapper:" + m_launcherWrapperVersionMapping[m_mcVersion]));
lib->finalize();
to->libraries.prepend(lib);
}
TEST_F(TrajectoryLibraryTest, RemainderTrajectorySimpleAltitude) {
StereoOctomap octomap(bot_frames_);
// get a trajectory
TrajectoryLibrary lib(0);
lib.LoadLibrary("trajtest/simple", true);
double altitude = 5;
BotTrans trans;
bot_trans_set_identity(&trans);
trans.trans_vec[2] = altitude;
const Trajectory *traj = lib.GetTrajectoryByNumber(0);
double dist = traj->ClosestObstacleInRemainderOfTrajectory(octomap, trans, 0, 0);
EXPECT_EQ_ARM(dist, -1);
// add an obstacle
double point[3] = { 0, 0, 6};
AddPointToOctree(&octomap, point, 0);
dist = traj->ClosestObstacleInRemainderOfTrajectory(octomap, trans, 0, 0);
EXPECT_EQ_ARM(dist, 6 - altitude);
}
void tst_QPluginLoader::preloadedPlugin()
{
// check that using QPluginLoader does not interfere with QLibrary
QFETCH(QString, libname);
QLibrary lib(libname);
QVERIFY(lib.load());
typedef int *(*pf_t)();
pf_t pf = (pf_t)lib.resolve("pointerAddress");
QVERIFY(pf);
int *pluginVariable = pf();
QVERIFY(pluginVariable);
QCOMPARE(*pluginVariable, 0xc0ffee);
{
// load the plugin
QPluginLoader loader(libname);
QFETCH(bool, doLoad);
if (doLoad && loader.load()) {
// unload() returns false because QLibrary has it loaded
QVERIFY(!loader.unload());
}
}
QVERIFY(lib.isLoaded());
// if the library was unloaded behind our backs, the following will crash:
QCOMPARE(*pluginVariable, 0xc0ffee);
QVERIFY(lib.unload());
}
void loadLibraries(const QString& configFile)
{
QVector<QString> libraryList;
readDependencyConfigFile(configFile, libraryList);
for(int i=0; i<libraryList.size(); ++i)
{
QString libPath = libraryList.at(i).simplified(); // remove spaces at the beginning and the end
if(goodLibPath(libPath))
{
QFileInfo fi(libPath);
QString fileName = fi.fileName();
if (fileName == "touchmat.dll")
{
qDebug() << ">>>>>>>>> " << "Loading QtPlugin: " << libPath << ".............";
loadQtPlugin(libPath);
}
else
{
qDebug() << ">>>>>>>>>> " << "Loading normal library: " << libPath << "............";
QLibrary lib(libPath);
if (!lib.load())
{
qCritical() << "Failed to load: " << libPath;
}
}
qDebug() << "";
}
}
}
int qt_retrieveNisPrinters(QList<QPrinterDescription> *printers)
{
#ifndef QT_NO_LIBRARY
typedef int (*WildCast)(int, char *, int, char *, int, char *);
char printersConfByname[] = "printers.conf.byname";
char *domain;
int err;
QLibrary lib(QLatin1String("nsl"));
typedef int (*ypGetDefaultDomain)(char **);
ypGetDefaultDomain _ypGetDefaultDomain = (ypGetDefaultDomain)lib.resolve("yp_get_default_domain");
typedef int (*ypAll)(const char *, const char *, const struct ypall_callback *);
ypAll _ypAll = (ypAll)lib.resolve("yp_all");
if (_ypGetDefaultDomain && _ypAll) {
err = _ypGetDefaultDomain(&domain);
if (err == 0) {
ypall_callback cb;
// wild cast to support K&R-style system headers
(WildCast &) cb.foreach = (WildCast) qt_pd_foreach;
cb.data = (char *) printers;
err = _ypAll(domain, printersConfByname, &cb);
}
if (!err)
return Success;
}
#endif //QT_NO_LIBRARY
return Unavail;
}
HMODULE __stdcall FakeLoadLibraryA(LPCSTR lpFilePath)
{
fs::path lib((const char*)lpFilePath);
if (lib == "Game.dll")
{
if (!g_DllMod.hGameDll)
{
g_DllMod.hGameDll = ::LoadLibraryW((g_DllMod.patch_path / L"Game.dll").c_str());
if (!g_DllMod.hGameDll)
{
g_DllMod.hGameDll = ::LoadLibraryW(L"Game.dll");
if (!g_DllMod.hGameDll)
{
return g_DllMod.hGameDll;
}
}
RealCreateWindowExA = base::hook::iat(L"Game.dll", "user32.dll", "CreateWindowExA", (uintptr_t)FakeCreateWindowExA);
if (g_DllMod.IsDisableSecurityAccess)
{
RealGameLoadLibraryA = base::hook::iat(L"Game.dll", "kernel32.dll", "LoadLibraryA", (uintptr_t)FakeGameLoadLibraryA);
}
HANDLE hMpq;
aero::std_call<BOOL>(RealSFileOpenArchive, (g_DllMod.patch_path / "Patch.mpq").string().c_str(), 9, 6, &hMpq);
g_DllMod.LoadPlugins();
return g_DllMod.hGameDll;
}
}
return aero::std_call<HMODULE>(RealLoadLibraryA, lpFilePath);
}
static void resolveLibs()
{
#ifndef Q_OS_TEMP
static bool triedResolve = false;
if (!triedResolve) {
#ifdef QT_THREAD_SUPPORT
// protect initialization
QMutexLocker locker(qt_global_mutexpool ?
qt_global_mutexpool->get(&triedResolve) : 0);
// check triedResolve again, since another thread may have already
// done the initialization
if (triedResolve) {
// another thread did initialize the security function pointers,
// so we shouldn't do it again.
return;
}
#endif
triedResolve = true;
if (qt_winunicode) {
QLibrary lib("shell32");
ptrSHBrowseForFolder = (PtrSHBrowseForFolder) lib.resolve("SHBrowseForFolderW");
ptrSHGetPathFromIDList = (PtrSHGetPathFromIDList) lib.resolve("SHGetPathFromIDListW");
}
}
#endif
}
bool DebuggerEngineLibrary::init(const QString &path,
QString *dbgEngDLL,
QString *errorMessage)
{
// Load the dependent help lib first
const QString helpLibPath = libPath(QLatin1String(dbgHelpDllC), path);
QLibrary helpLib(helpLibPath, 0);
if (!helpLib.isLoaded() && !helpLib.load()) {
*errorMessage = msgLibLoadFailed(helpLibPath, helpLib.errorString());
return false;
}
// Load dbgeng lib
const QString engineLibPath = libPath(QLatin1String(dbgEngineDllC), path);
QLibrary lib(engineLibPath, 0);
if (!lib.isLoaded() && !lib.load()) {
*errorMessage = msgLibLoadFailed(engineLibPath, lib.errorString());
return false;
}
*dbgEngDLL = engineLibPath;
// Locate symbols
void *createFunc = lib.resolve(debugCreateFuncC);
if (!createFunc) {
*errorMessage = QCoreApplication::translate("Debugger::Cdb", "Unable to resolve '%1' in the debugger engine library '%2'").
arg(QLatin1String(debugCreateFuncC), QLatin1String(dbgEngineDllC));
return false;
}
m_debugCreate = static_cast<DebugCreateFunction>(createFunc);
return true;
}
TEST(GeneralPlugin, load)
{
DynamicLibrary::Ptr lib(new DynamicLibrary(""));
PluginThread::Ptr thread(new PluginThread());
GeneralPlugin::Params pluginParams(1, lib, thread);
ASSERT_NO_THROW(GeneralPluginTest plugin(pluginParams));
}
TEST_F(TrajectoryLibraryTest, ManyTrajectoriesWithTransform) {
StereoOctomap octomap(bot_frames_);
TrajectoryLibrary lib(0);
lib.LoadLibrary("trajtest/full", true);
double altitude = 30;
double point[3] = {18, 12, 0};
AddPointToOctree(&octomap, point, altitude);
BotTrans trans;
bot_trans_set_identity(&trans);
trans.trans_vec[0] = 17;
trans.trans_vec[1] = 11;
trans.trans_vec[2] = altitude;
// send th
double dist;
const Trajectory *best_traj;
std::tie(dist, best_traj) = lib.FindFarthestTrajectory(octomap, trans, 5.0);
DrawOriginLcmGl(lcm_);
bot_lcmgl_color3f(lcmgl_, 0, 0, 1);
best_traj->Draw(lcmgl_, &trans);
EXPECT_EQ_ARM(best_traj->GetTrajectoryNumber(), 3);
EXPECT_NEAR(dist, 1.025243, TOLERANCE);
// now add a yaw
trans.rot_quat[0] = 0.642787609686539;
trans.rot_quat[1] = 0;
trans.rot_quat[2] = 0;
trans.rot_quat[3] = 0.766044443118978;
bot_lcmgl_color3f(lcmgl_, 1, 0, 0);
best_traj->Draw(lcmgl_, &trans);
bot_lcmgl_switch_buffer(lcmgl_);
std::tie(dist, best_traj) = lib.FindFarthestTrajectory(octomap, trans, 5.0);
//lib.Draw(lcm_, &trans);
EXPECT_EQ_ARM(best_traj->GetTrajectoryNumber(), 2);
EXPECT_NEAR(dist, 1.174604, TOLERANCE);
// now have a transform with roll, pitch, and yaw
trans.rot_quat[0] = 0.863589399067779;
trans.rot_quat[1] = -0.004581450790098;
trans.rot_quat[2] = 0.298930259006064;
trans.rot_quat[3] = 0.405996379758463;
std::tie(dist, best_traj) = lib.FindFarthestTrajectory(octomap, trans, 5.0);
EXPECT_EQ_ARM(best_traj->GetTrajectoryNumber(), 4);
EXPECT_NEAR(dist, 0.327772, TOLERANCE);
}
TEST_F(TrajectoryLibraryTest, ManyPointsAgainstMatlab) {
StereoOctomap octomap(bot_frames_);
double altitude = 30;
// load points
AddManyPointsToOctree(&octomap, x_points_, y_points_, z_points_, number_of_reference_points_, altitude);
TrajectoryLibrary lib(0);
lib.LoadLibrary("trajtest/many", true);
BotTrans trans;
bot_trans_set_identity(&trans);
trans.trans_vec[2] = altitude;
double dist;
const Trajectory *best_traj;
std::tie(dist, best_traj) = lib.FindFarthestTrajectory(octomap, trans, 50.0);
ASSERT_TRUE(best_traj != nullptr);
EXPECT_EQ_ARM(best_traj->GetTrajectoryNumber(), 1);
EXPECT_NEAR(dist, 4.2911, 0.001);
}
std::shared_ptr<statefs_provider> load(std::string const& path
, statefs_server *server)
{
std::shared_ptr<cor::SharedLib> lib
(new cor::SharedLib(path, RTLD_LAZY));
if (!lib->is_loaded())
return nullptr;
auto fn = lib->sym<statefs_provider_fn>
(statefs_provider_accessor());
if (!fn)
return nullptr;
statefs::provider_ptr res
(fn(server), [lib](statefs_provider* p) mutable {
if (p)
statefs_provider_release(p);
lib.reset();
});
if (!res)
return nullptr;
if (!statefs_is_compatible(STATEFS_CURRENT_VERSION, res.get())) {
std::cerr << "statefs: Incompatible provider version "
<< res->version << " vs "
<< STATEFS_CURRENT_VERSION;
return nullptr;
}
return res;
}
TEST_F(TrajectoryLibraryTest, RemainderTrajectory) {
StereoOctomap octomap(bot_frames_);
// Load a complicated trajectory
TrajectoryLibrary lib(0);
lib.LoadLibrary("trajtest/many", true);
double altitude = 30;
BotTrans trans;
bot_trans_set_identity(&trans);
trans.trans_vec[2] = altitude;
const Trajectory *traj = lib.GetTrajectoryByNumber(1);
double dist;
double point[3] = { 6.65, -7.23, 9.10 };
AddPointToOctree(&octomap, point, altitude);
dist = traj->ClosestObstacleInRemainderOfTrajectory(octomap, trans, 0, 0);
EXPECT_NEAR(dist, 11.748141101535500, TOLERANCE2); // from matlab
dist = traj->ClosestObstacleInRemainderOfTrajectory(octomap, trans, 0.95, 0);
EXPECT_NEAR(dist, 11.8831, TOLERANCE2);
dist = traj->ClosestObstacleInRemainderOfTrajectory(octomap, trans, 1.5, 0); // t after trajectory
EXPECT_NEAR(dist, 12.3832, TOLERANCE2); // from matlab
}
QString QWpsDrawer::getModelName(QString libraryName) {
QLibrary lib(libraryName);
if ((pfget_model_name)lib.resolve("get_model_name"))
return ((pfget_model_name)lib.resolve("get_model_name"))();
DEBUGF1("ERR: failed to resolve <get_model_name>");
return "unknown";
}
void
LibraryNotify::receive (UAS_CollectionRetrievedMsg &message, void *client_data)
{
ON_DEBUG (printf ("Got Library Notify message!\n"));
UAS_Pointer<UAS_Common> lib(message.fCol->root());
search_scope_mgr().insert (lib);
}
bool QWpsDrawer::tryResolve() {
QLibrary lib(mCurTarget);
lib_wps_init = (pfwps_init)lib.resolve("wps_init");
lib_wps_display = (pfwps_display)lib.resolve("wps_display");
lib_wps_refresh = (pfwps_refresh)lib.resolve("wps_refresh");
lib_get_model_name = (pfget_model_name)lib.resolve("get_model_name");
mResolved = lib_wps_init && lib_wps_display && lib_wps_refresh && lib_get_model_name;
if (!mResolved)
DEBUGF1(tr("ERR: Failed to resolve funcs!"));
else {
int v = api.verbose;
memset(&api,0,sizeof(struct proxy_api));
api.verbose = v;
api.putsxy = &QWpsDrawer::putsxy;
api.transparent_bitmap_part = &QWpsDrawer::transparent_bitmap_part;
api.bitmap_part = &QWpsDrawer::bitmap_part;
api.drawpixel = &QWpsDrawer::drawpixel;
api.fillrect = &QWpsDrawer::fillrect;
api.hline = &QWpsDrawer::hline;
api.vline = &QWpsDrawer::vline;
api.clear_viewport = &QWpsDrawer::clear_viewport;
api.load_wps_backdrop = &QWpsDrawer::load_wps_backdrop;
api.read_bmp_file = &QWpsDrawer::read_bmp_file;
api.debugf = &qlogger;
qDebug()<<(mCurTarget+" resolved");
}
return mResolved;
}
void *QGLContext::getProcAddress(const QString &proc) const
{
typedef void *(*qt_glXGetProcAddressARB)(const GLubyte *);
static qt_glXGetProcAddressARB glXGetProcAddressARB = 0;
static bool resolved = false;
if (resolved && !glXGetProcAddressARB)
return 0;
if (!glXGetProcAddressARB) {
QString glxExt = QString(QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS)));
if (glxExt.contains(QLatin1String("GLX_ARB_get_proc_address"))) {
#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
void *handle = dlopen(NULL, RTLD_LAZY);
if (handle) {
glXGetProcAddressARB = (qt_glXGetProcAddressARB) dlsym(handle, "glXGetProcAddressARB");
dlclose(handle);
}
if (!glXGetProcAddressARB)
#endif
{
extern const QString qt_gl_library_name();
QLibrary lib(qt_gl_library_name());
glXGetProcAddressARB = (qt_glXGetProcAddressARB) lib.resolve("glXGetProcAddressARB");
}
}
resolved = true;
}
if (!glXGetProcAddressARB)
return 0;
return glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(proc.toLatin1().data()));
}
auto_release_ptr<Plugin> PluginCache::load(const char* path)
{
boost::lock_guard<boost::mutex> lock(g_plugin_cache_mutex);
// Check if we loaded this plugin before.
PluginCacheType::iterator it = g_plugin_cache.find(path);
if (it != g_plugin_cache.end())
{
if (boost::shared_ptr<SharedLibrary> lib = it->second.lock())
{
Plugin::Impl* impl = new Plugin::Impl(lib);
return auto_release_ptr<Plugin>(new Plugin(impl));
}
}
// If this plugin is not in the cache, load the shared lib.
boost::shared_ptr<SharedLibrary> lib(new SharedLibrary(path), PluginDeleter());
// Try to call the initialization function if defined.
Plugin::InitPluginFnType init_fn =
reinterpret_cast<Plugin::InitPluginFnType>(
lib->get_symbol("initialize_plugin"));
if (init_fn)
{
if (!init_fn())
throw ExceptionPluginInitializationFailed();
}
Plugin::Impl* impl = new Plugin::Impl(lib);
g_plugin_cache[path] = boost::weak_ptr<SharedLibrary>(lib);
return auto_release_ptr<Plugin>(new Plugin(impl));
}
ctkPluginManager::ctkPluginManager()
: d_ptr(new ctkPluginManagerPrivate())
{
Q_D(ctkPluginManager);
QString libName("CTKCore");
QLibrary lib(libName);
QFileInfo fileInfo(libName);
QString libBaseName(fileInfo.baseName());
if (libBaseName.startsWith("lib"))
{
libBaseName.remove(0, 3);
}
qDebug() << libBaseName;
lib.load();
if (lib.isLoaded())
{
QString xyz = QString(":/") + libBaseName + "/servicedescriptor.xml";
qDebug() << "resource string: " << xyz;
QFile serviceDescriptor(xyz);
qDebug() << "file exists: " << serviceDescriptor.exists();
qDebug() << "open returns:" << serviceDescriptor.open(QIODevice::ReadOnly);
qDebug() << "file open: " << serviceDescriptor.isOpen();
qDebug() << "file is readable: " << serviceDescriptor.isReadable();
//QByteArray serviceBA = serviceDescriptor.readAll();
//qDebug() << serviceBA;
qDebug() << "Service for " << libBaseName << " registered:" << d->serviceManager.addService(&serviceDescriptor);
lib.unload();
}
}
static bool loadLibIDN()
{
if (Jreen_idn_stringprep)
return true;
if (triedToInit)
return false;
triedToInit = true;
QLibrary lib(QLatin1String("idn"));
if (!lib.load()) {
#ifdef Q_OS_WIN32
QStringList paths = QStringList()
<< QLatin1String("idn-11")
<< QLatin1String("libidn-11")
<< QLatin1String("libidn");
bool ok = false;
for (int i = 0; !ok && i < paths.size(); i++) {
lib.setFileName(paths.at(i));
ok |= lib.load();
}
if (!ok)
#endif // Q_OS_WIN32
return false;
}
Jreen_idn_stringprep_nameprep
= reinterpret_cast<Stringprep_profile*>(lib.resolve("stringprep_nameprep"));
Jreen_idn_stringprep_xmpp_nodeprep
= reinterpret_cast<Stringprep_profile*>(lib.resolve("stringprep_xmpp_nodeprep"));
Jreen_idn_stringprep_xmpp_resourceprep
= reinterpret_cast<Stringprep_profile*>(lib.resolve("stringprep_xmpp_resourceprep"));
Jreen_idn_stringprep = reinterpret_cast<Jreen_idn_stringprep_>(lib.resolve("stringprep"));
return true;
}
static void resolveLibrary()
{
#if !defined(QT_NO_LIBRARY) && !defined(Q_OS_QNX)
QLibrary lib(QLatin1String("resolv"));
lib.setLoadHints(QLibrary::ImprovedSearchHeuristics);
if (!lib.load())
return;
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
}
//---------------------------- PUBLIC -----------------------------//
wxBaseRadioButton::wxBaseRadioButton(wxWindow* parent, wxWindowID id,
const wxString& label,
const HashString &color,
const HashString &font, const wxPoint& pos,
const wxSize& size, long style)
: wxRadioButton(parent, id, label, pos, size, style)
, BaseSkinMixin<wxBaseRadioButton>(color, font, shInputBackground)
{
#ifdef __WIN32__
if ( wxApp::GetComCtl32Version() >= 600 )
{
wxLogNull nolog;
typedef boost::scoped_ptr<wxDynamicLibrary> DynamicLibraryPtr;
DynamicLibraryPtr lib(new wxDynamicLibrary);
if(true == lib->Load(wxT("uxtheme.dll")))
{
typedef HRESULT (__stdcall *PFNWXUSETWINDOWTHEME)(WXHWND,
const wchar_t*, const wchar_t *) ;
PFNWXUSETWINDOWTHEME func = (PFNWXUSETWINDOWTHEME)
lib->GetSymbol(_T("SetWindowTheme"));
if(func)
{
func((HWND) GetHWND(), LPCWSTR(" "), LPCWSTR(" "));
}
}
}
#endif
OnSkin();
}
void* QGLXContext::getProcAddress(const QString& procName)
{
Q_XCB_NOOP(m_screen->connection());
typedef void *(*qt_glXGetProcAddressARB)(const GLubyte *);
static qt_glXGetProcAddressARB glXGetProcAddressARB = 0;
static bool resolved = false;
if (resolved && !glXGetProcAddressARB)
return 0;
if (!glXGetProcAddressARB) {
QList<QByteArray> glxExt = QByteArray(glXGetClientString(DISPLAY_FROM_XCB(m_screen), GLX_EXTENSIONS)).split(' ');
if (glxExt.contains("GLX_ARB_get_proc_address")) {
#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
void *handle = dlopen(NULL, RTLD_LAZY);
if (handle) {
glXGetProcAddressARB = (qt_glXGetProcAddressARB) dlsym(handle, "glXGetProcAddressARB");
dlclose(handle);
}
if (!glXGetProcAddressARB)
#endif
{
extern const QString qt_gl_library_name();
// QLibrary lib(qt_gl_library_name());
QLibrary lib(QLatin1String("GL"));
glXGetProcAddressARB = (qt_glXGetProcAddressARB) lib.resolve("glXGetProcAddressARB");
}
}
resolved = true;
}
if (!glXGetProcAddressARB)
return 0;
return glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(procName.toLatin1().data()));
}
bool KCMInit::runModule(const QString &libName, KService::Ptr service)
{
QLibrary lib(libName);
if (lib.load()) {
QVariant tmp = service->property("X-KDE-Init-Symbol", QVariant::String);
QString kcminit;
if ( tmp.isValid() ) {
kcminit = tmp.toString();
if( !kcminit.startsWith( QLatin1String( "kcminit_" ) ) )
kcminit = "kcminit_" + kcminit;
} else {
kcminit = "kcminit_" + libName;
}
// get the kcminit_ function
void *init = lib.resolve(kcminit.toUtf8());
if (init) {
// initialize the module
kDebug(1208) << "Initializing " << libName << ": " << kcminit;
void (*func)() = (void(*)())init;
func();
return true;
} else {
kDebug(1208) << "Module" << libName << "does not actually have a kcminit function";
}
}
return false;
}
