static ABAdminPlugin * tryLoadPlugin( const QString & path )
{
QLibrary library(path);
abadmin_plugin_instance_fn func = (abadmin_plugin_instance_fn)library.resolve( "abadmin_plugin_instance" );
if( func )
return func();
}
int main() {
PRINT("This example loads dictionaries from the EDS library.");
std::unordered_map<kaco::Address, kaco::Entry> dictionary;
std::unordered_map<std::string, kaco::Address> name_to_address;
kaco::EDSLibrary library(dictionary, name_to_address);
bool success = library.lookup_library();
if (!success) {
ERROR("EDS library not found.");
return EXIT_FAILURE;
}
success = library.load_default_eds(402);
if (!success) {
ERROR("load_default_eds(402) failed.");
} else {
print_dictionary(dictionary);
}
// This should fail.
dictionary.clear();
name_to_address.clear();
success = library.load_default_eds(405);
if (!success) {
ERROR("load_default_eds(405) failed.");
} else {
print_dictionary(dictionary);
}
return EXIT_SUCCESS;
}
ConfigurePreviewPluginDialog::ConfigurePreviewPluginDialog(const QString& pluginName,
const QString& desktopEntryName,
QWidget* parent) :
KDialog(parent),
m_configurationWidget(0),
m_previewPlugin(0)
{
QLibrary library(desktopEntryName);
if (library.load()) {
newCreator create = (newCreator)library.resolve("new_creator");
if (create) {
m_previewPlugin = dynamic_cast<ThumbCreator*>(create());
}
}
setCaption(i18nc("@title:window", "Configure Preview for %1", pluginName));
setMinimumWidth(400);
setButtons(Ok | Cancel);
setDefaultButton(Ok);
QWidget* mainWidget = new QWidget(this);
mainWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
QVBoxLayout* layout = new QVBoxLayout(mainWidget);
if (m_previewPlugin) {
m_configurationWidget = m_previewPlugin->createConfigurationWidget();
layout->addWidget(m_configurationWidget);
}
layout->addStretch(1);
setMainWidget(mainWidget);
connect(this, SIGNAL(okClicked()), this, SLOT(slotOk()));
}
QRegion QRegion::fromHIShapeRef(HIShapeRef shape)
{
QRegion returnRegion;
returnRegion.detach();
// Begin gratuitous #if-defery
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
# ifndef Q_WS_MAC64
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
# endif
HIShapeEnumerate(shape, kHIShapeParseFromTopLeft, shape2QRegionHelper, &returnRegion);
# ifndef Q_WS_MAC64
} else
# endif
#endif
{
#if !defined(Q_WS_MAC64) && !defined(QT_MAC_USE_COCOA)
if (ptrHIShapeGetAsQDRgn == 0) {
QLibrary library(QLatin1String("/System/Library/Frameworks/Carbon.framework/Carbon"));
library.setLoadHints(QLibrary::ExportExternalSymbolsHint);
ptrHIShapeGetAsQDRgn = reinterpret_cast<PtrHIShapeGetAsQDRgn>(library.resolve("HIShapeGetAsQDRgn"));
}
RgnHandle rgn = qt_mac_get_rgn();
ptrHIShapeGetAsQDRgn(shape, rgn);
returnRegion = QRegion::fromQDRgn(rgn);
qt_mac_dispose_rgn(rgn);
#endif
}
return returnRegion;
}
void ShaderDialog::installShaderParameters(int)
{
ShaderLibrary& library(ShaderLibrary::instance());
QString name(m_dialog.shaderCombo->currentText());
library.setUniformVariables(name, getParameters());
updated();
}
Pothos::Util::CompilerArgs Pothos::Util::CompilerArgs::defaultDevEnv(void)
{
Pothos::Util::CompilerArgs args;
//add devel environment libraries
Poco::Path path(Pothos::System::getPothosDevLibraryPath());
std::vector<std::string> files; Poco::File(path).list(files);
for (size_t i = 0; i < files.size(); i++)
{
Poco::Path library(path, files[i]);
if ((
library.getExtension() == "so" or
library.getExtension() == "lib" or
library.getExtension() == "dylib"
) and
(
files[i].find("Poco") != std::string::npos or
files[i].find("Pothos") != std::string::npos
)) args.libraries.push_back(library.absolute().toString());
}
//add devel environment includes
args.includes.push_back(Pothos::System::getPothosDevIncludePath());
return args;
}
ShaderDialog::ShaderDialog(QWidget* parent) : QDialog(parent)
{
m_dialog.setupUi(this);
m_labels[0] = m_dialog.label0;
m_labels[1] = m_dialog.label1;
m_labels[2] = m_dialog.label2;
m_labels[3] = m_dialog.label3;
m_sliders[0] = m_dialog.slider0;
m_sliders[1] = m_dialog.slider1;
m_sliders[2] = m_dialog.slider2;
m_sliders[3] = m_dialog.slider3;
m_checkBoxes[0] = m_dialog.checkBox0;
m_checkBoxes[1] = m_dialog.checkBox1;
for (int i = 0; i < s_maxSliders; ++i) {
connect(m_sliders[i], SIGNAL(valueChanged(int)),
this, SLOT(installShaderParameters(int)));
}
for (int i = 0; i < s_maxCheckBoxes; ++i) {
connect(m_checkBoxes[i], SIGNAL(stateChanged(int)),
this, SLOT(installShaderParameters(int)));
}
ShaderLibrary& library(ShaderLibrary::instance());
QStringList shaderNames(library.availableShaders());
m_dialog.shaderCombo->addItems(shaderNames);
hideOptionControls();
int index(m_dialog.shaderCombo->findText(Preferences::DefaultShader()));
if (index >= 0) {
m_dialog.shaderCombo->setCurrentIndex(index);
on_shaderCombo_currentIndexChanged(index);
}
}
// -------------------------------------------------------------------------- //
//
void Test_ScalarDistributionData::testInitNotifyAccept()
{
// Read a library.
Library library("./testfiles/testlibSmall");
// Construct with the normal constructor.
const std::string scalar_name("VP-Volume");
const std::string ref_path("./testfiles/vvol_ref.data");
const double sigma = 0.093;
const int pos = 1;
ScalarDistributionData sdd(scalar_name, ref_path, sigma, pos);
// Setup a small sampleset.
std::vector<int> sampleset(10);
sampleset[0] = 7;
sampleset[1] = 9;
sampleset[2] = 13;
sampleset[3] = 27;
sampleset[4] = 28;
sampleset[5] = 29;
sampleset[6] = 43;
sampleset[7] = 53;
sampleset[8] = 56;
sampleset[9] = 57;
// Call init.
sdd.init(sampleset, library);
// Check that the data was correctly set.
CPPUNIT_ASSERT_EQUAL( 10, sdd.nsample_ );
const double chi2 = 16.79464613935;
CPPUNIT_ASSERT_DOUBLES_EQUAL( chi2, sdd.chi2_, 1.0e-10 );
// Check a few values.
CPPUNIT_ASSERT_DOUBLES_EQUAL( sdd.distribution_[1] , 0.1, 1.0e-12 );
CPPUNIT_ASSERT_DOUBLES_EQUAL( sdd.distribution_[26], 0.2, 1.0e-12 );
CPPUNIT_ASSERT_DOUBLES_EQUAL( sdd.distribution_[86], 0.1, 1.0e-12 );
// Call notify.
const int from_sample = 29;
const int from_basis = 34;
sdd.notify(from_sample, from_basis, library);
// Check chi2 and chi2_new.
const double chi2_new = 16.7499785124567;
CPPUNIT_ASSERT_DOUBLES_EQUAL( chi2_new, sdd.chi2_new_, 1.0e-8 );
CPPUNIT_ASSERT_DOUBLES_EQUAL( chi2, sdd.chi2_, 1.0e-8 );
// Call accept.
sdd.accept();
// Check that chi2 was set.
CPPUNIT_ASSERT_DOUBLES_EQUAL( chi2_new, sdd.chi2_, 1.0e-10 );
// Check that the curve was set.
for (size_t i = 0; i < sdd.distribution_.size(); ++i)
{
CPPUNIT_ASSERT_DOUBLES_EQUAL( sdd.distribution_[i], sdd.distribution_new_[i], 1.0e-12 );
}
}
static void initializeGtk(QLibrary* module = 0)
{
// Ensures missing Gtk initialization in some versions of Adobe's flash player
// plugin do not cause crashes. See BR# 40567, 44324, and 44405 for details.
if (module) {
typedef void *(*gtk_init_ptr)(int*, char***);
gtk_init_ptr gtkInit = (gtk_init_ptr)module->resolve("gtk_init");
if (gtkInit) {
// Prevent gtk_init() from replacing the X error handlers, since the Gtk
// handlers abort when they receive an X error, thus killing the viewer.
#ifdef Q_WS_X11
int (*old_error_handler)(Display*, XErrorEvent*) = XSetErrorHandler(0);
int (*old_io_error_handler)(Display*) = XSetIOErrorHandler(0);
#endif
gtkInit(0, 0);
#ifdef Q_WS_X11
XSetErrorHandler(old_error_handler);
XSetIOErrorHandler(old_io_error_handler);
#endif
return;
}
}
QLibrary library(QLatin1String("libgtk-x11-2.0"), 0);
if (library.load()) {
typedef void *(*gtk_init_check_ptr)(int*, char***);
gtk_init_check_ptr gtkInitCheck = (gtk_init_check_ptr)library.resolve("gtk_init_check");
// NOTE: We're using gtk_init_check() since gtk_init() calls exit() on failure.
if (gtkInitCheck)
(void) gtkInitCheck(0, 0);
}
}
static corto_dl corto_load_validLibrary(corto_string fileName, corto_string *build_out) {
corto_dl result = NULL;
corto_string ___ (*build)(void);
corto_string ___ (*library)(void);
if (build_out) {
*build_out = NULL;
}
if (!(result = corto_dlOpen(fileName))) {
corto_seterr("%s", corto_dlError());
goto error;
}
/* Lookup build function */
build = (corto_string ___ (*)(void))corto_dlProc(result, "corto_getBuild");
library = (corto_string ___ (*)(void))corto_dlProc(result, "corto_getLibrary");
/* Validate version */
if (build && strcmp(build(), corto_getBuild())) {
corto_seterr(
"corto: library '%s' links with conflicting corto library\n"
" links with: '%s' (%s)\n"
" current: '%s' (%s)\n",
fileName, library ? library() : "???", build(), corto_getLibrary(), corto_getBuild());
/* Library is linked with different Corto version */
if (build_out) {
*build_out = corto_strdup(build());
}
goto error;
} else if (build) {
corto_debug(
"loader: '%s' links with correct corto library\n build: '%s'\n library: '%s'\n",
fileName, build(), library());
} else {
corto_trace("loader: found '%s' which doesn't link with corto", fileName);
}
/* If no build function is available, the library is not linked with
* Corto, and probably represents a --nocorto package */
return result;
error:
if (result) corto_dlClose(result);
return NULL;
}
// open a native library and push a handle
// Allocates memory
void factor_vm::primitive_dlopen() {
data_root<byte_array> path(ctx->pop(), this);
check_tagged(path);
data_root<dll> library(allot<dll>(sizeof(dll)), this);
library->path = path.value();
ffi_dlopen(library.untagged());
ctx->push(library.value());
}
KLibFactory* KLibLoader::factory( const char* name )
{
KLibrary* lib = library( name );
if ( !lib )
return 0;
return lib->factory();
}
void QWindowsShcoreDLL::init()
{
if (QSysInfo::windowsVersion() < QSysInfo::WV_WINDOWS8_1)
return;
QSystemLibrary library(QStringLiteral("SHCore"));
getProcessDpiAwareness = (GetProcessDpiAwareness)library.resolve("GetProcessDpiAwareness");
setProcessDpiAwareness = (SetProcessDpiAwareness)library.resolve("SetProcessDpiAwareness");
getDpiForMonitor = (GetDpiForMonitor)library.resolve("GetDpiForMonitor");
}
static GetSpecialFolderPath resolveGetSpecialFolderPath()
{
static GetSpecialFolderPath gsfp = 0;
if (!gsfp) {
QSystemLibrary library(QLatin1String("shell32"));
gsfp = (GetSpecialFolderPath)library.resolve("SHGetSpecialFolderPathW");
}
return gsfp;
}
/* open a native library and push a handle */
inline void factorvm::vmprim_dlopen()
{
gc_root<byte_array> path(dpop(),this);
path.untag_check(this);
gc_root<dll> library(allot<dll>(sizeof(dll)),this);
library->path = path.value();
ffi_dlopen(library.untagged());
dpush(library.value());
}
void load_plugin(std::string path)
{
QString libPath(path.c_str());
QLibrary library(libPath);
bool loaded = library.load();
if(!loaded)
printf("%s library failed to load!\n", path.c_str());
}
void QWindowsShell32DLL::init()
{
QSystemLibrary library(QStringLiteral("shell32"));
sHCreateItemFromParsingName = (SHCreateItemFromParsingName)(library.resolve("SHCreateItemFromParsingName"));
sHGetKnownFolderIDList = (SHGetKnownFolderIDList)(library.resolve("SHGetKnownFolderIDList"));
sHGetStockIconInfo = (SHGetStockIconInfo)library.resolve("SHGetStockIconInfo");
sHGetImageList = (SHGetImageList)library.resolve("SHGetImageList");
sHCreateItemFromIDList = (SHCreateItemFromIDList)library.resolve("SHCreateItemFromIDList");
}
bool QWindowsUser32DLL::initTouch()
{
QSystemLibrary library(QStringLiteral("user32"));
registerTouchWindow = (RegisterTouchWindow)(library.resolve("RegisterTouchWindow"));
unregisterTouchWindow = (UnregisterTouchWindow)(library.resolve("UnregisterTouchWindow"));
getTouchInputInfo = (GetTouchInputInfo)(library.resolve("GetTouchInputInfo"));
closeTouchInputHandle = (CloseTouchInputHandle)(library.resolve("CloseTouchInputHandle"));
return registerTouchWindow && unregisterTouchWindow && getTouchInputInfo && getTouchInputInfo;
}
void tst_QLibrary::unload_after_implicit_load()
{
QLibrary library( QCoreApplication::applicationDirPath() + "/mylib" );
QFunctionPointer p = library.resolve("mylibversion");
QVERIFY(p); // Check if it was loaded
QVERIFY(library.isLoaded());
QVERIFY(library.unload());
QCOMPARE(library.isLoaded(), false);
}
TrayIndicator *MainWidget::createTrayObject(QWidget *obj_parent)
{
TrayFunctionPointer create_tray = NULL;
#ifdef Q_OS_LINUX
QString desktop = getenv("XDG_CURRENT_DESKTOP");
qDebug() << "Current desktop: " << desktop;
#ifdef QT_DEBUG
QString library_path = QApplication::applicationDirPath();
#else
QString library_path = "/usr/lib/qcma";
#endif
if(desktop.toLower() == "kde")
{
#ifdef QT_DEBUG
library_path += "/../kdenotifier";
#endif
// KDENotifier
QLibrary library(library_path + "/libqcma_kdenotifier.so");
if(library.load())
create_tray = reinterpret_cast<TrayFunctionPointer>(library.resolve("createTrayIndicator"));
else
qWarning() << "Cannot load libqcma_kdenotifier plugin from" << library_path;
}
else
// try to use the appindicator if is available
// if(desktop.toLower() == "unity")
{
#ifdef QT_DEBUG
library_path += "/../appindicator";
#endif
// AppIndicator
QLibrary library(library_path + "/libqcma_appindicator.so");
if(library.load())
create_tray = reinterpret_cast<TrayFunctionPointer>(library.resolve("createTrayIndicator"));
else
qWarning() << "Cannot load libqcma_appindicator plugin from" << library_path;
}
#endif
// else QSystemTrayIcon
return (create_tray != NULL) ? create_tray(obj_parent) : createTrayIndicator(obj_parent);
}
static void resolveSymbols()
{
static bool tried = false;
if ( !tried ) {
tried = true;
QLibrary library( "uxtheme" );
pIsAppThemed = (PtrIsAppThemed)library.resolve( "IsAppThemed" );
pGetCurrentThemeName = (PtrGetCurrentThemeName)library.resolve( "GetCurrentThemeName" );
}
}
static void initializeGTK()
{
QLibrary library(QLatin1String("libgtk-x11-2.0.so.0"));
if (library.load()) {
typedef void *(*gtk_init_check_ptr)(int*, char***);
gtk_init_check_ptr gtkInitCheck = reinterpret_cast<gtk_init_check_ptr>(library.resolve("gtk_init_check"));
// NOTE: We're using gtk_init_check() since gtk_init() calls exit() on failure.
if (gtkInitCheck)
(void) gtkInitCheck(0, 0);
}
}
/*!
Unloads the library and returns TRUE if the library could be
unloaded; otherwise returns FALSE.
This function is called by the destructor if autoUnload() is
enabled.
\sa resolve()
*/
bool QLibrary::unload()
{
if ( !d->pHnd )
return TRUE;
#if !defined(QT_NO_LIBRARY_UNLOAD)
if ( !d->freeLibrary() ) {
# if defined(QT_DEBUG_COMPONENT)
qWarning( "%s could not be unloaded", (const char*) QFile::encodeName(library()) );
# endif
return FALSE;
}
# if defined(QT_DEBUG_COMPONENT) && QT_DEBUG_COMPONENT == 2
qWarning( "%s has been unloaded", (const char*) QFile::encodeName(library()) );
# endif
d->pHnd = 0;
#endif
return TRUE;
}
TQString TDECModuleInfo::factoryName() const
{
if( d->factoryName.isEmpty() )
{
d->factoryName = _service->property("X-TDE-FactoryName", TQVariant::String).toString();
if ( d->factoryName.isEmpty() )
d->factoryName = library();
}
return d->factoryName;
}
/** Copied from QgsVectorLayer::setDataProvider
* TODO: Make it work in the generic environment
*
* TODO: Is this class really the best place to put a data provider loader?
* It seems more sensible to provide the code in one place rather than
* in qgsrasterlayer, qgsvectorlayer, serversourceselect, etc.
*/
QgsDataProvider *QgsProviderRegistry::provider( QString const & providerKey, QString const & dataSource )
{
// XXX should I check for and possibly delete any pre-existing providers?
// XXX How often will that scenario occur?
// load the plugin
QString lib = library( providerKey );
#ifdef TESTPROVIDERLIB
const char *cLib = lib.toUtf8();
// test code to help debug provider loading problems
// void *handle = dlopen(cLib, RTLD_LAZY);
void *handle = dlopen( cOgrLib, RTLD_LAZY | RTLD_GLOBAL );
if ( !handle )
{
QgsLogger::warning( "Error in dlopen" );
}
else
{
QgsDebugMsg( "dlopen suceeded" );
dlclose( handle );
}
#endif
// load the data provider
QLibrary myLib( lib );
QgsDebugMsg( "Library name is " + myLib.fileName() );
if ( !myLib.load() )
{
QgsMessageLog::logMessage( QObject::tr( "Failed to load %1: %2" ).arg( lib ).arg( myLib.errorString() ) );
return 0;
}
classFactoryFunction_t *classFactory = ( classFactoryFunction_t * ) cast_to_fptr( myLib.resolve( "classFactory" ) );
if ( !classFactory )
{
QgsDebugMsg( QString( "Failed to load %1: no classFactory method" ).arg( lib ) );
return 0;
}
QgsDataProvider *dataProvider = classFactory( &dataSource );
if ( !dataProvider )
{
QgsMessageLog::logMessage( QObject::tr( "Unable to instantiate the data provider plugin %1" ).arg( lib ) );
myLib.unload();
return 0;
}
QgsDebugMsg( QString( "Instantiated the data provider plugin: %1" ).arg( dataProvider->name() ) );
return dataProvider;
} // QgsProviderRegistry::setDataProvider
QFunctionPointer QgsProviderRegistry::function( QString const &providerKey,
QString const &functionName )
{
QString lib = library( providerKey );
if ( lib.isEmpty() )
return nullptr;
QLibrary myLib( library( providerKey ) );
QgsDebugMsg( "Library name is " + myLib.fileName() );
if ( myLib.load() )
{
return myLib.resolve( functionName.toLatin1().data() );
}
else
{
QgsDebugMsg( "Cannot load library: " + myLib.errorString() );
return nullptr;
}
}
KLibrary *KLibLoader::globalLibrary(const char *name)
{
KLibrary *tmp;
int old_dlopen_flag = d->dlopen_flag;
d->dlopen_flag |= RTLD_GLOBAL;
kdDebug(150) << "Loading the next library global with flag " << d->dlopen_flag << "." << endl;
tmp = library(name);
d->dlopen_flag = old_dlopen_flag;
return tmp;
}
bool QWindowsUser32DLL::initTouch()
{
if (!isTouchWindow && QSysInfo::windowsVersion() >= QSysInfo::WV_WINDOWS7) {
QSystemLibrary library(QStringLiteral("user32"));
isTouchWindow = (IsTouchWindow)(library.resolve("IsTouchWindow"));
registerTouchWindow = (RegisterTouchWindow)(library.resolve("RegisterTouchWindow"));
unregisterTouchWindow = (UnregisterTouchWindow)(library.resolve("UnregisterTouchWindow"));
getTouchInputInfo = (GetTouchInputInfo)(library.resolve("GetTouchInputInfo"));
closeTouchInputHandle = (CloseTouchInputHandle)(library.resolve("CloseTouchInputHandle"));
}
return isTouchWindow && registerTouchWindow && unregisterTouchWindow && getTouchInputInfo && closeTouchInputHandle;
}
void QWindowsUser32DLL::init()
{
QSystemLibrary library(QStringLiteral("user32"));
// MinGW (g++ 3.4.5) accepts only C casts.
setLayeredWindowAttributes = (SetLayeredWindowAttributes)(library.resolve("SetLayeredWindowAttributes"));
updateLayeredWindow = (UpdateLayeredWindow)(library.resolve("UpdateLayeredWindow"));
if (!setLayeredWindowAttributes || !updateLayeredWindow)
qFatal("This version of Windows is not supported (User32.dll is missing the symbols 'SetLayeredWindowAttributes', 'UpdateLayeredWindow').");
updateLayeredWindowIndirect = (UpdateLayeredWindowIndirect)(library.resolve("UpdateLayeredWindowIndirect"));
isHungAppWindow = (IsHungAppWindow)library.resolve("IsHungAppWindow");
}
void QMeeGoRuntime::initialize()
{
QFactoryLoader loader(QGraphicsSystemFactoryInterface_iid, QLatin1String("/graphicssystems"), Qt::CaseInsensitive);
QLibraryPrivate *libraryPrivate = loader.library(QLatin1String("meego"));
Q_ASSERT(libraryPrivate);
QLibrary library(libraryPrivate->fileName, libraryPrivate->fullVersion);
library.setLoadHints(QLibrary::ImprovedSearchHeuristics);
bool success = library.load();
if (success) {
qt_meego_image_to_egl_shared_image = (QMeeGoImageToEglSharedImageFunc) library.resolve("qt_meego_image_to_egl_shared_image");
qt_meego_pixmapdata_from_egl_shared_image = (QMeeGoPixmapDataFromEglSharedImageFunc) library.resolve("qt_meego_pixmapdata_from_egl_shared_image");
qt_meego_pixmapdata_with_gl_texture = (QMeeGoPixmapDataWithGLTextureFunc) library.resolve("qt_meego_pixmapdata_with_gl_texture");
qt_meego_destroy_egl_shared_image = (QMeeGoDestroyEGLSharedImageFunc) library.resolve("qt_meego_destroy_egl_shared_image");
qt_meego_update_egl_shared_image_pixmap = (QMeeGoUpdateEglSharedImagePixmapFunc) library.resolve("qt_meego_update_egl_shared_image_pixmap");
qt_meego_set_surface_fixed_size = (QMeeGoSetSurfaceFixedSizeFunc) library.resolve("qt_meego_set_surface_fixed_size");
qt_meego_set_surface_scaling = (QMeeGoSetSurfaceScalingFunc) library.resolve("qt_meego_set_surface_scaling");
qt_meego_set_translucent = (QMeeGoSetTranslucentFunc) library.resolve("qt_meego_set_translucent");
qt_meego_pixmapdata_with_new_live_texture = (QMeeGoPixmapDataWithNewLiveTextureFunc) library.resolve("qt_meego_pixmapdata_with_new_live_texture");
qt_meego_pixmapdata_from_live_texture_handle = (QMeeGoPixmapDataFromLiveTextureHandleFunc) library.resolve("qt_meego_pixmapdata_from_live_texture_handle");
qt_meego_live_texture_lock = (QMeeGoLiveTextureLockFunc) library.resolve("qt_meego_live_texture_lock");
qt_meego_live_texture_release = (QMeeGoLiveTextureReleaseFunc) library.resolve("qt_meego_live_texture_release");
qt_meego_live_texture_get_handle = (QMeeGoLiveTextureGetHandleFunc) library.resolve("qt_meego_live_texture_get_handle");
qt_meego_create_fence_sync = (QMeeGoCreateFenceSyncFunc) library.resolve("qt_meego_create_fence_sync");
qt_meego_destroy_fence_sync = (QMeeGoDestroyFenceSyncFunc) library.resolve("qt_meego_destroy_fence_sync");
qt_meego_invalidate_live_surfaces = (QMeeGoInvalidateLiveSurfacesFunc) library.resolve("qt_meego_invalidate_live_surfaces");
qt_meego_switch_to_raster = (QMeeGoSwitchToRasterFunc) library.resolve("qt_meego_switch_to_raster");
qt_meego_switch_to_meego = (QMeeGoSwitchToMeeGoFunc) library.resolve("qt_meego_switch_to_meego");
qt_meego_register_switch_callback = (QMeeGoRegisterSwitchCallbackFunc) library.resolve("qt_meego_register_switch_callback");
qt_meego_set_switch_policy = (QMeeGoSetSwitchPolicyFunc) library.resolve("qt_meego_set_switch_policy");
if (qt_meego_image_to_egl_shared_image && qt_meego_pixmapdata_from_egl_shared_image &&
qt_meego_pixmapdata_with_gl_texture && qt_meego_destroy_egl_shared_image && qt_meego_update_egl_shared_image_pixmap &&
qt_meego_set_surface_fixed_size && qt_meego_set_surface_scaling && qt_meego_set_translucent &&
qt_meego_pixmapdata_with_new_live_texture && qt_meego_pixmapdata_from_live_texture_handle &&
qt_meego_live_texture_lock && qt_meego_live_texture_release && qt_meego_live_texture_get_handle &&
qt_meego_create_fence_sync && qt_meego_destroy_fence_sync && qt_meego_invalidate_live_surfaces &&
qt_meego_switch_to_raster && qt_meego_switch_to_meego && qt_meego_register_switch_callback &&
qt_meego_set_switch_policy)
{
qDebug("Successfully resolved MeeGo graphics system: %s %s\n", qPrintable(libraryPrivate->fileName), qPrintable(libraryPrivate->fullVersion));
} else {
Q_ASSERT(false);
}
} else {
Q_ASSERT(false);
}
initialized = true;
}
