Exemple #1
0
QString DesignerUtils::getSchemaFileFilter(bool any, bool addOldExt) {
    QStringList exts(WorkflowUtils::WD_FILE_EXTENSIONS);
    if(addOldExt) {
        exts << WorkflowUtils::WD_XML_FORMAT_EXTENSION;
    }
    return DialogUtils::prepareFileFilter(WorkflowUtils::tr("UGENE workflow documents"), exts, any);
}
Exemple #2
0
void nglContext::Dump(uint Level) const
{
  nglContextInfo info;

  if (!GetContextInfo(info)) return;
  info.Dump(Level);
  nglString version((const char*)glGetString(GL_VERSION));
  nglString renderer((const char*)glGetString(GL_RENDERER));
  nglString vendor((const char*)glGetString(GL_VENDOR));
  nglString exts((const char*)glGetString(GL_EXTENSIONS));
#if (!defined _UIKIT_) && (!defined _ANDROID_)
  nglString sl((const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
#endif
  
  NGL_LOG(_T("context"), Level, _T("  OpenGL Version: %s"), version.GetChars());
  NGL_LOG(_T("context"), Level, _T("  Renderer      : %s"),        renderer.GetChars());
  NGL_LOG(_T("context"), Level, _T("  Vendor        : %s"),        vendor.GetChars());
#if (!defined _UIKIT_) && (!defined _ANDROID_)
  NGL_LOG(_T("context"), Level, _T("  GLSL version  : %s"),        sl.GetChars());
#endif
  NGL_LOG(_T("context"), Level, _T("  Extensions    :"));
  
  std::vector<nglString> tokens;
  exts.Tokenize(tokens);
  for (int32 i = 0; i < tokens.size(); i++)
  {
    NGL_LOG(_T("context"), Level, _T("    %3d %s"), i, tokens[i].GetChars());
  }
  
}
Exemple #3
0
FileFinder::FileFinder(
    bool recursiveScan,
    const string_t& rootPath,
    const string_t& extensions /*= ""*/,
    const string_t& ignoredFiles /*= ""*/ )
    : rootPath_(rootPath)
    , recursiveScan_(recursiveScan)
    , numDirs_(0)
{
    /// have normalized string
    Poco::Path tmp(rootPath);
    rootPath_ = tmp.toString();

    Poco::StringTokenizer tokenizer(extensions, ";",
                                    Poco::StringTokenizer::TOK_IGNORE_EMPTY |
                                    Poco::StringTokenizer::TOK_TRIM);

    std::set<string_t> exts(tokenizer.begin(), tokenizer.end());

    Poco::StringTokenizer ignoreToks(
        ignoredFiles, ";",
        Poco::StringTokenizer::TOK_IGNORE_EMPTY |
        Poco::StringTokenizer::TOK_TRIM);

    for (auto it = ignoreToks.begin(); it != ignoreToks.end(); ++it) {
        /// the reason we are inserting paths through Poco::Path is
        /// that it will let us have paths similar path in each platform
        /// in windows with '\', in linux '/'
        ignore_.insert(Poco::Path(*it).toString());
    }

    performScan(rootPath_, exts);
}
Exemple #4
0
/**
 * \brief Flattens the caps specification into the set of 'simple' 
 * specifications.
 * A 'simple' specification is a specification with exactly one extension,
 * or with the version number as the extension.
 *
 * Example: A caps specification with node=http://psi-im.org, version=0.10,
 * and ext='achat vchat' would be expanded into the following list of specs:
 *	node=http://psi-im.org, ver=0.10, ext=0.10
 *	node=http://psi-im.org, ver=0.10, ext=achat
 *	node=http://psi-im.org, ver=0.10, ext=vchat
 */
CapsSpecs CapsSpec::flatten() const 
{
	CapsSpecs l;
	l.append(CapsSpec(node(),version(),version()));
	QStringList exts(extensions().split(" ",QString::SkipEmptyParts));
	for (QStringList::ConstIterator i = exts.begin(); i != exts.end(); ++i) {
		l.append(CapsSpec(node(),version(),*i));
	}
	return l;
}
Exemple #5
0
/// Called from constructor to fill file extensions
void FacilityInfo::fillExtensions(const Poco::XML::Element *elem) {
  std::string extsStr = elem->getAttribute("FileExtensions");
  if (extsStr.empty()) {
    g_log.error("No file extensions defined");
    throw std::runtime_error("No file extensions defined");
  }
  typedef Poco::StringTokenizer tokenizer;
  tokenizer exts(extsStr, ",",
                 tokenizer::TOK_IGNORE_EMPTY | tokenizer::TOK_TRIM);
  for (tokenizer::Iterator it = exts.begin(); it != exts.end(); ++it) {
    addExtension(*it);
  }
}
	//---------------------------------------------------------------------
	void FreeImageCodec::startup(void)
	{
		FreeImage_Initialise(false);

		LogManager::getSingleton().logMessage(
			LML_NORMAL,
			"FreeImage version: " + String(FreeImage_GetVersion()));
		LogManager::getSingleton().logMessage(
			LML_NORMAL,
			FreeImage_GetCopyrightMessage());

		// Register codecs
		StringUtil::StrStreamType strExt;
		strExt << "Supported formats: ";
		bool first = true;
		for (int i = 0; i < FreeImage_GetFIFCount(); ++i)
		{

			// Skip DDS codec since FreeImage does not have the option 
			// to keep DXT data compressed, we'll use our own codec
			if ((FREE_IMAGE_FORMAT)i == FIF_DDS)
				continue;
			
			String exts(FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i));
			if (!first)
			{
				strExt << ",";
			}
			first = false;
			strExt << exts;
			
			// Pull off individual formats (separated by comma by FI)
			StringVector extsVector = StringUtil::split(exts, ",");
			for (StringVector::iterator v = extsVector.begin(); v != extsVector.end(); ++v)
			{
				ImageCodec* codec = OGRE_NEW FreeImageCodec(*v, i);
				msCodecList.push_back(codec);
				Codec::registerCodec(codec);
			}
		}
		LogManager::getSingleton().logMessage(
			LML_NORMAL,
			strExt.str());

		// Set error handler
		FreeImage_SetOutputMessage(FreeImageErrorHandler);




	}
Exemple #7
0
bool DeviceContext::CheckCapability(std::string cap) {
  if (backend_ == BACKEND_OpenCL) {
#ifdef USE_GREENTEA
    viennacl::ocl::context &ctx = viennacl::ocl::get_context(id_);

    size_t size;
    size_t max_size = 1024 * 1024;
    clGetDeviceInfo(ctx.devices()[0].id(), CL_DEVICE_EXTENSIONS,
                    0, NULL, &size);

    // Cap at 1 MB to capture faulty OpenCL implementations (nVidia)
    std::vector<char> exts(std::min(size, max_size));

    clGetDeviceInfo(ctx.devices()[0].id(), CL_DEVICE_EXTENSIONS,
                    size, &(exts[0]), NULL);

    std::string extsstr(&(exts[0]));
    return extsstr.find(cap) != std::string::npos;
#endif
  }
  return true;
}
Exemple #8
0
void
GLLibraryEGL::InitExtensionsFromDisplay(EGLDisplay eglDisplay)
{
    std::vector<nsCString> driverExtensionList;

    const char* rawExts = (const char*)fQueryString(eglDisplay, LOCAL_EGL_EXTENSIONS);
    if (rawExts) {
        nsDependentCString exts(rawExts);
        SplitByChar(exts, ' ', &driverExtensionList);
    } else {
        NS_WARNING("Failed to load EGL extension list!");
    }

    const bool shouldDumpExts = GLContext::ShouldDumpExts();
    if (shouldDumpExts) {
        printf_stderr("%i EGL driver extensions: (*: recognized)\n",
                      (uint32_t)driverExtensionList.size());
    }

    MarkBitfieldByStrings(driverExtensionList, shouldDumpExts, sEGLExtensionNames,
                          &mAvailableExtensions);
}
Exemple #9
0
FreeImageImageCodec::FreeImageImageCodec()
    : ImageCodec("FreeImageCodec - FreeImage based image codec")
{
    FreeImage_Initialise(true);
    FreeImage_SetOutputMessage(&FreeImageErrorHandler);

    // Getting extensions
    for (int i = 0; i < FreeImage_GetFIFCount(); ++i)
    {
        String exts(FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i));

        // Replace commas with spaces
        for (size_t i = 0; i < exts.length(); ++i)
            if (exts[i] == ',')
                exts[i] = ' ';

        // Add space after existing extensions
        if (!d_supportedFormat.empty())
            d_supportedFormat += ' ';

        d_supportedFormat += exts;
    }
}
Exemple #10
0
nuiGLPainter::nuiGLPainter(nglContext* pContext, const nuiRect& rRect)
: nuiPainter(rRect, pContext)
{
  mCanRectangleTexture = 0;
  mTextureTarget = GL_TEXTURE_2D;
  mTwoPassBlend = false;
  mDefaultFramebuffer = 0;
  mDefaultRenderbuffer = 0;

  mpContext = pContext;
  if (mpContext)
  {
    mpContext->BeginSession();
    const char* ext0 = (const char*)glGetString(GL_EXTENSIONS);
    nglString exts(ext0);
    //NGL_OUT(_T("Extensions: %ls\n"), exts.GetChars());


    mpContext->CheckExtension(_T("GL_VERSION_1_2"));
    nuiCheckForGLErrors();
    mpContext->CheckExtension(_T("GL_VERSION_1_3"));
    nuiCheckForGLErrors();
    mpContext->CheckExtension(_T("GL_VERSION_1_4"));
    nuiCheckForGLErrors();
    mpContext->CheckExtension(_T("GL_VERSION_1_5"));
    nuiCheckForGLErrors();
    mpContext->CheckExtension(_T("GL_ARB_vertex_buffer_object"));
    nuiCheckForGLErrors();
    mpContext->CheckExtension(_T("GL_EXT_framebuffer_object"));
    nuiCheckForGLErrors();

    mpContext->CheckExtension(_T("GL_ARB_framebuffer_object"));
    nuiCheckForGLErrors();

    if (mpContext->CheckExtension(_T("GL_ARB_texture_non_power_of_two")))
    {
      mCanRectangleTexture = 1;
    }
    else if (mpContext->CheckExtension(_T("GL_EXT_texture_rectangle")) || mpContext->CheckExtension(_T("GL_ARB_texture_rectangle")) || mpContext->CheckExtension(_T("GL_NV_texture_rectangle")))
    {
      mCanRectangleTexture = 2;
    }
    //mCanRectangleTexture = 0;

    
    if (!mActiveContexts)
    {
      glAAInit();
      nuiCheckForGLErrors();
    }


    nuiCheckForGLErrors();
  }

#ifdef _OPENGL_ES_
//  mDefaultFramebuffer = 0;
//  mDefaultRenderbuffer = 0;
  glGetIntegerv(GL_FRAMEBUFFER_BINDING_NUI, &mDefaultFramebuffer);
  glGetIntegerv(GL_RENDERBUFFER_BINDING_NUI, (GLint *) &mDefaultRenderbuffer);
#endif

  mActiveContexts++;
}