/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali-toolkit/internal/visuals/visual-url.h>
// EXTERNAL HEADERS
+#include <dali/devel-api/common/hash.h>
#include <cstring> // for toupper()
namespace Dali
const uint32_t length = url.size();
if((length > 7) && urlCStr[5] == ':' && urlCStr[6] == '/' && urlCStr[7] == '/')
{
- // https://
- if(('h' == tolower(urlCStr[0])) &&
- ('t' == tolower(urlCStr[1])) &&
- ('t' == tolower(urlCStr[2])) &&
- ('p' == tolower(urlCStr[3])) &&
- ('s' == tolower(urlCStr[4])))
+ // https:// or enbuf://
+ const char hOre = tolower(urlCStr[0]);
+ const char tOrn = tolower(urlCStr[1]);
+ const char tOrb = tolower(urlCStr[2]);
+ const char pOru = tolower(urlCStr[3]);
+ const char sOrf = tolower(urlCStr[4]);
+ if(('h' == hOre) &&
+ ('t' == tOrn) &&
+ ('t' == tOrb) &&
+ ('p' == pOru) &&
+ ('s' == sOrf))
{
return VisualUrl::REMOTE;
}
+ if(('e' == hOre) &&
+ ('n' == tOrn) &&
+ ('b' == tOrb) &&
+ ('u' == pOru) &&
+ ('f' == sOrf))
+ {
+ return VisualUrl::BUFFER;
+ }
}
else if((length > 6) && urlCStr[4] == ':' && urlCStr[5] == '/' && urlCStr[6] == '/')
{
else if((length > 5) && urlCStr[3] == ':' && urlCStr[4] == '/' && urlCStr[5] == '/')
{
// ftp:// or ssh://
- const char fOrS = tolower(urlCStr[0]);
- if(('f' == fOrS) || ('s' == fOrS))
+ const char fOrs = tolower(urlCStr[0]);
+ const char tOrs = tolower(urlCStr[1]);
+ const char pOrh = tolower(urlCStr[2]);
+ if(('f' == fOrs) &&
+ ('t' == tOrs) &&
+ ('p' == pOrh))
{
- const char tOrs = tolower(urlCStr[1]);
- if(('t' == tOrs) || ('s' == tOrs))
- {
- const char pOrh = tolower(urlCStr[2]);
- if(('p' == pOrh) || ('h' == pOrh))
- {
- return VisualUrl::REMOTE;
- }
- }
+ return VisualUrl::REMOTE;
+ }
+ if(('s' == fOrs) &&
+ ('s' == tOrs) &&
+ ('h' == pOrh))
+ {
+ return VisualUrl::REMOTE;
}
}
return VisualUrl::LOCAL;
VisualUrl::Type ResolveType(const std::string& url)
{
// if only one char in string, can only be regular image
- const std::size_t count = url.size();
+ const std::size_t count = url.size();
+ VisualUrl::Type returnType = VisualUrl::REGULAR_IMAGE;
if(count > 0)
{
// parsing from the end for better chance of early outs
char GIF[4] = {'f', 'i', 'g', '.'};
char WEBP[5] = {'p', 'b', 'e', 'w', '.'};
char JSON[5] = {'n', 'o', 's', 'j', '.'};
+ char TVG[4] = {'g', 'v', 't', '.'};
unsigned int svgScore = 0;
+ unsigned int tvgScore = 0;
unsigned int gifScore = 0;
unsigned int webpScore = 0;
unsigned int jsonScore = 0;
return VisualUrl::SVG;
}
}
+ if((offsetFromEnd < sizeof(TVG)) && (currentChar == TVG[offsetFromEnd]))
+ {
+ // early out if TVG as can't be used in N patch for now
+ if(++tvgScore == sizeof(TVG))
+ {
+ return VisualUrl::TVG;
+ }
+ }
if((offsetFromEnd < sizeof(GIF)) && (currentChar == GIF[offsetFromEnd]))
{
- // early out if GIF as can't be used in N patch for now
+ //find type, but need to be check used in N patch
if(++gifScore == sizeof(GIF))
{
- return VisualUrl::GIF;
+ returnType = VisualUrl::GIF;
}
}
if((offsetFromEnd < sizeof(WEBP)) && (currentChar == WEBP[offsetFromEnd]))
{
- // early out if WEBP as can't be used in N patch for now
if(++webpScore == sizeof(WEBP))
{
- return VisualUrl::WEBP;
+ //find type, but need to be check used in N patch
+ returnType = VisualUrl::WEBP;
}
}
if((offsetFromEnd < sizeof(JSON)) && (currentChar == JSON[offsetFromEnd]))
else
{
// early out, not a valid N/9-patch URL
- return VisualUrl::REGULAR_IMAGE;
+ return returnType;
}
break;
}
else
{
// early out, not a valid N/9-patch URL
- return VisualUrl::REGULAR_IMAGE;
+ return returnType;
}
break;
}
}
}
// if we got here it is a regular image
- return VisualUrl::REGULAR_IMAGE;
+ return returnType;
}
} // namespace
VisualUrl::VisualUrl()
: mUrl(),
mType(VisualUrl::REGULAR_IMAGE),
- mLocation(VisualUrl::LOCAL)
+ mLocation(VisualUrl::LOCAL),
+ mUrlHash(0ull)
{
}
VisualUrl::VisualUrl(const std::string& url)
: mUrl(url),
mType(VisualUrl::REGULAR_IMAGE),
- mLocation(VisualUrl::LOCAL)
+ mLocation(VisualUrl::LOCAL),
+ mUrlHash(0ull)
{
if(!url.empty())
{
mLocation = ResolveLocation(url);
- if(VisualUrl::TEXTURE != mLocation)
+ if(VisualUrl::TEXTURE != mLocation && VisualUrl::BUFFER != mLocation)
{
- // TEXTURE location url doesn't need type resolving, REGULAR_IMAGE is fine
+ // TEXTURE and BUFFER location url doesn't need type resolving, REGULAR_IMAGE is fine
mType = ResolveType(url);
}
}
VisualUrl::VisualUrl(const VisualUrl& url)
: mUrl(url.mUrl),
mType(url.mType),
- mLocation(url.mLocation)
+ mLocation(url.mLocation),
+ mUrlHash(url.mUrlHash)
+{
+}
+
+VisualUrl::~VisualUrl()
{
}
mUrl = url.mUrl;
mType = url.mType;
mLocation = url.mLocation;
+ mUrlHash = url.mUrlHash;
}
return *this;
}
return mUrl;
}
+const std::uint64_t& VisualUrl::GetUrlHash() const
+{
+ return DALI_UNLIKELY(mUrlHash == 0) ? (mUrlHash = Dali::CalculateHash(mUrl)) : mUrlHash;
+}
+
VisualUrl::Type VisualUrl::GetType() const
{
return mType;
return mLocation == VisualUrl::LOCAL;
}
+bool VisualUrl::IsBufferResource() const
+{
+ return mLocation == VisualUrl::BUFFER;
+}
+
std::string VisualUrl::GetLocation() const
{
- const auto location = mUrl.find("://");
- if(std::string::npos != location)
- {
- return mUrl.substr(location + 3u); // 3 characters forwards from the start of ://
- }
- return mUrl;
+ return GetLocation(mUrl);
}
std::string VisualUrl::CreateTextureUrl(const std::string& location)
return "dali://" + location;
}
+std::string VisualUrl::CreateBufferUrl(const std::string& location)
+{
+ return "enbuf://" + location;
+}
+
+VisualUrl::ProtocolType VisualUrl::GetProtocolType(const std::string& url)
+{
+ return ResolveLocation(url);
+}
+
+std::string VisualUrl::GetLocation(const std::string& url)
+{
+ const auto location = url.find("://");
+ if(std::string::npos != location)
+ {
+ return url.substr(location + 3u); // 3 characters forwards from the start of ://
+ }
+ return url;
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff