+2014-09-25 Csaba Osztrogonác <ossy@webkit.org>
+
+ Remove WinCE port from trunk
+ https://bugs.webkit.org/show_bug.cgi?id=136951
+
+ Reviewed by Alex Christensen.
+
+ * Source/cmake/OptionsWinCE.cmake: Removed.
+ * Source/cmake/WebKitPackaging.cmake:
+
2014-09-17 Renato Nagy <rnagy@inf.u-szeged.hu>
[EFL][GTK] Remove WebKit1 related codes
+2014-09-25 Csaba Osztrogonác <ossy@webkit.org>
+
+ Remove WinCE port from trunk
+ https://bugs.webkit.org/show_bug.cgi?id=136951
+
+ Reviewed by Alex Christensen.
+
+ * assembler/ARMAssembler.h:
+ (JSC::ARMAssembler::cacheFlush):
+ * assembler/ARMv7Assembler.h:
+ (JSC::ARMv7Assembler::cacheFlush):
+ * config.h:
+ * heap/MachineStackMarker.cpp:
+ (JSC::MachineThreads::gatherFromCurrentThread):
+ (JSC::MachineThreads::gatherFromOtherThread):
+ (JSC::swapIfBackwards): Deleted.
+ * jit/ExecutableAllocator.h:
+ * jsc.cpp:
+ (main):
+ * runtime/DateConstructor.cpp:
+ * runtime/Options.cpp:
+ (JSC::overrideOptionWithHeuristic):
+ * runtime/VM.cpp:
+ (JSC::VM::VM):
+ * testRegExp.cpp:
+ (main):
+ * tools/CodeProfiling.cpp:
+ (JSC::CodeProfiling::notifyAllocator):
+
2014-09-24 Brian J. Burg <burg@cs.washington.edu>
Web Inspector: subtract elapsed time while debugger is paused from profile nodes
linuxPageFlush(current, current + page);
linuxPageFlush(current, end);
-#elif OS(WINCE)
- CacheRangeFlush(code, size, CACHE_SYNC_ALL);
#else
#error "The cacheFlush support is missing on this platform."
#endif
linuxPageFlush(current, current + page);
linuxPageFlush(current, end);
-#elif OS(WINCE)
- CacheRangeFlush(code, size, CACHE_SYNC_ALL);
#else
#error "The cacheFlush support is missing on this platform."
#endif
#define WINVER 0x0502
#endif
-#if !COMPILER(MSVC7_OR_LOWER) && !OS(WINCE)
+#if !COMPILER(MSVC7_OR_LOWER)
// We need to define this before the first #include of stdlib.h or it won't contain rand_s.
#ifndef _CRT_RAND_S
#define _CRT_RAND_S
#endif
-#endif // !COMPILER(MSVC7_OR_LOWER) && !OS(WINCE)
+#endif // !COMPILER(MSVC7_OR_LOWER
#endif // OS(WINDOWS)
namespace JSC {
-static inline void swapIfBackwards(void*& begin, void*& end)
-{
-#if OS(WINCE)
- if (begin <= end)
- return;
- std::swap(begin, end);
-#else
-UNUSED_PARAM(begin);
-UNUSED_PARAM(end);
-#endif
-}
-
#if OS(DARWIN)
typedef mach_port_t PlatformThread;
#elif OS(WINDOWS)
void* registersBegin = ®isters;
void* registersEnd = reinterpret_cast<void*>(roundUpToMultipleOf<sizeof(void*)>(reinterpret_cast<uintptr_t>(®isters + 1)));
- swapIfBackwards(registersBegin, registersEnd);
conservativeRoots.add(registersBegin, registersEnd, jitStubRoutines, codeBlocks);
void* stackBegin = stackCurrent;
void* stackEnd = wtfThreadData().stack().origin();
- swapIfBackwards(stackBegin, stackEnd);
conservativeRoots.add(stackBegin, stackEnd, jitStubRoutines, codeBlocks);
}
void* stackPointer = otherThreadStackPointer(regs);
void* stackBase = thread->stackBase;
- swapIfBackwards(stackPointer, stackBase);
stackPointer = reinterpret_cast<void*>(WTF::roundUpToMultipleOf<sizeof(void*)>(reinterpret_cast<uintptr_t>(stackPointer)));
conservativeRoots.add(stackPointer, stackBase, jitStubRoutines, codeBlocks);
#include <unistd.h>
#endif
-#if OS(WINCE)
-// From pkfuncs.h (private header file from the Platform Builder)
-#define CACHE_SYNC_ALL 0x07F
-extern "C" __declspec(dllimport) void CacheRangeFlush(LPVOID pAddr, DWORD dwLength, DWORD dwFlags);
-#endif
-
#define JIT_ALLOCATOR_LARGE_ALLOC_SIZE (pageSize() * 4)
#if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
#include <signal.h>
#endif
-#if COMPILER(MSVC) && !OS(WINCE)
+#if COMPILER(MSVC)
#include <crtdbg.h>
#include <mmsystem.h>
#include <windows.h>
// be in a separate main function because the jscmain function requires object
// unwinding.
-#if COMPILER(MSVC) && !defined(_DEBUG) && !OS(WINCE)
+#if COMPILER(MSVC) && !defined(_DEBUG)
#define TRY __try {
#define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
#else
#endif
#if OS(WINDOWS)
-#if !OS(WINCE)
// Cygwin calls ::SetErrorMode(SEM_FAILCRITICALERRORS), which we will inherit. This is bad for
// testing/debugging, as it causes the post-mortem debugger not to be invoked. We reset the
// error mode here to work around Cygwin's behavior. See <http://webkit.org/b/55222>.
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
-#endif
#endif
timeBeginPeriod(1);
#endif
JSC::initializeThreading();
-#if !OS(WINCE)
if (char* timeoutString = getenv("JSC_timeout")) {
if (sscanf(timeoutString, "%lf", &s_desiredTimeout) != 1) {
dataLog(
} else
createThread(timeoutThreadMain, 0, "jsc Timeout Thread");
}
-#endif
#if PLATFORM(IOS)
Options::crashIfCantAllocateJITMemory() = true;
#include "JSReplayInputs.h"
#endif
-#if OS(WINCE)
-extern "C" time_t time(time_t* timer); // Provided by libce.
-#endif
-
#if HAVE(SYS_TIME_H)
#include <sys/time.h>
#endif
template<typename T>
bool overrideOptionWithHeuristic(T& variable, const char* name)
{
-#if !OS(WINCE)
const char* stringValue = getenv(name);
if (!stringValue)
return false;
return true;
fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
-#endif
return false;
}
m_perBytecodeProfiler = adoptPtr(new Profiler::Database(*this));
StringPrintStream pathOut;
-#if !OS(WINCE)
const char* profilerPath = getenv("JSC_PROFILER_PATH");
if (profilerPath)
pathOut.print(profilerPath, "/");
-#endif
pathOut.print("JSCProfile-", getCurrentProcessID(), "-", m_perBytecodeProfiler->databaseID(), ".json");
m_perBytecodeProfiler->registerToSaveAtExit(pathOut.toCString().data());
}
#include <sys/time.h>
#endif
-#if COMPILER(MSVC) && !OS(WINCE)
+#if COMPILER(MSVC)
#include <crtdbg.h>
#include <mmsystem.h>
#include <windows.h>
// be in a separate main function because the realMain function requires object
// unwinding.
-#if COMPILER(MSVC) && !defined(_DEBUG) && !OS(WINCE)
+#if COMPILER(MSVC) && !defined(_DEBUG)
#define TRY __try {
#define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
#else
int main(int argc, char** argv)
{
#if OS(WINDOWS)
-#if !OS(WINCE)
// Cygwin calls ::SetErrorMode(SEM_FAILCRITICALERRORS), which we will inherit. This is bad for
// testing/debugging, as it causes the post-mortem debugger not to be invoked. We reset the
// error mode here to work around Cygwin's behavior. See <http://webkit.org/b/55222>.
::SetErrorMode(0);
-#endif
#if defined(_DEBUG)
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
void CodeProfiling::notifyAllocator(WTF::MetaAllocator* allocator)
{
-#if !OS(WINCE)
// Check for JSC_CODE_PROFILING.
const char* codeProfilingMode = getenv("JSC_CODE_PROFILING");
if (!codeProfilingMode)
ASSERT(!s_tracker);
s_tracker = new WTF::MetaAllocatorTracker();
allocator->trackAllocations(s_tracker);
-#endif
}
void* CodeProfiling::getOwnerUIDForPC(void* address)
+2014-09-25 Csaba Osztrogonác <ossy@webkit.org>
+
+ Remove WinCE port from trunk
+ https://bugs.webkit.org/show_bug.cgi?id=136951
+
+ Reviewed by Alex Christensen.
+
+ * config.h:
+ * wtf/Assertions.cpp:
+ * wtf/Assertions.h:
+ * wtf/Atomics.h:
+ (WTF::weakCompareAndSwap):
+ * wtf/CurrentTime.cpp:
+ (WTF::lowResUTCTime):
+ * wtf/DataLog.cpp:
+ * wtf/DateMath.cpp:
+ (WTF::getLocalTime):
+ (WTF::calculateDSTOffset):
+ * wtf/FastMalloc.cpp:
+ * wtf/FeatureDefines.h:
+ * wtf/OSAllocator.h:
+ (WTF::OSAllocator::decommitAndRelease):
+ * wtf/Platform.h:
+ * wtf/PlatformWin.cmake:
+ * wtf/RAMSize.cpp:
+ (WTF::computeRAMSize):
+ * wtf/RandomNumberSeed.h:
+ (WTF::initializeRandomNumberGenerator):
+ * wtf/StackBounds.cpp:
+ (WTF::StackBounds::initialize):
+ * wtf/StackBounds.h:
+ (WTF::StackBounds::isGrowingDownward):
+ * wtf/StdLibExtras.h:
+ (wtf_bsearch): Deleted.
+ * wtf/StringExtras.h:
+ (strnicmp): Deleted.
+ (stricmp): Deleted.
+ (strdup): Deleted.
+ * wtf/ThreadSpecific.h:
+ * wtf/ThreadingWin.cpp:
+ (WTF::createThreadInternal):
+ * wtf/WindowsExtras.h:
+ (WTF::getRegistryValue):
+ (WTF::getWindowPointer):
+ (WTF::setWindowPointer):
+ * wtf/dtoa/utils.h:
+ * wtf/text/WTFString.cpp:
+ (WTF::String::format):
+
2014-09-24 Geoffrey Garen <ggaren@apple.com>
Do the bmalloc.
#endif
#endif
-#if !COMPILER(MSVC7_OR_LOWER) && !OS(WINCE)
+#if !COMPILER(MSVC7_OR_LOWER)
// We need to define this before the first #include of stdlib.h or it won't contain rand_s.
#ifndef _CRT_RAND_S
#define _CRT_RAND_S
#endif
#endif // USE(CF)
-#if COMPILER(MSVC) && !OS(WINCE)
+#if COMPILER(MSVC)
#include <crtdbg.h>
#endif
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
-#if OS(WINCE)
- // WinCE only supports wide chars
- wchar_t* wideBuffer = (wchar_t*)malloc(size * sizeof(wchar_t));
- if (wideBuffer == NULL)
- break;
- for (unsigned int i = 0; i < size; ++i) {
- if (!(wideBuffer[i] = buffer[i]))
- break;
- }
- OutputDebugStringW(wideBuffer);
- free(wideBuffer);
-#else
OutputDebugStringA(buffer);
-#endif
free(buffer);
break;
}
static void printCallSite(const char* file, int line, const char* function)
{
-#if OS(WINDOWS) && !OS(WINCE) && defined(_DEBUG)
+#if OS(WINDOWS) && defined(_DEBUG)
_CrtDbgReport(_CRT_WARN, file, line, NULL, "%s\n", function);
#else
// By using this format, which matches the format used by MSVC for compiler errors, developers
{
#if OS(DARWIN) || (OS(LINUX) && !defined(__UCLIBC__))
*size = backtrace(stack, *size);
-#elif OS(WINDOWS) && !OS(WINCE)
+#elif OS(WINDOWS)
// The CaptureStackBackTrace function is available in XP, but it is not defined
// in the Windows Server 2003 R2 Platform SDK. So, we'll grab the function
// through GetProcAddress.
Expressions inside them are evaluated in debug builds only.
*/
-#if OS(WINCE)
-/* FIXME: We include this here only to avoid a conflict with the ASSERT macro. */
-#include <windows.h>
-#undef min
-#undef max
-#undef ERROR
-#endif
-
#if OS(WINDOWS)
/* FIXME: Change to use something other than ASSERT to avoid this conflict with the underlying platform */
#undef ASSERT
#if OS(WINDOWS)
inline bool weakCompareAndSwap(volatile unsigned* location, unsigned expected, unsigned newValue)
{
-#if OS(WINCE)
- return InterlockedCompareExchange(reinterpret_cast<LONG*>(const_cast<unsigned*>(location)), static_cast<LONG>(newValue), static_cast<LONG>(expected)) == static_cast<LONG>(expected);
-#else
return InterlockedCompareExchange(reinterpret_cast<LONG volatile*>(location), static_cast<LONG>(newValue), static_cast<LONG>(expected)) == static_cast<LONG>(expected);
-#endif
}
inline bool weakCompareAndSwap(void*volatile* location, void* expected, void* newValue)
{
FILETIME fileTime;
-#if OS(WINCE)
- GetCurrentFT(&fileTime);
-#else
GetSystemTimeAsFileTime(&fileTime);
-#endif
// As per Windows documentation for FILETIME, copy the resulting FILETIME structure to a
// ULARGE_INTEGER structure using memcpy (using memcpy instead of direct assignment can
#include <unistd.h>
#endif
-#if OS(WINCE)
-#ifndef _IONBF
-#define _IONBF 0x0004
-#endif
-#endif
-
#define DATA_LOG_TO_FILE 0
// Set to 1 to use the temp directory from confstr instead of hardcoded directory.
{0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}
};
-#if !OS(WINCE)
static inline void getLocalTime(const time_t* localTime, struct tm* localTM)
{
#if COMPILER(MINGW)
localtime_r(localTime, localTM);
#endif
}
-#endif
bool isLeapYear(int year)
{
*/
static double calculateDSTOffset(time_t localTime, double utcOffset)
{
-#if OS(WINCE)
- UNUSED_PARAM(localTime);
- UNUSED_PARAM(utcOffset);
- return 0;
-#elif OS(WINDOWS)
+#if OS(WINDOWS)
FILETIME utcFileTime;
UnixTimeToFileTime(localTime, &utcFileTime);
SYSTEMTIME utcSystemTime, localSystemTime;
#if OS(WINDOWS)
-// TLS_OUT_OF_INDEXES is not defined on WinCE.
-#ifndef TLS_OUT_OF_INDEXES
-#define TLS_OUT_OF_INDEXES 0xffffffff
-#endif
-
static DWORD isForibiddenTlsIndex = TLS_OUT_OF_INDEXES;
static const LPVOID kTlsAllowValue = reinterpret_cast<LPVOID>(0); // Must be zero.
static const LPVOID kTlsForbiddenValue = reinterpret_cast<LPVOID>(1);
#endif /* PLATFORM(MAC) */
/* --------- Apple Windows port --------- */
-#if PLATFORM(WIN) && !OS(WINCE) && !PLATFORM(WIN_CAIRO)
+#if PLATFORM(WIN) && !PLATFORM(WIN_CAIRO)
#if !defined(ENABLE_FULLSCREEN_API)
#define ENABLE_FULLSCREEN_API 1
#define ENABLE_WEBGL 1
#endif
-#endif /* PLATFORM(WIN) && !OS(WINCE) && !PLATFORM(WIN_CAIRO) */
-
-/* --------- WinCE port --------- */
-/* WinCE port is a specialization of PLATFORM(WIN). */
-/* PLATFORM(WIN) is always enabled when building for the WinCE port. */
-#if PLATFORM(WIN) && OS(WINCE)
-
-#if !defined(ENABLE_DRAG_SUPPORT)
-#define ENABLE_DRAG_SUPPORT 0
-#endif
-
-#if !defined(ENABLE_FTPDIR)
-#define ENABLE_FTPDIR 0
-#endif
-
-#if !defined(ENABLE_INSPECTOR)
-#define ENABLE_INSPECTOR 0
-#endif
-
-#endif /* PLATFORM(WIN) && OS(WINCE) */
+#endif /* PLATFORM(WIN) && !PLATFORM(WIN_CAIRO) */
/* --------- Windows CAIRO port --------- */
/* PLATFORM(WIN_CAIRO) is a specialization of PLATFORM(WIN). */
// committing/decommitting the entire region additional parameters allow a subregion to be
// specified.
WTF_EXPORT_PRIVATE static void* reserveAndCommit(size_t reserveSize, size_t commitSize, Usage = UnknownUsage, bool writable = true, bool executable = false);
- static void decommitAndRelease(void* releaseBase, size_t releaseSize, void* decommitBase, size_t decommitSize);
// Reallocate an existing, committed allocation.
// The prior allocation must be fully comitted, and the new size will also be fully committed.
return base;
}
-inline void OSAllocator::decommitAndRelease(void* releaseBase, size_t releaseSize, void* decommitBase, size_t decommitSize)
+inline void OSAllocator::decommitAndRelease(void* releaseBase, size_t releaseSize)
{
- ASSERT(decommitBase >= releaseBase && (static_cast<char*>(decommitBase) + decommitSize) <= (static_cast<char*>(releaseBase) + releaseSize));
-#if OS(WINCE)
- // On most platforms we can actually skip this final decommit; releasing the VM will
- // implicitly decommit any physical memory in the region. This is not true on WINCE.
- decommit(decommitBase, decommitSize);
-#else
- UNUSED_PARAM(decommitBase);
- UNUSED_PARAM(decommitSize);
-#endif
releaseDecommitted(releaseBase, releaseSize);
}
-inline void OSAllocator::decommitAndRelease(void* base, size_t size)
-{
- decommitAndRelease(base, size, base, size);
-}
-
template<typename T>
inline T* OSAllocator::reallocateCommitted(T* oldBase, size_t oldSize, size_t newSize, Usage usage, bool writable, bool executable)
{
vm_deallocate(current_task(), reinterpret_cast<vm_address_t>(tmp.base()), tmp.size());
#else
ASSERT(tmp.m_reservation.contains(tmp.base(), tmp.size()));
- OSAllocator::decommitAndRelease(tmp.m_reservation.base(), tmp.m_reservation.size(), tmp.base(), tmp.size());
+ OSAllocator::decommitAndRelease(tmp.m_reservation.base(), tmp.m_reservation.size());
#endif
}
#define WTF_OS_SOLARIS 1
#endif
-/* OS(WINCE) - Windows CE; note that for this platform OS(WINDOWS) is also defined */
-#if defined(_WIN32_WCE)
-#define WTF_OS_WINCE 1
-#endif
-
/* OS(WINDOWS) - Any version of Windows */
#if defined(WIN32) || defined(_WIN32)
#define WTF_OS_WINDOWS 1
#endif /* OS(DARWIN) */
-#if OS(WINDOWS) && !OS(WINCE)
+#if OS(WINDOWS)
#define HAVE_SYS_TIMEB_H 1
#define HAVE_ALIGNED_MALLOC 1
/* The JIT is enabled by default on all x86, x86-64, ARM & MIPS platforms except ARMv7k and Windows. */
#if !defined(ENABLE_JIT) \
&& (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)) \
- && !CPU(APPLE_ARMV7K) \
- && !OS(WINCE)
+ && !CPU(APPLE_ARMV7K)
#define ENABLE_JIT 1
#endif
#define WTF_USE_UNIX_DOMAIN_SOCKETS 1
#endif
-#if !defined(WTF_USE_IMLANG_FONT_LINK2) && !OS(WINCE)
+#if !defined(WTF_USE_IMLANG_FONT_LINK2)
#define WTF_USE_IMLANG_FONT_LINK2 1
#endif
win/RunLoopWin.cpp
)
-if (WINCE)
- list(APPEND WTF_LIBRARIES
- mmtimer
- )
-else ()
- list(APPEND WTF_LIBRARIES
- winmm
- )
-endif ()
+list(APPEND WTF_LIBRARIES
+ winmm
+)
list(APPEND WTF_HEADERS
"${DERIVED_SOURCES_WTF_DIR}/WTFHeaderDetection.h"
if (pages == -1 || pageSize == -1)
return ramSizeGuess;
return pages * pageSize;
-#elif OS(WINCE)
- MEMORYSTATUS status;
- status.dwLength = sizeof(status);
- GlobalMemoryStatus(&status);
- if (status.dwTotalPhys <= 0)
- return ramSizeGuess;
- return status.dwTotalPhys;
#elif OS(WINDOWS)
MEMORYSTATUSEX status;
status.dwLength = sizeof(status);
{
#if OS(DARWIN)
// On Darwin we use arc4random which initialises itself.
-#elif OS(WINCE)
- // initialize rand()
- srand(GetTickCount());
#elif COMPILER(MSVC) && defined(_CRT_RAND_S)
// On Windows we use rand_s which initialises itself
#elif OS(UNIX)
// stackOrigin.AllocationBase points to the reserved stack memory base address.
m_origin = static_cast<char*>(stackOrigin.BaseAddress) + stackOrigin.RegionSize;
-#if OS(WINCE)
- SYSTEM_INFO systemInfo;
- GetSystemInfo(&systemInfo);
- DWORD pageSize = systemInfo.dwPageSize;
-
- MEMORY_BASIC_INFORMATION stackMemory;
- VirtualQuery(m_origin, &stackMemory, sizeof(stackMemory));
-
- m_bound = static_cast<char*>(m_origin) - stackMemory.RegionSize + pageSize;
-#else
// The stack on Windows consists out of three parts (uncommitted memory, a guard page and present
// committed memory). The 3 regions have different BaseAddresses but all have the same AllocationBase
// since they are all from the same VirtualAlloc. The 3 regions are laid out in memory (from high to
ASSERT(endOfStack == computedEnd);
#endif // NDEBUG
m_bound = static_cast<char*>(endOfStack) + guardPage.RegionSize;
-#endif // OS(WINCE)
}
#else
bool isGrowingDownward() const
{
ASSERT(m_origin && m_bound);
-#if OS(WINCE)
- return m_origin > m_bound;
-#else
return true;
-#endif
}
private:
} // namespace WTF
-#if OS(WINCE)
-// Windows CE CRT has does not implement bsearch().
-inline void* wtf_bsearch(const void* key, const void* base, size_t count, size_t size, int (*compare)(const void *, const void *))
-{
- const char* first = static_cast<const char*>(base);
-
- while (count) {
- size_t pos = (count - 1) >> 1;
- const char* item = first + pos * size;
- int compareResult = compare(item, key);
- if (!compareResult)
- return const_cast<char*>(item);
- if (compareResult < 0) {
- count -= (pos + 1);
- first += (pos + 1) * size;
- } else
- count = pos;
- }
-
- return 0;
-}
-
-#define bsearch(key, base, count, size, compare) wtf_bsearch(key, base, count, size, compare)
-#endif
-
// This version of placement new omits a 0 check.
enum NotNullTag { NotNull };
inline void* operator new(size_t, NotNullTag, void* location)
// vsnprintf does not null terminate the buffer. WebKit can rely on the null termination.
#define vsnprintf(buffer, count, format, args) wtf_vsnprintf(buffer, count, format, args)
-#if OS(WINCE)
-
-inline int strnicmp(const char* string1, const char* string2, size_t count)
-{
- return _strnicmp(string1, string2, count);
-}
-
-inline int stricmp(const char* string1, const char* string2)
-{
- return _stricmp(string1, string2);
-}
-
-inline char* strdup(const char* strSource)
-{
- return _strdup(strSource);
-}
-
-#endif
-
inline int strncasecmp(const char* s1, const char* s2, size_t len)
{
return _strnicmp(s1, s2, len);
#elif OS(WINDOWS)
-// TLS_OUT_OF_INDEXES is not defined on WinCE.
-#ifndef TLS_OUT_OF_INDEXES
-#define TLS_OUT_OF_INDEXES 0xffffffff
-#endif
-
// The maximum number of TLS keys that can be created. For simplification, we assume that:
// 1) Once the instance of ThreadSpecific<> is created, it will not be destructed until the program dies.
// 2) We do not need to hold many instances of ThreadSpecific<> data. This fixed number should be far enough.
#include "MainThread.h"
#include "ThreadFunctionInvocation.h"
+#include <process.h>
#include <windows.h>
#include <wtf/CurrentTime.h>
#include <wtf/HashMap.h>
#include "ThreadSpecific.h"
#endif
-#if !OS(WINCE)
-#include <process.h>
-#endif
-
#if HAVE(ERRNO_H)
#include <errno.h>
#endif
unsigned threadIdentifier = 0;
ThreadIdentifier threadID = 0;
OwnPtr<ThreadFunctionInvocation> invocation = adoptPtr(new ThreadFunctionInvocation(entryPoint, data));
-#if OS(WINCE)
- // This is safe on WINCE, since CRT is in the core and innately multithreaded.
- // On desktop Windows, need to use _beginthreadex (not available on WinCE) if using any CRT functions
- HANDLE threadHandle = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)wtfThreadEntryPoint, invocation.get(), 0, (LPDWORD)&threadIdentifier);
-#else
HANDLE threadHandle = reinterpret_cast<HANDLE>(_beginthreadex(0, 0, wtfThreadEntryPoint, invocation.get(), 0, &threadIdentifier));
-#endif
if (!threadHandle) {
-#if OS(WINCE)
- LOG_ERROR("Failed to create thread at entry point %p with data %p: %ld", entryPoint, data, ::GetLastError());
-#elif !HAVE(ERRNO_H)
+#if !HAVE(ERRNO_H)
LOG_ERROR("Failed to create thread at entry point %p with data %p.", entryPoint, data);
#else
LOG_ERROR("Failed to create thread at entry point %p with data %p: %ld", entryPoint, data, errno);
inline HRESULT getRegistryValue(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue, LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
{
-#if OS(WINCE)
- HKEY key;
- if (::RegOpenKeyExW(hkey, pszSubKey, 0, 0, &key) != ERROR_SUCCESS)
- return ERROR_INVALID_NAME;
- HRESULT result = ::RegQueryValueExW(key, pszValue, 0, pdwType, static_cast<LPBYTE>(pvData), pcbData);
- ::RegCloseKey(key);
- return result;
-#else
return ::SHGetValueW(hkey, pszSubKey, pszValue, pdwType, pvData, pcbData);
-#endif
}
inline void* getWindowPointer(HWND hWnd, int index)
{
-#if OS(WINCE)
- return reinterpret_cast<void*>(::GetWindowLong(hWnd, index));
-#else
return reinterpret_cast<void*>(::GetWindowLongPtr(hWnd, index));
-#endif
}
inline void* setWindowPointer(HWND hWnd, int index, void* value)
{
-#if OS(WINCE)
- return reinterpret_cast<void*>(::SetWindowLong(hWnd, index, reinterpret_cast<LONG>(value)));
-#else
return reinterpret_cast<void*>(::SetWindowLongPtr(hWnd, index, reinterpret_cast<LONG_PTR>(value)));
-#endif
}
} // namespace WTF
defined(__ARMEL__) || \
defined(_MIPS_ARCH_MIPS32R2)
#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
-#elif CPU(MIPS) || CPU(PPC) || CPU(PPC64) || CPU(PPC64LE) || OS(WINCE) || CPU(SH4) || CPU(S390) || CPU(S390X) || CPU(IA64) || CPU(ALPHA) || CPU(ARM64) || CPU(HPPA)
+#elif CPU(MIPS) || CPU(PPC) || CPU(PPC64) || CPU(PPC64LE) || CPU(SH4) || CPU(S390) || CPU(S390X) || CPU(IA64) || CPU(ALPHA) || CPU(ARM64) || CPU(HPPA)
#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
#elif defined(_M_IX86) || defined(__i386__)
#if defined(_WIN32)
#else
#undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
#endif // _WIN32
-#elif defined(WINCE) || defined(_WIN32_WCE)
-#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
#else
#error Target architecture was not detected as supported by Double-Conversion.
#endif
String String::format(const char *format, ...)
{
-#if OS(WINCE)
- va_list args;
- va_start(args, format);
-
- Vector<char, 256> buffer;
-
- int bufferSize = 256;
- buffer.resize(bufferSize);
- for (;;) {
- int written = vsnprintf(buffer.data(), bufferSize, format, args);
- va_end(args);
-
- if (written == 0)
- return String("");
- if (written > 0)
- return StringImpl::create(reinterpret_cast<const LChar*>(buffer.data()), written);
-
- bufferSize <<= 1;
- buffer.resize(bufferSize);
- va_start(args, format);
- }
-
-#else
va_list args;
va_start(args, format);
va_end(args);
return StringImpl::create(reinterpret_cast<const LChar*>(buffer.data()), len);
-#endif
}
String String::number(int number)
+2014-09-25 Csaba Osztrogonác <ossy@webkit.org>
+
+ Remove WinCE port from trunk
+ https://bugs.webkit.org/show_bug.cgi?id=136951
+
+ Reviewed by Alex Christensen.
+
+ * Modules/encryptedmedia/CDMPrivateMediaPlayer.cpp:
+ * PlatformWinCE.cmake: Removed.
+ * accessibility/AXObjectCache.cpp:
+ * editing/FrameSelection.cpp:
+ (WebCore::FrameSelection::modifyMovingRight):
+ * loader/icon/wince/IconDatabaseWinCE.cpp: Removed.
+ * page/EventHandler.cpp:
+ (WebCore::EventHandler::sendContextMenuEventForKey):
+ * page/Settings.cpp:
+ * page/win/EventHandlerWin.cpp:
+ (WebCore::EventHandler::createDraggingDataTransfer):
+ * platform/ContextMenu.h:
+ * platform/DragImage.cpp:
+ * platform/FileSystem.h:
+ * platform/graphics/BitmapImage.cpp:
+ (WebCore::BitmapImage::mayFillWithSolidColor):
+ * platform/graphics/FontGlyphs.cpp:
+ (WebCore::FontGlyphs::glyphDataAndPageForCharacter):
+ * platform/graphics/FontPlatformData.h:
+ * platform/graphics/ImageBufferData.h:
+ * platform/graphics/MediaPlayer.cpp:
+ * platform/graphics/SimpleFontData.h:
+ * platform/graphics/opentype/OpenTypeUtilities.cpp:
+ (WebCore::renameAndActivateFont):
+ * platform/graphics/opentype/OpenTypeUtilities.h:
+ * platform/graphics/win/DIBPixelData.cpp:
+ (WebCore::DIBPixelData::setRGBABitmapAlpha):
+ * platform/graphics/win/GDIExtras.cpp: Removed.
+ * platform/graphics/win/GDIExtras.h:
+ (WebCore::hasAlphaBlendSupport):
+ (WebCore::alphaBlendIfSupported):
+ * platform/graphics/win/IconWin.cpp:
+ (WebCore::Icon::createIconForFiles):
+ (WebCore::Icon::paint):
+ * platform/graphics/win/SimpleFontDataWin.cpp:
+ (WebCore::SimpleFontData::initGDIFont):
+ (WebCore::SimpleFontData::platformDestroy):
+ (WebCore::SimpleFontData::boundsForGDIGlyph):
+ (WebCore::SimpleFontData::widthForGDIGlyph):
+ (WebCore::SimpleFontData::scriptFontProperties):
+ * platform/graphics/wince/FontCacheWinCE.cpp: Removed.
+ * platform/graphics/wince/FontCustomPlatformData.cpp: Removed.
+ * platform/graphics/wince/FontCustomPlatformData.h: Removed.
+ * platform/graphics/wince/FontPlatformData.cpp: Removed.
+ * platform/graphics/wince/FontPlatformData.h: Removed.
+ * platform/graphics/wince/FontWinCE.cpp: Removed.
+ * platform/graphics/wince/GlyphPageTreeNodeWinCE.cpp: Removed.
+ * platform/graphics/wince/GradientWinCE.cpp: Removed.
+ * platform/graphics/wince/GraphicsContextWinCE.cpp: Removed.
+ * platform/graphics/wince/ImageBufferDataWince.h: Removed.
+ * platform/graphics/wince/ImageBufferWinCE.cpp: Removed.
+ * platform/graphics/wince/ImageWinCE.cpp: Removed.
+ * platform/graphics/wince/MediaPlayerPrivateWinCE.h: Removed.
+ * platform/graphics/wince/MediaPlayerProxy.cpp: Removed.
+ * platform/graphics/wince/MediaPlayerProxy.h: Removed.
+ * platform/graphics/wince/PathWinCE.cpp: Removed.
+ * platform/graphics/wince/PlatformPathWinCE.cpp: Removed.
+ * platform/graphics/wince/PlatformPathWinCE.h: Removed.
+ * platform/graphics/wince/SharedBitmap.cpp: Removed.
+ * platform/graphics/wince/SharedBitmap.h: Removed.
+ * platform/graphics/wince/SimpleFontDataWinCE.cpp: Removed.
+ * platform/graphics/wince/WinCEGraphicsExtras.h: Removed.
+ * platform/image-decoders/jpeg/JPEGImageDecoder.h:
+ * platform/network/win/NetworkStateNotifierWin.cpp:
+ (WebCore::NetworkStateNotifier::NetworkStateNotifier):
+ * platform/win/COMPtr.h:
+ * platform/win/ClipboardUtilitiesWin.cpp:
+ * platform/win/ContextMenuItemWin.cpp:
+ * platform/win/ContextMenuWin.cpp:
+ (WebCore::ContextMenu::getContextMenuItems):
+ (WebCore::ContextMenu::createPlatformContextMenuFromItems):
+ * platform/win/DragImageWin.cpp:
+ (WebCore::dragLabelFont):
+ * platform/win/FileSystemWin.cpp:
+ (WebCore::pathByAppendingComponent):
+ (WebCore::pathGetFileName):
+ (WebCore::storageDirectory):
+ * platform/win/LoggingWin.cpp:
+ (WebCore::logLevelString):
+ * platform/win/PasteboardWin.cpp:
+ (WebCore::PasteboardOwnerWndProc):
+ (WebCore::Pasteboard::createForCopyAndPaste):
+ (WebCore::pathRemoveBadFSCharacters):
+ (WebCore::filesystemPathFromUrlOrTitle):
+ (WebCore::createGlobalHDropContent):
+ * platform/win/PlatformMouseEventWin.cpp:
+ (WebCore::messageToEventType):
+ (WebCore::PlatformMouseEvent::PlatformMouseEvent):
+ * platform/win/PlatformScreenWin.cpp:
+ (WebCore::deviceInfoForWidget):
+ (WebCore::screenIsMonochrome):
+ * platform/win/PopupMenuWin.cpp:
+ (WebCore::PopupMenuWin::show):
+ (WebCore::PopupMenuWin::paint):
+ (WebCore::PopupMenuWin::registerClass):
+ (WebCore::PopupMenuWin::wndProc):
+ * platform/win/ScrollbarThemeWin.cpp:
+ (WebCore::ScrollbarThemeWin::paintButton):
+ * platform/win/SharedBufferWin.cpp:
+ * platform/win/SharedTimerWin.cpp:
+ (WebCore::TimerWindowWndProc):
+ (WebCore::initializeOffScreenTimerWindow):
+ (WebCore::queueTimerProc):
+ (WebCore::setSharedTimerFireInterval):
+ (WebCore::stopSharedTimer):
+ * platform/win/SoftLinking.h:
+ * platform/win/SystemInfo.cpp:
+ (WebCore::windowsVersion):
+ (WebCore::processorArchitecture):
+ (WebCore::architectureTokenForUAString):
+ * platform/win/WCDataObject.cpp:
+ (WebCore::WCDataObject::CopyMedium):
+ * plugins/PluginDatabase.cpp:
+ * plugins/PluginView.cpp:
+ (WebCore::PluginView::stop):
+ * plugins/PluginViewNone.cpp:
+ * plugins/win/PluginDatabaseWin.cpp:
+ (WebCore::addWindowsMediaPlayerPluginDirectory):
+ (WebCore::addMacromediaPluginDirectories):
+ * plugins/win/PluginPackageWin.cpp:
+ (WebCore::PluginPackage::load):
+ * plugins/win/PluginViewWin.cpp:
+ (WebCore::setUpOffscreenPaintingHooks):
+ (WebCore::registerPluginView):
+ (WebCore::PluginView::wndProc):
+ (WebCore::PluginView::updatePluginWidget):
+ (WebCore::PluginView::paintIntoTransformedContext):
+ (WebCore::PluginView::paint):
+ (WebCore::PluginView::handleMouseEvent):
+ (WebCore::PluginView::setParent):
+ (WebCore::PluginView::setNPWindowRect):
+ (WebCore::PluginView::platformStart):
+ * rendering/RenderThemeWinCE.cpp: Removed.
+ * rendering/RenderThemeWinCE.h: Removed.
+ * storage/wince/DatabaseThreadWinCE.cpp: Removed.
+ * storage/wince/DatabaseThreadWinCE.h: Removed.
+ * storage/wince/StorageThreadWinCE.cpp: Removed.
+ * storage/wince/StorageThreadWinCE.h: Removed.
+
2014-09-25 Carlos Garcia Campos <cgarcia@igalia.com>
Unreviewed. Fix GTK+ build after r173944.
#include "ExceptionCode.h"
#include "MediaPlayer.h"
-#if PLATFORM(IOS) || OS(WINCE)
+#if PLATFORM(IOS)
#include "SoftLinking.h"
#endif
+++ /dev/null
-list(APPEND WebCore_INCLUDE_DIRECTORIES
- "${WEBCORE_DIR}/platform/wince"
- "${WEBCORE_DIR}/platform/graphics/wince"
- "${WEBCORE_DIR}/platform/network/win"
- "${3RDPARTY_DIR}/libjpeg"
- "${3RDPARTY_DIR}/libpng"
- "${3RDPARTY_DIR}/libxml2/include"
- "${3RDPARTY_DIR}/libxslt/include"
- "${3RDPARTY_DIR}/sqlite"
- "${3RDPARTY_DIR}/zlib"
-)
-
-list(APPEND WebCore_SOURCES
- page/win/FrameGdiWin.cpp
-
- platform/ScrollAnimatorNone.cpp
-
- platform/graphics/win/DIBPixelData.cpp
- platform/graphics/win/GDIExtras.cpp
- platform/graphics/win/IconWin.cpp
- platform/graphics/win/ImageWin.cpp
- platform/graphics/win/IntPointWin.cpp
- platform/graphics/win/IntRectWin.cpp
- platform/graphics/win/IntSizeWin.cpp
-
- platform/graphics/wince/FontCacheWince.cpp
- platform/graphics/wince/FontCustomPlatformData.cpp
- platform/graphics/wince/FontPlatformData.cpp
- platform/graphics/wince/FontWince.cpp
- platform/graphics/wince/GlyphPageTreeNodeWince.cpp
- platform/graphics/wince/GradientWince.cpp
- platform/graphics/wince/GraphicsContextWince.cpp
- platform/graphics/wince/ImageBufferWince.cpp
- platform/graphics/wince/ImageWinCE.cpp
- platform/graphics/wince/PathWince.cpp
- platform/graphics/wince/PlatformPathWince.cpp
- platform/graphics/wince/SharedBitmap.cpp
- platform/graphics/wince/SimpleFontDataWince.cpp
-
- platform/network/NetworkStorageSessionStub.cpp
-
- platform/network/win/CookieJarWin.cpp
- platform/network/win/CredentialStorageWin.cpp
- platform/network/win/ProxyServerWin.cpp
- platform/network/win/ResourceHandleWin.cpp
- platform/network/win/SocketStreamHandleWin.cpp
-
- platform/text/LocaleNone.cpp
-
- platform/text/win/TextCodecWin.cpp
-
- rendering/RenderThemeWince.cpp
-)
-
-list(APPEND WebCore_LIBRARIES
- crypt32
- iphlpapi
- libjpeg
- libpng
- libxml2
- libxslt
- sqlite
- wininet
-)
}
-#if !PLATFORM(WIN) || OS(WINCE)
+#if !PLATFORM(WIN)
AXID AXObjectCache::platformGenerateAXID() const
{
static AXID lastUsedID = 0;
pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).right(true);
break;
case WordGranularity: {
- // Visual word movement relies on isWordTextBreak which is not implemented in WinCE and QT.
- // https://bugs.webkit.org/show_bug.cgi?id=81136.
bool skipsSpaceWhenMovingRight = m_frame && m_frame->editor().behavior().shouldSkipSpaceWhenMovingRight();
pos = rightWordPosition(VisiblePosition(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
break;
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#include "config.h"
-#include "IconDatabase.h"
-
-#include "DocumentLoader.h"
-#include "FileSystem.h"
-#include "IconDatabaseClient.h"
-#include "IconRecord.h"
-#include "Image.h"
-#include <wtf/AutodrainedPool.h>
-#include <wtf/text/CString.h>
-
-namespace WebCore {
-
-static IconDatabase* sharedIconDatabase = 0;
-
-// Function to obtain the global icon database.
-IconDatabase& iconDatabase()
-{
- if (!sharedIconDatabase)
- sharedIconDatabase = new IconDatabase;
- return *sharedIconDatabase;
-}
-
-IconDatabase::IconDatabase() {}
-IconDatabase::~IconDatabase() {}
-
-void IconDatabase::setClient(IconDatabaseClient*) {}
-
-bool IconDatabase::open(const String& path) { return false; }
-void IconDatabase::close() {}
-
-void IconDatabase::removeAllIcons() {}
-
-Image* IconDatabase::iconForPageURL(const String&, const IntSize&) { return 0; }
-void IconDatabase::readIconForPageURLFromDisk(const String&) {}
-String IconDatabase::iconURLForPageURL(const String&) { return String(); }
-Image* IconDatabase::defaultIcon(const IntSize&) { return 0;}
-
-void IconDatabase::retainIconForPageURL(const String&) {}
-void IconDatabase::releaseIconForPageURL(const String&) {}
-
-void IconDatabase::setIconDataForIconURL(PassRefPtr<SharedBuffer> data, const String&) {}
-void IconDatabase::setIconURLForPageURL(const String& iconURL, const String& pageURL) {}
-
-IconLoadDecision IconDatabase::loadDecisionForIconURL(const String&, DocumentLoader*) { return IconLoadNo; }
-bool IconDatabase::iconDataKnownForIconURL(const String&) { return false; }
-
-void IconDatabase::setEnabled(bool enabled) {}
-bool IconDatabase::isEnabled() const { return false; }
-
-void IconDatabase::setPrivateBrowsingEnabled(bool flag) {}
-bool IconDatabase::isPrivateBrowsingEnabled() const { return false; }
-
-void IconDatabase::delayDatabaseCleanup() {}
-void IconDatabase::allowDatabaseCleanup() {}
-void IconDatabase::checkIntegrityBeforeOpening() {}
-
-// Support for WebCoreStatistics in WebKit
-size_t IconDatabase::pageURLMappingCount() { return 0; }
-size_t IconDatabase::retainedPageURLCount() {return 0; }
-size_t IconDatabase::iconRecordCount() { return 0; }
-size_t IconDatabase::iconRecordCountWithData() { return 0; }
-
-bool IconDatabase::isOpen() const { return false; }
-String IconDatabase::databasePath() const { return String(); }
-String IconDatabase::defaultDatabaseFilename() { return String(); }
-
-} // namespace WebCore
static const int kContextMenuMargin = 1;
-#if OS(WINDOWS) && !OS(WINCE)
+#if OS(WINDOWS)
int rightAligned = ::GetSystemMetrics(SM_MENUDROPALIGNMENT);
#else
int rightAligned = 0;
// NOTEs
// 1) EditingMacBehavior comprises Tiger, Leopard, SnowLeopard and iOS builds, as well as QtWebKit when built on Mac;
-// 2) EditingWindowsBehavior comprises Win32 and WinCE builds, as well as QtWebKit and Chromium when built on Windows;
+// 2) EditingWindowsBehavior comprises Win32 build;
// 3) EditingUnixBehavior comprises all unix-based systems, but Darwin/MacOS (and then abusing the terminology);
// 99) MacEditingBehavior is used as a fallback.
static EditingBehaviorType editingBehaviorTypeForPlatform()
#if ENABLE(DRAG_SUPPORT)
PassRefPtr<DataTransfer> EventHandler::createDraggingDataTransfer() const
{
-#if OS(WINCE)
- return 0;
-#else
return DataTransfer::createForDragAndDrop();
-#endif
}
#endif
RetainPtr<NSMutableArray> m_platformDescription;
#else
PlatformMenuDescription m_platformDescription;
-#if OS(WINCE)
- unsigned m_itemCount;
-#endif
#endif
#endif // USE(CROSS_PLATFORM_CONTEXT_MENUS)
return createDragImageFromSnapshot(snapshotNode(frame, node), &node);
}
-#if !PLATFORM(COCOA) && (!PLATFORM(WIN) || OS(WINCE))
+#if !PLATFORM(COCOA) && !PLATFORM(WIN)
DragImageRef createDragImageForLink(URL&, const String&, FontRenderingMode)
{
return nullptr;
uint64_t getVolumeFreeSizeForPath(const char*);
#endif
-#if PLATFORM(WIN) && !OS(WINCE)
+#if PLATFORM(WIN)
String localUserSpecificStorageDirectory();
String roamingUserSpecificStorageDirectory();
#endif
{
if (!m_checkedForSolidColor && frameCount() > 0) {
checkForSolidColor();
- // WINCE PORT: checkForSolidColor() doesn't set m_checkedForSolidColor until
- // it gets enough information to make final decision.
-#if !OS(WINCE)
ASSERT(m_checkedForSolidColor);
-#endif
}
return m_isSolidColor && !m_currentFrame;
}
GlyphData data = fallbackPage && fallbackPage->fontDataForCharacter(c) ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
// Cache it so we don't have to do system fallback again next time.
if (variant == NormalVariant) {
-#if OS(WINCE)
- // missingGlyphData returns a null character, which is not suitable for GDI to display.
- // Also, sometimes we cannot map a font for the character on WINCE, but GDI can still
- // display the character, probably because the font package is not installed correctly.
- // So we just always set the glyph to be same as the character, and let GDI solve it.
- page->setGlyphDataForCharacter(c, c, characterFontData.get());
- characterFontData->setMaxGlyphPageTreeLevel(std::max(characterFontData->maxGlyphPageTreeLevel(), node->level()));
- return std::make_pair(page->glyphDataForCharacter(c), page);
-#else
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
data.fontData->setMaxGlyphPageTreeLevel(std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
if (!Font::isCJKIdeographOrSymbol(c) && data.fontData->platformData().orientation() != Horizontal && !data.fontData->isTextOrientationFallback())
return glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(c, description.nonCJKGlyphOrientation(), data, fallbackPage, pageNumber);
-#endif
}
return std::make_pair(data, page);
}
// FIXME: It would be nicer to use the missing glyph from the last resort font instead.
GlyphData data = primarySimpleFontData(description)->missingGlyphData();
if (variant == NormalVariant) {
-#if OS(WINCE)
- // See comment about WINCE GDI handling near setGlyphDataForCharacter above.
- page->setGlyphDataForCharacter(c, c, data.fontData);
- data.fontData->setMaxGlyphPageTreeLevel(std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
- return std::make_pair(page->glyphDataForCharacter(c), page);
-#else
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
data.fontData->setMaxGlyphPageTreeLevel(std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
-#endif
}
return std::make_pair(data, page);
}
*/
// FIXME: This is temporary until all ports switch to using this file.
-#if USE(WINGDI)
-#include "wince/FontPlatformData.h"
-#elif PLATFORM(EFL) || PLATFORM(GTK)
+#if PLATFORM(EFL) || PLATFORM(GTK)
#include "freetype/FontPlatformData.h"
#else
#include "ImageBufferDataCG.h"
#elif USE(CAIRO)
#include "ImageBufferDataCairo.h"
-#elif USE(WINGDI)
-#include "ImageBufferDataWince.h"
#endif
#include "MediaPlayerPrivateMediaSourceAVFObjC.h"
#endif
#endif
-#elif OS(WINCE)
-#include "MediaPlayerPrivateWinCE.h"
-#define PlatformMediaEngineClassName MediaPlayerPrivate
#elif PLATFORM(WIN) && !USE(GSTREAMER)
#if USE(AVFOUNDATION)
#include "MediaPlayerPrivateAVFoundationCF.h"
#include <wtf/RetainPtr.h>
#endif
-#if (PLATFORM(WIN) && !OS(WINCE))
+#if PLATFORM(WIN)
#include <usp10.h>
#endif
#if PLATFORM(WIN)
bool isSystemFont() const { return m_isSystemFont; }
-#if !OS(WINCE) // disable unused members to save space
SCRIPT_FONTPROPERTIES* scriptFontProperties() const;
SCRIPT_CACHE* scriptCache() const { return &m_scriptCache; }
-#endif
static void setShouldApplyMacAscentHack(bool);
static bool shouldApplyMacAscentHack();
static float ascentConsideringMacAscentHack(const WCHAR*, float ascent, float descent);
PassRefPtr<SimpleFontData> createScaledFontData(const FontDescription&, float scaleFactor) const;
PassRefPtr<SimpleFontData> platformCreateScaledFontData(const FontDescription&, float scaleFactor) const;
-#if (PLATFORM(WIN) && !OS(WINCE))
+#if PLATFORM(WIN)
void initGDIFont();
void platformCommonDestroy();
FloatRect boundsForGDIGlyph(Glyph glyph) const;
#if PLATFORM(WIN)
bool m_isSystemFont;
-#if !OS(WINCE) // disable unused members to save space
mutable SCRIPT_CACHE m_scriptCache;
mutable SCRIPT_FONTPROPERTIES* m_scriptFontProperties;
#endif
-#endif
#if PLATFORM(IOS)
bool m_shouldNotBeUsedForArabic;
#endif
return true;
}
-#if !OS(WINCE)
// Rename the font and install the new font data into the system
HANDLE renameAndActivateFont(const SharedBuffer& fontData, const String& fontName)
{
return fontHandle;
}
-#endif
}
struct EOTPrefix;
class SharedBuffer;
-#if OS(WINCE)
-typedef unsigned __int8 UInt8;
-#endif
-
struct EOTHeader {
EOTHeader();
ASSERT(pixelData.bitsPerPixel() == 32);
IntRect drawRect(dstRect);
-#if !OS(WINCE)
XFORM trans;
GetWorldTransform(hdc, &trans);
IntSize transformedPosition(trans.eDx, trans.eDy);
drawRect.move(transformedPosition);
-#endif
int pixelDataWidth = pixelData.size().width();
int pixelDataHeight = pixelData.size().height();
+++ /dev/null
-/*
- * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "GDIExtras.h"
-
-#include "SoftLinking.h"
-
-namespace WebCore {
-
-#if OS(WINCE)
-SOFT_LINK_LIBRARY(coredll)
-SOFT_LINK_OPTIONAL(coredll, AlphaBlend, BOOL, APIENTRY, (HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, HDC hdcSrc,
- int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, BLENDFUNCTION blendFunction))
-
-AlphaBlendPointerType AlphaBlendPointer()
-{
- return AlphaBlendPtr();
-}
-#endif
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef GDIExtras_h
-#define GDIExtras_h
-
-#include <windows.h>
-
-namespace WebCore {
-
-typedef BOOL (APIENTRY *AlphaBlendPointerType) (HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, HDC hdcSrc,
- int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, BLENDFUNCTION blendFunction);
-
-#if OS(WINCE)
-AlphaBlendPointerType AlphaBlendPointer();
-#endif
-
-inline bool hasAlphaBlendSupport()
-{
-#if OS(WINCE)
- return AlphaBlendPointer();
-#else
- return true;
-#endif
-}
-
-inline bool alphaBlendIfSupported(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, HDC hdcSrc,
- int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, BLENDFUNCTION blendFunction)
-{
-#if OS(WINCE)
- AlphaBlendPointerType alphaBlendPointer = AlphaBlendPointer();
- if (!alphaBlendPointer)
- return false;
-
- alphaBlendPointer(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, blendFunction);
-#else
- AlphaBlend(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, blendFunction);
-#endif
- return true;
-}
-
-} // namespace WebCore
-
-#endif // GDIExtras_h
#include <windows.h>
#include <wtf/text/WTFString.h>
-#if OS(WINCE)
-// SHGFI_SHELLICONSIZE is not available on WINCE
-#define SHGFI_SHELLICONSIZE 0
-#endif
-
namespace WebCore {
static const int shell32MultipleFileIconIndex = 54;
return adoptRef(new Icon(sfi.hIcon));
}
-#if OS(WINCE)
- return 0;
-#else
WCHAR buffer[MAX_PATH];
UINT length = ::GetSystemDirectoryW(buffer, WTF_ARRAY_LENGTH(buffer));
if (!length)
if (!::ExtractIconExW(buffer, shell32MultipleFileIconIndex, 0, &hIcon, 1))
return 0;
return adoptRef(new Icon(hIcon));
-#endif
}
void Icon::paint(GraphicsContext* context, const IntRect& r)
if (context->paintingDisabled())
return;
-#if OS(WINCE)
- context->drawIcon(m_hIcon, r, DI_NORMAL);
-#else
LocalWindowsContext windowContext(context, r);
DrawIconEx(windowContext.hdc(), r.x(), r.y(), m_hIcon, r.width(), r.height(), 0, 0, DI_NORMAL);
-#endif
}
}
m_avgCharWidth = textMetrics.tmAveCharWidth;
m_maxCharWidth = textMetrics.tmMaxCharWidth;
float xHeight = ascent * 0.56f; // Best guess for xHeight if no x glyph is present.
-#if !OS(WINCE)
GLYPHMETRICS gm;
static const MAT2 identity = { 0, 1, 0, 0, 0, 0, 0, 1 };
DWORD len = GetGlyphOutline(hdc, 'x', GGO_METRICS, &gm, 0, 0, &identity);
if (len != GDI_ERROR && gm.gmptGlyphOrigin.y > 0)
xHeight = gm.gmptGlyphOrigin.y;
-#endif
m_fontMetrics.setXHeight(xHeight);
m_fontMetrics.setUnitsPerEm(metrics.otmEMSquare);
void SimpleFontData::platformDestroy()
{
-#if !OS(WINCE)
ScriptFreeCache(&m_scriptCache);
delete m_scriptFontProperties;
-#endif
}
PassRefPtr<SimpleFontData> SimpleFontData::platformCreateScaledFontData(const FontDescription& fontDescription, float scaleFactor) const
FloatRect SimpleFontData::boundsForGDIGlyph(Glyph glyph) const
{
-#if OS(WINCE)
- return FloatRect();
-#else
HWndDC hdc(0);
SetGraphicsMode(hdc, GM_ADVANCED);
HGDIOBJ oldFont = SelectObject(hdc, m_platformData.hfont());
return FloatRect(gdiMetrics.gmptGlyphOrigin.x, -gdiMetrics.gmptGlyphOrigin.y,
gdiMetrics.gmBlackBoxX + m_syntheticBoldOffset, gdiMetrics.gmBlackBoxY);
-#endif
}
float SimpleFontData::widthForGDIGlyph(Glyph glyph) const
{
HWndDC hdc(0);
-#if !OS(WINCE)
SetGraphicsMode(hdc, GM_ADVANCED);
-#endif
HGDIOBJ oldFont = SelectObject(hdc, m_platformData.hfont());
-#if OS(WINCE)
- WCHAR c = glyph;
- SIZE fontSize;
- GetTextExtentPoint32W(hdc, &c, 1, &fontSize);
- float result = fontSize.cx * m_platformData.size() / 72.f;
-#else
GLYPHMETRICS gdiMetrics;
static const MAT2 identity = { 0, 1, 0, 0, 0, 0, 0, 1 };
GetGlyphOutline(hdc, glyph, GGO_METRICS | GGO_GLYPH_INDEX, &gdiMetrics, 0, 0, &identity);
float result = gdiMetrics.gmCellIncX + m_syntheticBoldOffset;
-#endif
SelectObject(hdc, oldFont);
return result;
}
-#if !OS(WINCE)
SCRIPT_FONTPROPERTIES* SimpleFontData::scriptFontProperties() const
{
if (!m_scriptFontProperties) {
}
return m_scriptFontProperties;
}
-#endif
} // namespace WebCore
+++ /dev/null
-/*
-* Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
-* Copyright (C) 2007-2009 Torch Mobile, Inc.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following conditions
-* are met:
-*
-* 1. Redistributions of source code must retain the above copyright
-* notice, this list of conditions and the following disclaimer.
-* 2. Redistributions in binary form must reproduce the above copyright
-* notice, this list of conditions and the following disclaimer in the
-* documentation and/or other materials provided with the distribution.
-* 3. Neither the name of Apple Inc. ("Apple") nor the names of
-* its contributors may be used to endorse or promote products derived
-* from this software without specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
-* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
-* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include "config.h"
-#include "FontCache.h"
-
-#include "Font.h"
-#include "FontData.h"
-#include "SimpleFontData.h"
-#include <wtf/OwnPtr.h>
-#include <windows.h>
-#include <mlang.h>
-
-namespace WebCore {
-
-extern HDC g_screenDC;
-
-static IMultiLanguage *multiLanguage = 0;
-static IMLangFontLinkType* langFontLink = 0;
-
-IMultiLanguage* FontCache::getMultiLanguageInterface()
-{
- if (!multiLanguage)
- CoCreateInstance(CLSID_CMultiLanguage, 0, CLSCTX_INPROC_SERVER, IID_IMultiLanguage, (void**)&multiLanguage);
-
- return multiLanguage;
-}
-
-IMLangFontLinkType* FontCache::getFontLinkInterface()
-{
- if (!langFontLink) {
- if (IMultiLanguage* mli = getMultiLanguageInterface())
- mli->QueryInterface(&langFontLink);
- }
-
- return langFontLink;
-}
-
-static bool currentFontContainsCharacter(IMLangFontLinkType* langFontLink, HDC hdc, HFONT hfont, UChar character, const wchar_t* faceName)
-{
-#if USE(IMLANG_FONT_LINK2)
- UINT unicodeRanges;
- if (S_OK != langFontLink->GetFontUnicodeRanges(hdc, &unicodeRanges, 0))
- return false;
-
- static Vector<UNICODERANGE, 64> glyphsetBuffer;
- glyphsetBuffer.resize(unicodeRanges);
-
- if (S_OK != langFontLink->GetFontUnicodeRanges(hdc, &unicodeRanges, glyphsetBuffer.data()))
- return false;
-
- // FIXME: Change this to a binary search. (Yong Li: That's easy. But, is it guaranteed that the ranges are sorted?)
- for (Vector<UNICODERANGE, 64>::const_iterator i = glyphsetBuffer.begin(); i != glyphsetBuffer.end(); ++i) {
- if (i->wcTo >= character)
- return i->wcFrom <= character;
- }
-#else
- DWORD fontCodePages = 0, charCodePages = 0;
- HRESULT result = langFontLink->GetFontCodePages(hdc, hfont, &fontCodePages);
- if (result != S_OK)
- return false;
- result = langFontLink->GetCharCodePages(character, &charCodePages);
- if (result != S_OK)
- return false;
-
- fontCodePages |= FontPlatformData::getKnownFontCodePages(faceName);
- if (fontCodePages & charCodePages)
- return true;
-#endif
-
- return false;
-}
-
-static HFONT createMLangFont(IMLangFontLinkType* langFontLink, HDC hdc, const FontPlatformData& refFont, DWORD codePageMask, UChar character = 0)
-{
- HFONT mlangFont;
-
-#if USE(IMLANG_FONT_LINK2)
- HRESULT result = langFontLink->MapFont(hdc, codePageMask, character, &mlangFont);
-#else
- HRESULT result = langFontLink->MapFont(hdc, codePageMask, refFont.hfont(), &mlangFont);
-#endif
-
- if (SUCCEEDED(result))
- return mlangFont;
- return 0;
-}
-
-static const Vector<DWORD, 4>& getCJKCodePageMasks()
-{
- // The default order in which we look for a font for a CJK character. If the user's default code page is
- // one of these, we will use it first.
- static const UINT CJKCodePages[] = {
- 932, /* Japanese */
- 936, /* Simplified Chinese */
- 950, /* Traditional Chinese */
- 949 /* Korean */
- };
-
- static Vector<DWORD, 4> codePageMasks;
- static bool initialized;
- if (!initialized) {
- initialized = true;
- IMLangFontLinkType* langFontLink = fontCache().getFontLinkInterface();
- if (!langFontLink)
- return codePageMasks;
-
- UINT defaultCodePage;
- DWORD defaultCodePageMask = 0;
- if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_RETURN_NUMBER | LOCALE_IDEFAULTANSICODEPAGE, reinterpret_cast<LPWSTR>(&defaultCodePage), sizeof(defaultCodePage)))
- langFontLink->CodePageToCodePages(defaultCodePage, &defaultCodePageMask);
-
- if (defaultCodePage == CJKCodePages[0] || defaultCodePage == CJKCodePages[1] || defaultCodePage == CJKCodePages[2] || defaultCodePage == CJKCodePages[3])
- codePageMasks.append(defaultCodePageMask);
- for (unsigned i = 0; i < 4; ++i) {
- if (defaultCodePage != CJKCodePages[i]) {
- DWORD codePageMask;
- langFontLink->CodePageToCodePages(CJKCodePages[i], &codePageMask);
- codePageMasks.append(codePageMask);
- }
- }
- }
- return codePageMasks;
-}
-
-
-struct TraitsInFamilyProcData {
- TraitsInFamilyProcData(const AtomicString& familyName)
- : m_familyName(familyName)
- {
- }
-
- const AtomicString& m_familyName;
- HashSet<unsigned> m_traitsMasks;
-};
-
-static int CALLBACK traitsInFamilyEnumProc(CONST LOGFONT* logFont, CONST TEXTMETRIC* metrics, DWORD fontType, LPARAM lParam)
-{
- TraitsInFamilyProcData* procData = reinterpret_cast<TraitsInFamilyProcData*>(lParam);
-
- unsigned traitsMask = 0;
- traitsMask |= logFont->lfItalic ? FontStyleItalicMask : FontStyleNormalMask;
- traitsMask |= FontVariantNormalMask;
- LONG weight = FontPlatformData::adjustedGDIFontWeight(logFont->lfWeight, procData->m_familyName);
- traitsMask |= weight == FW_THIN ? FontWeight100Mask :
- weight == FW_EXTRALIGHT ? FontWeight200Mask :
- weight == FW_LIGHT ? FontWeight300Mask :
- weight == FW_NORMAL ? FontWeight400Mask :
- weight == FW_MEDIUM ? FontWeight500Mask :
- weight == FW_SEMIBOLD ? FontWeight600Mask :
- weight == FW_BOLD ? FontWeight700Mask :
- weight == FW_EXTRABOLD ? FontWeight800Mask :
- FontWeight900Mask;
- procData->m_traitsMasks.add(traitsMask);
- return 1;
-}
-
-void FontCache::platformInit()
-{
-}
-
-void FontCache::comInitialize()
-{
-}
-
-void FontCache::comUninitialize()
-{
- if (langFontLink) {
- langFontLink->Release();
- langFontLink = 0;
- }
- if (multiLanguage) {
- multiLanguage->Release();
- multiLanguage = 0;
- }
-}
-
-PassRefPtr<SimpleFontData> FontCache::systemFallbackForCharacters(const FontDescription& description, const SimpleFontData* originalFontData, bool, const UChar* characters, int length)
-{
- String familyName;
- WCHAR name[LF_FACESIZE];
-
- UChar character = characters[0];
- const FontPlatformData& origFont = originalFontData->platformData();
-
- if (IMLangFontLinkType* langFontLink = getFontLinkInterface()) {
- HGDIOBJ oldFont = GetCurrentObject(g_screenDC, OBJ_FONT);
- HFONT hfont = 0;
- DWORD codePages = 0;
- UINT codePage = 0;
- // Try MLang font linking first.
- langFontLink->GetCharCodePages(character, &codePages);
- if (codePages && u_getIntPropertyValue(character, UCHAR_UNIFIED_IDEOGRAPH)) {
- // The CJK character may belong to multiple code pages. We want to
- // do font linking against a single one of them, preferring the default
- // code page for the user's locale.
- const Vector<DWORD, 4>& CJKCodePageMasks = getCJKCodePageMasks();
- unsigned numCodePages = CJKCodePageMasks.size();
- for (unsigned i = 0; i < numCodePages; ++i) {
- hfont = createMLangFont(langFontLink, g_screenDC, origFont, CJKCodePageMasks[i]);
- if (!hfont)
- continue;
-
- SelectObject(g_screenDC, hfont);
- GetTextFace(g_screenDC, LF_FACESIZE, name);
-
- if (hfont && !(codePages & CJKCodePageMasks[i])) {
- // We asked about a code page that is not one of the code pages
- // returned by MLang, so the font might not contain the character.
- if (!currentFontContainsCharacter(langFontLink, g_screenDC, hfont, character, name))
- {
- SelectObject(g_screenDC, oldFont);
- langFontLink->ReleaseFont(hfont);
- hfont = 0;
- continue;
- }
- }
- break;
- }
- } else {
- hfont = createMLangFont(langFontLink, g_screenDC, origFont, codePages, character);
- SelectObject(g_screenDC, hfont);
- GetTextFace(g_screenDC, LF_FACESIZE, name);
- }
- SelectObject(g_screenDC, oldFont);
-
- if (hfont) {
- familyName = name;
- langFontLink->ReleaseFont(hfont);
- } else
- FontPlatformData::mapKnownFont(codePages, familyName);
- }
-
- if (familyName.isEmpty())
- familyName = FontPlatformData::defaultFontFamily();
-
- if (!familyName.isEmpty()) {
- // FIXME: temporary workaround for Thai font problem
- FontDescription fontDescription(description);
- if (ublock_getCode(c) == UBLOCK_THAI && fontDescription.weight() > FontWeightNormal)
- fontDescription.setWeight(FontWeightNormal);
-
- FontPlatformData* result = getCachedFontPlatformData(fontDescription, familyName);
- if (result && result->hash() != origFont.hash()) {
- if (RefPtr<SimpleFontData> fontData = getCachedFontData(result, DoNotRetain))
- return fontData.release();
- }
- }
-
- return 0;
-}
-
-PassRefPtr<SimpleFontData> FontCache::getLastResortFallbackFont(const FontDescription& fontDesc, ShouldRetain shouldRetain)
-{
- // FIXME: Would be even better to somehow get the user's default font here. For now we'll pick
- // the default that the user would get without changing any prefs.
- return getCachedFontData(fontDesc, FontPlatformData::defaultFontFamily(), false, shouldRetain);
-}
-
-PassOwnPtr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
-{
- return adoptPtr(new FontPlatformData(fontDescription, family));
-}
-
-void FontCache::getTraitsInFamily(const AtomicString& familyName, Vector<unsigned>& traitsMasks)
-{
- LOGFONT logFont;
- logFont.lfCharSet = DEFAULT_CHARSET;
- unsigned familyLength = std::min(familyName.length(), static_cast<unsigned>(LF_FACESIZE - 1));
- memcpy(logFont.lfFaceName, familyName.characters(), familyLength * sizeof(UChar));
- logFont.lfFaceName[familyLength] = 0;
- logFont.lfPitchAndFamily = 0;
-
- TraitsInFamilyProcData procData(familyName);
- EnumFontFamiliesEx(g_screenDC, &logFont, traitsInFamilyEnumProc, reinterpret_cast<LPARAM>(&procData), 0);
- copyToVector(procData.m_traitsMasks, traitsMasks);
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
- * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#include "config.h"
-#include "FontCustomPlatformData.h"
-
-#include "CachedFont.h"
-#include "FontPlatformData.h"
-#include "OpenTypeUtilities.h"
-#include "SharedBuffer.h"
-#include <wtf/RandomNumber.h>
-#include <wtf/text/Base64.h>
-
-namespace WebCore {
-
-static CustomFontCache* g_customFontCache = 0;
-
-void setCustomFontCache(CustomFontCache* cache)
-{
- g_customFontCache = cache;
-}
-
-FontCustomPlatformData::~FontCustomPlatformData()
-{
- if (g_customFontCache && !m_name.isEmpty())
- g_customFontCache->unregisterFont(m_name);
-}
-
-FontPlatformData FontCustomPlatformData::fontPlatformData(int size, bool bold, bool italic, FontOrientation, FontWidthVariant, FontRenderingMode renderingMode)
-{
- FontDescription fontDesc;
- fontDesc.setComputedSize(size);
- fontDesc.setSpecifiedSize(size);
- fontDesc.setItalic(italic);
- fontDesc.setWeight(bold ? FontWeightBold : FontWeightNormal);
- return FontPlatformData(fontDesc, m_name, false);
-}
-
-// Creates a unique and unpredictable font name, in order to avoid collisions and to
-// not allow access from CSS.
-static String createUniqueFontName()
-{
- GUID fontUuid;
-
- unsigned int* ptr = reinterpret_cast<unsigned int*>(&fontUuid);
- for (int i = 0; i < sizeof(GUID) / sizeof(int) ; ++i)
- *(ptr + i) = static_cast<unsigned int>(randomNumber() * (std::numeric_limits<unsigned>::max() + 1.0));
-
- String fontName = base64Encode(reinterpret_cast<char*>(&fontUuid), sizeof(fontUuid));
- ASSERT(fontName.length() < LF_FACESIZE);
- return fontName.replace('/', '_');
-}
-
-std::unique_ptr<FontCustomPlatformData> createFontCustomPlatformData(SharedBuffer& buffer)
-{
- String fontName = createUniqueFontName();
-
- Vector<char> rewrittenFontData;
- if (!renameFont(buffer, fontName, rewrittenFontData))
- return nullptr;
-
- RefPtr<SharedBuffer> localBuffer = SharedBuffer::adoptVector(rewrittenFontData);
- if (!g_customFontCache || !g_customFontCache->registerFont(fontName, localBuffer.get()))
- return nullptr;
-
- return std::make_unique<FontCustomPlatformData>(fontName);
-}
-
-bool FontCustomPlatformData::supportsFormat(const String& format)
-{
- return equalIgnoringCase(format, "truetype") || equalIgnoringCase(format, "opentype");
-}
-
-}
+++ /dev/null
-/*
- * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#ifndef FontCustomPlatformData_h
-#define FontCustomPlatformData_h
-
-#include "FontDescription.h"
-#include "FontRenderingMode.h"
-#include "FontWidthVariant.h"
-#include <wtf/Noncopyable.h>
-#include <wtf/text/WTFString.h>
-
-namespace WebCore {
-
- class FontPlatformData;
- class CachedFont;
- class SharedBuffer;
-
- class CustomFontCache {
- public:
- virtual bool registerFont(const String& fontName, const SharedBuffer*) = 0;
- virtual void unregisterFont(const String& fontName) = 0;
- };
-
- struct FontCustomPlatformData {
- WTF_MAKE_NONCOPYABLE(FontCustomPlatformData);
- public:
- FontCustomPlatformData(const String& name)
- : m_name(name)
- {
- }
-
- ~FontCustomPlatformData();
-
- FontPlatformData fontPlatformData(int size, bool bold, bool italic, FontOrientation = Horizontal, FontWidthVariant = RegularWidth, FontRenderingMode = NormalRenderingMode);
-
- static bool supportsFormat(const String&);
-
- String m_name;
- };
-
- std::unique_ptr<FontCustomPlatformData> createFontCustomPlatformData(SharedBuffer&);
- void setCustomFontCache(CustomFontCache*);
-}
-
-#endif
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#include "config.h"
-#include "FontPlatformData.h"
-
-#include "Font.h"
-#include "FontCache.h"
-#include "FontData.h"
-#include "SimpleFontData.h"
-#include <wtf/StdLibExtras.h>
-#include <wtf/text/StringHash.h>
-#include <wtf/text/WTFString.h>
-#include <wtf/win/GDIObject.h>
-
-#include <windows.h>
-#include <mlang.h>
-
-namespace WebCore {
-
-extern HDC g_screenDC;
-
-static wchar_t songTiStr[] = { 0x5b8b, 0x4f53, 0 };
-static wchar_t heiTiStr[] = { 0x9ed1, 0x4f53, 0 };
-
-class FontFamilyCodePageInfo {
-public:
- FontFamilyCodePageInfo()
- : m_codePage(0), m_codePages(0)
- {
- }
- FontFamilyCodePageInfo(const wchar_t* family, UINT codePage)
- : m_family(family), m_codePage(codePage), m_codePages(0)
- {
- }
- DWORD codePages() const
- {
- if (!m_codePages) {
- if (IMLangFontLinkType* langFontLink = fontCache().getFontLinkInterface())
- langFontLink->CodePageToCodePages(m_codePage, &m_codePages);
- }
- return m_codePages;
- }
-
- String m_family;
- UINT m_codePage;
-private:
- mutable DWORD m_codePages;
-};
-
-class FontFamilyChecker {
-public:
- FontFamilyChecker(const wchar_t* family)
- : m_exists(false)
- {
- EnumFontFamilies(g_screenDC, family, enumFontFamProc, (LPARAM)this);
- }
- bool isSupported() const { return m_exists; }
-private:
- bool m_exists;
- static int CALLBACK enumFontFamProc(const LOGFONT FAR* lpelf, const TEXTMETRIC FAR* lpntm, DWORD FontType, LPARAM lParam);
-};
-
-class ValidFontFamilyFinder {
-public:
- ValidFontFamilyFinder()
- {
- EnumFontFamilies(g_screenDC, 0, enumFontFamProc, (LPARAM)this);
- }
- const String& family() const { return m_family; }
-private:
- String m_family;
- static int CALLBACK enumFontFamProc(const LOGFONT FAR* lpelf, const TEXTMETRIC FAR* lpntm, DWORD FontType, LPARAM lParam);
-};
-
-class FixedSizeFontData: public RefCounted<FixedSizeFontData> {
-public:
- LOGFONT m_font;
- GDIObject<HFONT> m_hfont;
- TEXTMETRIC m_metrics;
- DWORD m_codePages;
- unsigned m_weight;
- bool m_italic;
-
- static PassRefPtr<FixedSizeFontData> create(const AtomicString& family, unsigned weight, bool italic);
-private:
- FixedSizeFontData()
- : m_codePages(0)
- , m_weight(0)
- , m_italic(false)
- {
- memset(&m_font, 0, sizeof(m_font));
- memset(&m_metrics, 0, sizeof(m_metrics));
- }
-};
-
-struct FixedSizeFontDataKey {
- FixedSizeFontDataKey(const AtomicString& family = AtomicString(), unsigned weight = 0, bool italic = false)
- : m_family(family)
- , m_weight(weight)
- , m_italic(italic)
- {
- }
-
- FixedSizeFontDataKey(WTF::HashTableDeletedValueType) : m_weight(-2) { }
- bool isHashTableDeletedValue() const { return m_weight == -2; }
-
- bool operator==(const FixedSizeFontDataKey& other) const
- {
- return equalIgnoringCase(m_family, other.m_family)
- && m_weight == other.m_weight
- && m_italic == other.m_italic;
- }
-
- AtomicString m_family;
- unsigned m_weight;
- bool m_italic;
-};
-
-struct FixedSizeFontDataKeyHash {
- static unsigned hash(const FixedSizeFontDataKey& font)
- {
- unsigned hashCodes[] = {
- CaseFoldingHash::hash(font.m_family),
- font.m_weight,
- // static_cast<unsigned>(font.m_italic);
- };
- return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
- }
-
- static bool equal(const FixedSizeFontDataKey& a, const FixedSizeFontDataKey& b)
- {
- return a == b;
- }
-
- static const bool safeToCompareToEmptyOrDeleted = true;
-};
-
-struct FixedSizeFontDataKeyTraits : WTF::GenericHashTraits<FixedSizeFontDataKey> {
- static const bool emptyValueIsZero = true;
- static const FixedSizeFontDataKey& emptyValue()
- {
- DEPRECATED_DEFINE_STATIC_LOCAL(FixedSizeFontDataKey, key, (nullAtom));
- return key;
- }
- static void constructDeletedValue(FixedSizeFontDataKey& slot)
- {
- new (&slot) FixedSizeFontDataKey(WTF::HashTableDeletedValue);
- }
- static bool isDeletedValue(const FixedSizeFontDataKey& value)
- {
- return value.isHashTableDeletedValue();
- }
-};
-
-int CALLBACK FontFamilyChecker::enumFontFamProc(const LOGFONT FAR* lpelf, const TEXTMETRIC FAR* lpntm, DWORD FontType, LPARAM lParam)
-{
- ((FontFamilyChecker*)lParam)->m_exists = true;
- return 0;
-}
-
-int CALLBACK ValidFontFamilyFinder::enumFontFamProc(const LOGFONT FAR* lpelf, const TEXTMETRIC FAR* lpntm, DWORD FontType, LPARAM lParam)
-{
- if (lpelf->lfCharSet != SYMBOL_CHARSET) {
- ((ValidFontFamilyFinder*)lParam)->m_family = String(lpelf->lfFaceName);
- return 0;
- }
- return 1;
-}
-
-typedef Vector<FontFamilyCodePageInfo> KnownFonts;
-static KnownFonts& knownFonts()
-{
- static KnownFonts fonts;
- static bool firstTime = true;
- if (firstTime) {
- firstTime = false;
- if (FontPlatformData::isSongTiSupported())
- fonts.append(FontFamilyCodePageInfo(songTiStr, 936));
- }
- return fonts;
-}
-
-static String getDefaultFontFamily()
-{
- if (FontFamilyChecker(L"Tahoma").isSupported())
- return String(L"Tahoma");
-
- bool good = false;
- String family;
- HKEY key;
- if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SYSTEM\\GDI\\SysFnt", 0, 0, &key) == ERROR_SUCCESS) {
- DWORD maxlen, type;
- if (RegQueryValueEx(key, L"Nm", 0, &type, 0, &maxlen) == ERROR_SUCCESS && type == REG_SZ) {
- ++maxlen;
- if (wchar_t* buffer = new wchar_t[maxlen]) {
- if (RegQueryValueEx(key, L"Nm", 0, &type, (LPBYTE)buffer, &maxlen) == ERROR_SUCCESS) {
- family = String(buffer, maxlen);
- good = true;
- }
- delete[] buffer;
- }
- }
- RegCloseKey(key);
- }
- if (good)
- return family;
-
- return ValidFontFamilyFinder().family();
-}
-
-typedef HashMap<FixedSizeFontDataKey, RefPtr<FixedSizeFontData>, FixedSizeFontDataKeyHash, FixedSizeFontDataKeyTraits> FixedSizeFontCache;
-FixedSizeFontCache g_fixedSizeFontCache;
-
-PassRefPtr<FixedSizeFontData> FixedSizeFontData::create(const AtomicString& family, unsigned weight, bool italic)
-{
- FixedSizeFontData* fontData = new FixedSizeFontData();
-
- fontData->m_weight = weight;
- fontData->m_italic = italic;
-
- LOGFONT& winFont = fontData->m_font;
- // The size here looks unusual. The negative number is intentional.
- winFont.lfHeight = -72;
- winFont.lfWidth = 0;
- winFont.lfEscapement = 0;
- winFont.lfOrientation = 0;
- winFont.lfUnderline = false;
- winFont.lfStrikeOut = false;
- winFont.lfCharSet = DEFAULT_CHARSET;
- winFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
- winFont.lfQuality = CLEARTYPE_QUALITY; //DEFAULT_QUALITY;
- winFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
- winFont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
- winFont.lfItalic = italic;
- winFont.lfWeight = FontPlatformData::adjustedGDIFontWeight(weight, family);
-
- int len = std::min(family.length(), (unsigned int)LF_FACESIZE - 1);
- wmemcpy(winFont.lfFaceName, family.characters(), len);
- winFont.lfFaceName[len] = L'\0';
-
- fontData->m_hfont = adoptGDIObject(::CreateFontIndirect(&winFont));
-
- HGDIOBJ oldFont = SelectObject(g_screenDC, fontData->m_hfont.get());
-
- GetTextMetrics(g_screenDC, &fontData->m_metrics);
-
- if (IMLangFontLinkType* langFontLink = fontCache().getFontLinkInterface()) {
- langFontLink->GetFontCodePages(g_screenDC, fontData->m_hfont.get(), &fontData->m_codePages);
- fontData->m_codePages |= FontPlatformData::getKnownFontCodePages(winFont.lfFaceName);
- }
-
- SelectObject(g_screenDC, oldFont);
-
- return adoptRef(fontData);
-}
-
-static PassRefPtr<FixedSizeFontData> createFixedSizeFontData(const AtomicString& family, unsigned weight, bool italic)
-{
- FixedSizeFontDataKey key(family, weight, italic);
- FixedSizeFontCache::AddResult result = g_fixedSizeFontCache.add(key, RefPtr<FixedSizeFontData>());
- if (result.isNewEntry)
- result.iterator->value = FixedSizeFontData::create(family, weight, italic);
-
- return result.iterator->value;
-}
-
-static LONG toGDIFontWeight(FontWeight fontWeight)
-{
- static LONG gdiFontWeights[] = {
- FW_THIN, // FontWeight100
- FW_EXTRALIGHT, // FontWeight200
- FW_LIGHT, // FontWeight300
- FW_NORMAL, // FontWeight400
- FW_MEDIUM, // FontWeight500
- FW_SEMIBOLD, // FontWeight600
- FW_BOLD, // FontWeight700
- FW_EXTRABOLD, // FontWeight800
- FW_HEAVY // FontWeight900
- };
- return gdiFontWeights[fontWeight];
-}
-
-class FontPlatformPrivateData {
-public:
- int m_reference;
- RefPtr<FixedSizeFontData> m_rootFontData;
- AtomicString m_family;
- FontDescription m_fontDescription;
- GDIObject<HFONT> m_hfontScaled;
- int m_size;
- long m_fontScaledWidth;
- long m_fontScaledHeight;
- bool m_disabled;
- FontPlatformPrivateData(int size, unsigned weight)
- : m_reference(1)
- , m_family(FontPlatformData::defaultFontFamily())
- , m_size(size)
- , m_fontScaledWidth(0)
- , m_fontScaledHeight(0)
- , m_disabled(false)
- {
- m_rootFontData = createFixedSizeFontData(m_family, weight, false);
- }
- FontPlatformPrivateData(const FontDescription& fontDescription, const AtomicString& family)
- : m_reference(1)
- , m_size(fontDescription.computedPixelSize())
- , m_fontDescription(fontDescription)
- , m_family(family)
- , m_fontScaledWidth(0)
- , m_fontScaledHeight(0)
- , m_disabled(!fontDescription.specifiedSize())
- {
- m_rootFontData = FixedSizeFontData::create(family, toGDIFontWeight(fontDescription.weight()), fontDescription.italic());
- }
-};
-
-FontPlatformData::FontPlatformData(const FontDescription& fontDescription, const AtomicString& desiredFamily, bool useDefaultFontIfNotPresent)
-{
- String family(desiredFamily);
- if (!equalIgnoringCase(family, defaultFontFamily()) && !FontFamilyChecker(family.charactersWithNullTermination().data()).isSupported()) {
- if (equalIgnoringCase(family, String(heiTiStr)) && isSongTiSupported())
- family = String(songTiStr);
- else if (useDefaultFontIfNotPresent)
- family = defaultFontFamily();
- }
-
- m_private = new FontPlatformPrivateData(fontDescription, family);
-}
-
-FontPlatformData::FontPlatformData(float size, bool bold, bool oblique)
-{
- if (!size)
- m_private = 0;
- else
- m_private = new FontPlatformPrivateData((int)(size + 0.5), bold ? FW_BOLD : FW_NORMAL);
-}
-
-FontPlatformData::~FontPlatformData()
-{
- if (isValid() && !--m_private->m_reference) {
- if (m_private->m_rootFontData->refCount() == 2) {
- FixedSizeFontDataKey key(m_private->m_family, m_private->m_rootFontData->m_weight, m_private->m_rootFontData->m_italic);
- g_fixedSizeFontCache.remove(key);
- }
- delete m_private;
- }
-}
-
-FontPlatformData& FontPlatformData::operator=(const FontPlatformData& o)
-{
- if (isValid() && !--m_private->m_reference)
- delete m_private;
-
- if (m_private = o.m_private)
- ++m_private->m_reference;
-
- return *this;
-}
-
-HFONT FontPlatformData::hfont() const
-{
- if (!isValid())
- return 0;
-
- if (m_private->m_disabled)
- return 0;
-
- if (!m_private->m_rootFontData->m_hfont)
- m_private->m_rootFontData->m_hfont = adoptGDIObject(::CreateFontIndirect(&m_private->m_rootFontData->m_font));
-
- return m_private->m_rootFontData->m_hfont.get();
-}
-
-HFONT FontPlatformData::getScaledFontHandle(int height, int width) const
-{
- if (!isValid() || m_private->m_disabled)
- return 0;
-
- if (!m_private->m_hfontScaled || m_private->m_fontScaledHeight != height || m_private->m_fontScaledWidth != width) {
- m_private->m_fontScaledHeight = height;
- m_private->m_fontScaledWidth = width;
- LOGFONT font = m_private->m_rootFontData->m_font;
- font.lfHeight = -height;
- font.lfWidth = width;
- m_private->m_hfontScaled = adoptGDIObject(::CreateFontIndirect(&font));
- }
-
- return m_private->m_hfontScaled.get();
-}
-
-bool FontPlatformData::discardFontHandle()
-{
- if (!isValid())
- return false;
-
- if (m_private->m_rootFontData->m_hfont) {
- m_private->m_rootFontData->m_hfont = nullptr;
- return true;
- }
-
- if (m_private->m_hfontScaled) {
- m_private->m_hfontScaled = nullptr;
- return true;
- }
- return false;
-}
-
-const TEXTMETRIC& FontPlatformData::metrics() const
-{
- return m_private->m_rootFontData->m_metrics;
-}
-
-bool FontPlatformData::isSystemFont() const
-{
- return false;
-}
-
-int FontPlatformData::size() const
-{
- return m_private->m_size;
-}
-
-const FontDescription& FontPlatformData::fontDescription() const
-{
- return m_private->m_fontDescription;
-}
-
-const AtomicString& FontPlatformData::family() const
-{
- return m_private->m_family;
-}
-
-const LOGFONT& FontPlatformData::logFont() const
-{
- return m_private->m_rootFontData->m_font;
-}
-
-bool FontPlatformData::isDisabled() const
-{
- return !isValid() || m_private->m_disabled;
-}
-
-DWORD FontPlatformData::codePages() const
-{
- return m_private->m_rootFontData->m_codePages;
-}
-
-bool FontPlatformData::isSongTiSupported()
-{
- static bool exists = FontFamilyChecker(songTiStr).isSupported();
- return exists;
-}
-
-bool FontPlatformData::mapKnownFont(DWORD codePages, String& family)
-{
- KnownFonts& fonts = knownFonts();
- for (KnownFonts::iterator i = fonts.begin(); i != fonts.end(); ++i) {
- if (i->codePages() & codePages) {
- family = i->m_family;
- return true;
- }
- }
- return false;
-}
-
-DWORD FontPlatformData::getKnownFontCodePages(const wchar_t* family)
-{
- KnownFonts& fonts = knownFonts();
- for (KnownFonts::iterator i = fonts.begin(); i != fonts.end(); ++i) {
- if (equalIgnoringCase(i->m_family, String(family)))
- return i->codePages();
- }
- return 0;
-}
-
-const String& FontPlatformData::defaultFontFamily()
-{
- static String family(getDefaultFontFamily());
- return family;
-}
-
-LONG FontPlatformData::adjustedGDIFontWeight(LONG gdiFontWeight, const String& family)
-{
- static AtomicString lucidaStr("Lucida Grande");
- if (equalIgnoringCase(family, lucidaStr)) {
- if (gdiFontWeight == FW_NORMAL)
- return FW_MEDIUM;
- if (gdiFontWeight == FW_BOLD)
- return FW_SEMIBOLD;
- }
- return gdiFontWeight;
-}
-
-#ifndef NDEBUG
-String FontPlatformData::description() const
-{
- return String();
-}
-#endif
-
-}
+++ /dev/null
-/*
- * This file is part of the internal font implementation. It should not be included by anyone other than
- * FontMac.cpp, FontWin.cpp and Font.cpp.
- *
- * Copyright (C) 2006, 2007 Apple Inc.
- * Copyright (C) 2007-2008 Torch Mobile, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#ifndef FontPlatformData_h
-#define FontPlatformData_h
-
-#include "FontDescription.h"
-#include "FontOrientation.h"
-#include <wtf/Forward.h>
-#include <wtf/Noncopyable.h>
-#include <wtf/text/StringImpl.h>
-
-typedef struct tagTEXTMETRICW TEXTMETRIC;
-typedef struct tagLOGFONTW LOGFONT;
-
-namespace WebCore {
-
- class FontPlatformPrivateData;
-
- class FontPlatformData {
-
- public:
-
- FontPlatformData(): m_private(0) {}
- FontPlatformData(float size, bool bold, bool oblique);
-
- // Used for deleted values in the font cache's hash tables.
- FontPlatformData(WTF::HashTableDeletedValueType) : m_private((FontPlatformPrivateData*)1) {}
- bool isHashTableDeletedValue() const { return (unsigned)m_private == 1; }
-
- FontPlatformData(const FontDescription& fontDescription, const AtomicString& family, bool useDefaultFontIfNotPresent = true);
-
- ~FontPlatformData();
-
- FontPlatformData(const FontPlatformData& o) : m_private(0) { operator=(o); }
- FontPlatformData& operator=(const FontPlatformData& o);
-
- int isValid() const { return reinterpret_cast<unsigned>(m_private) & ~1; }
- HFONT hfont() const;
- const TEXTMETRIC& metrics() const;
- bool isSystemFont() const;
- int size() const;
- unsigned hash() const { return (unsigned)m_private; }
- const FontDescription& fontDescription() const;
- const AtomicString& family() const;
- bool operator==(const FontPlatformData& other) const { return m_private == other.m_private; }
- HFONT getScaledFontHandle(int height, int width) const;
- const LOGFONT& logFont() const;
- bool isDisabled() const;
- bool discardFontHandle();
- DWORD codePages() const;
-
- static bool isSongTiSupported();
- static bool mapKnownFont(DWORD codePages, String& family);
- static DWORD getKnownFontCodePages(const wchar_t* family);
- static const String& defaultFontFamily();
- static LONG adjustedGDIFontWeight(LONG gdiFontWeight, const String& family);
-
- FontOrientation orientation() const { return Horizontal; } // FIXME: Implement.
- void setOrientation(FontOrientation) { } // FIXME: Implement.
-
-#ifndef NDEBUG
- String description() const;
-#endif
-
- private:
- FontPlatformPrivateData* m_private;
- };
-
-}
-
-#endif
+++ /dev/null
-/*
- * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
- * Copyright (C) 2007-2009 Torch Mobile, Inc.
- * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
- * Copyright (C) 2008 Holger Hans Peter Freyther
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "Font.h"
-
-#include "AffineTransform.h"
-#include "FloatRect.h"
-#include "FontCache.h"
-#include "FontData.h"
-#include "FontGlyphs.h"
-#include "GlyphBuffer.h"
-#include "GraphicsContext.h"
-#include "IntRect.h"
-#include "NotImplemented.h"
-#include "TextRun.h"
-#include "WidthIterator.h"
-#include <wtf/MathExtras.h>
-#include <wtf/OwnPtr.h>
-
-#include <windows.h>
-
-using namespace WTF::Unicode;
-
-namespace WebCore {
-
-HDC g_screenDC = GetDC(0);
-
-class ScreenDcReleaser {
-public:
- ~ScreenDcReleaser()
- {
- ReleaseDC(0, g_screenDC);
- }
-};
-
-ScreenDcReleaser releaseScreenDc;
-
-void Font::drawGlyphs(GraphicsContext* graphicsContext, const SimpleFontData* fontData, const GlyphBuffer& glyphBuffer,
- int from, int numGlyphs, const FloatPoint& point) const
-{
- graphicsContext->drawText(fontData, glyphBuffer, from, numGlyphs, point);
-}
-
-class TextRunComponent {
-public:
- TextRunComponent() : m_textRun(0, 0) {}
- TextRunComponent(const UChar *start, int length, const TextRun& parentTextRun, const Font &font, int offset);
- TextRunComponent(int spaces, const Font &font, int offset);
- ~TextRunComponent() { m_textRun; }
-
- bool isSpace() const { return m_spaces; }
- int textLength() const { return m_spaces ? m_spaces : m_textRun.length(); }
-
- TextRun m_textRun;
- float m_width;
- int m_offset;
- int m_spaces;
-};
-
-TextRunComponent::TextRunComponent(const UChar *start, int length, const TextRun& parentTextRun, const Font &font, int o)
- : m_textRun(start, length, 0, 0
- , parentTextRun.allowsTrailingExpansion() ? TextRun::AllowTrailingExpansion : TextRun::ForbidTrailingExpansion
- , parentTextRun.direction()
- , parentTextRun.directionalOverride())
- , m_offset(o)
- , m_spaces(0)
-{
- m_textRun.setTabSize(parentTextRun.allowTabs(), parentTextRun.tabSize());
-
- WidthIterator it(&font, m_textRun);
- it.advance(m_textRun.length(), 0);
- m_width = it.m_runWidthSoFar;
-}
-
-TextRunComponent::TextRunComponent(int s, const Font &font, int o)
- : m_textRun(0, 0)
- , m_offset(o)
- , m_spaces(s)
-{
- m_width = s * font.primaryFont()->widthForGlyph(' ');
-}
-
-typedef Vector<TextRunComponent, 128> TextRunComponents;
-
-static int generateComponents(TextRunComponents* components, const Font &font, const TextRun &run)
-{
- int letterSpacing = font.letterSpacing();
- int wordSpacing = font.wordSpacing();
- int padding = run.expansion();
- int numSpaces = 0;
- if (padding) {
- for (int i = 0; i < run.length(); i++)
- if (Font::treatAsSpace(run[i]))
- ++numSpaces;
- }
-
- int offset = 0;
- if (letterSpacing) {
- // need to draw every letter on it's own
- int start = 0;
- if (Font::treatAsSpace(run[0])) {
- int add = 0;
- if (numSpaces) {
- add = padding/numSpaces;
- padding -= add;
- --numSpaces;
- }
- components->append(TextRunComponent(1, font, offset));
- offset += add + letterSpacing + components->last().m_width;
- start = 1;
- }
- for (int i = 1; i < run.length(); ++i) {
- UChar ch = run[i];
- if (U16_IS_LEAD(ch) && U16_IS_TRAIL(run[i-1]))
- ch = U16_GET_SUPPLEMENTARY(ch, run[i-1]);
- if (U16_IS_TRAIL(ch) || U_GET_GC_MASK(ch) & U_GC_MN_MASK)
- continue;
- if (Font::treatAsSpace(run[i])) {
- int add = 0;
- if (i - start > 0) {
- components->append(TextRunComponent(run.characters16() + start, i - start,
- run, font, offset));
- offset += components->last().m_width + letterSpacing;
- }
- if (numSpaces) {
- add = padding/numSpaces;
- padding -= add;
- --numSpaces;
- }
- components->append(TextRunComponent(1, font, offset));
- offset += wordSpacing + add + components->last().m_width + letterSpacing;
- start = i + 1;
- continue;
- }
- if (i - start > 0) {
- components->append(TextRunComponent(run.characters16() + start, i - start,
- run,
- font, offset));
- offset += components->last().m_width + letterSpacing;
- }
- start = i;
- }
- if (run.length() - start > 0) {
- components->append(TextRunComponent(run.characters16() + start, run.length() - start,
- run,
- font, offset));
- offset += components->last().m_width;
- }
- offset += letterSpacing;
- } else {
- int start = 0;
- for (int i = 0; i < run.length(); ++i) {
- if (Font::treatAsSpace(run[i])) {
- if (i - start > 0) {
- components->append(TextRunComponent(run.characters16() + start, i - start,
- run,
- font, offset));
- offset += components->last().m_width;
- }
- int add = 0;
- if (numSpaces) {
- add = padding/numSpaces;
- padding -= add;
- --numSpaces;
- }
- components->append(TextRunComponent(1, font, offset));
- offset += add + components->last().m_width;
- if (i)
- offset += wordSpacing;
- start = i + 1;
- }
- }
- if (run.length() - start > 0) {
- components->append(TextRunComponent(run.characters16() + start, run.length() - start,
- run,
- font, offset));
- offset += components->last().m_width;
- }
- }
- return offset;
-}
-
-float Font::drawComplexText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to) const
-{
- if (to < 0)
- to = run.length();
- if (from < 0)
- from = 0;
-
- TextRunComponents components;
- int w = generateComponents(&components, *this, run);
-
- float widthOfDrawnText = 0;
- int curPos = 0;
- for (int i = 0; i < (int)components.size(); ++i) {
- const TextRunComponent& comp = components.at(i);
- int len = comp.textLength();
- int curEnd = curPos + len;
- if (curPos < to && from < curEnd && !comp.isSpace()) {
- FloatPoint pt = point;
- if (run.rtl())
- pt.setX(point.x() + w - comp.m_offset - comp.m_width);
- else
- pt.setX(point.x() + comp.m_offset);
- widthOfDrawnText += drawSimpleText(context, comp.m_textRun, pt, from - curPos, std::min(to, curEnd) - curPos);
- }
- curPos += len;
- if (from < curPos)
- from = curPos;
- }
- return widthOfDrawnText;
-}
-
-void Font::drawEmphasisMarksForComplexText(GraphicsContext* /* context */, const TextRun& /* run */, const AtomicString& /* mark */, const FloatPoint& /* point */, int /* from */, int /* to */) const
-{
- notImplemented();
-}
-
-float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
-{
- TextRunComponents components;
- int w = generateComponents(&components, *this, run);
- return w;
-}
-
-int Font::offsetForPositionForComplexText(const TextRun& run, float xFloat, bool includePartialGlyphs) const
-{
- // FIXME: This truncation is not a problem for HTML, but only affects SVG, which passes floating-point numbers
- // to Font::offsetForPosition(). Bug http://webkit.org/b/40673 tracks fixing this problem.
- int position = static_cast<int>(xFloat);
-
- TextRunComponents components;
- int w = generateComponents(&components, *this, run);
-
- if (position >= w)
- return run.length();
-
- int offset = 0;
- if (run.rtl()) {
- for (size_t i = 0; i < components.size(); ++i) {
- const TextRunComponent& comp = components.at(i);
- int xe = w - comp.m_offset;
- int xs = xe - comp.m_width;
- if (position >= xs)
- return offset + (comp.isSpace()
- ? static_cast<int>((position - xe) * comp.m_spaces / std::max(1.f, comp.m_width) + 0.5)
- : offsetForPositionForSimpleText(comp.m_textRun, position - xs, includePartialGlyphs));
-
- offset += comp.textLength();
- }
- } else {
- for (size_t i = 0; i < components.size(); ++i) {
- const TextRunComponent& comp = components.at(i);
- int xs = comp.m_offset;
- int xe = xs + comp.m_width;
- if (position <= xe) {
- if (position - xs >= xe)
- return offset + comp.textLength();
- return offset + (comp.isSpace()
- ? static_cast<int>((position - xs) * comp.m_spaces / std::max(1.f, comp.m_width) + 0.5)
- : offsetForPositionForSimpleText(comp.m_textRun, position - xs, includePartialGlyphs));
- }
- offset += comp.textLength();
- }
- }
- return run.length();
-}
-
-
-static float cursorToX(const Font* font, const TextRunComponents& components, int width, bool rtl, int cursor)
-{
- int start = 0;
- for (size_t i = 0; i < components.size(); ++i) {
- const TextRunComponent& comp = components.at(i);
- if (start + comp.textLength() <= cursor) {
- start += comp.textLength();
- continue;
- }
- int xs = comp.m_offset;
- if (rtl)
- xs = width - xs - comp.m_width;
-
- int pos = cursor - start;
- if (comp.isSpace()) {
- if (rtl)
- pos = comp.textLength() - pos;
- return xs + pos * comp.m_width / comp.m_spaces;
- }
- WidthIterator it(font, comp.m_textRun);
- GlyphBuffer glyphBuffer;
- it.advance(pos, &glyphBuffer);
- return xs + it.m_runWidthSoFar;
- }
- return width;
-}
-
-FloatRect Font::selectionRectForComplexText(const TextRun& run, const FloatPoint& pt,
- int h, int from, int to) const
-{
- TextRunComponents components;
- int w = generateComponents(&components, *this, run);
-
- if (!from && to == run.length())
- return FloatRect(pt.x(), pt.y(), w, h);
-
- float x1 = cursorToX(this, components, w, run.rtl(), from);
- float x2 = cursorToX(this, components, w, run.rtl(), to);
- if (x2 < x1)
- std::swap(x1, x2);
-
- return FloatRect(pt.x() + x1, pt.y(), x2 - x1, h);
-}
-
-bool Font::canReturnFallbackFontsForComplexText()
-{
- return false;
-}
-
-bool Font::canExpandAroundIdeographsInComplexText()
-{
- return false;
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#include "config.h"
-#include "GlyphPageTreeNode.h"
-
-#include "Font.h"
-#include "FontCache.h"
-#include "FontData.h"
-#include "SimpleFontData.h"
-
-namespace WebCore {
-
-DWORD getKnownFontCodePages(const wchar_t* family);
-
-typedef unsigned (*funcGetCharCodePages)(unsigned short c, unsigned& lastPos);
-funcGetCharCodePages getCharCodePages = 0;
-
-bool GlyphPage::fill(unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const SimpleFontData* fontData)
-{
- if (length != bufferLength)
- return false;
-
- if (fontData->platformData().hfont()) {
- DWORD fontCodePages = fontData->platformData().codePages();
- if (fontCodePages) {
- if (getCharCodePages) {
- unsigned lastPos = 0;
- for (unsigned i = 0; i < bufferLength; ++i) {
- DWORD actualCodePages = getCharCodePages(buffer[i], lastPos);
- if (!actualCodePages || (actualCodePages & fontCodePages))
- setGlyphDataForIndex(offset + i, buffer[i], fontData);
- else
- setGlyphDataForIndex(offset + i, 0, 0);
- }
- return true;
- } else if (IMLangFontLinkType* langFontLink = fontCache().getFontLinkInterface()) {
- for (unsigned i = 0; i < bufferLength; ++i) {
- DWORD actualCodePages;
- langFontLink->GetCharCodePages(buffer[i], &actualCodePages);
- if (!actualCodePages || (actualCodePages & fontCodePages))
- setGlyphDataForIndex(offset + i, buffer[i], fontData);
- else
- setGlyphDataForIndex(offset + i, 0, 0);
- }
- return true;
- }
- }
- }
-
- for (unsigned i = 0; i < length; ++i)
- setGlyphDataForIndex(offset + i, buffer[i], fontData);
-
- return true;
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-
-#include "config.h"
-#include "Gradient.h"
-
-#include "GraphicsContext.h"
-
-namespace WebCore {
-
-void Gradient::platformDestroy()
-{
-}
-
-static inline bool compareStops(const Gradient::ColorStop& a, const Gradient::ColorStop& b)
-{
- return a.stop < b.stop;
-}
-
-const Vector<Gradient::ColorStop, 2>& Gradient::getStops() const
-{
- if (!m_stopsSorted) {
- if (m_stops.size())
- std::stable_sort(m_stops.begin(), m_stops.end(), compareStops);
- m_stopsSorted = true;
- }
- return m_stops;
-}
-
-void Gradient::fill(GraphicsContext* c, const FloatRect& r)
-{
- c->fillRect(r, this);
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile Inc.
- * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#include "config.h"
-#include "GraphicsContext.h"
-
-#include "AffineTransform.h"
-#include "FloatRoundedRect.h"
-#include "Font.h"
-#include "GDIExtras.h"
-#include "GlyphBuffer.h"
-#include "Gradient.h"
-#include "NotImplemented.h"
-#include "Path.h"
-#include "PlatformPathWinCE.h"
-#include "SharedBitmap.h"
-#include "SimpleFontData.h"
-#include <windows.h>
-#include <wtf/OwnPtr.h>
-#include <wtf/unicode/CharacterNames.h>
-
-namespace WebCore {
-
-typedef void (*FuncGradientFillRectLinear)(HDC hdc, const IntRect& r, const IntPoint& p0, const IntPoint& p1, const Vector<Gradient::ColorStop>& stops);
-typedef void (*FuncGradientFillRectRadial)(HDC hdc, const IntRect& r, const IntPoint& p0, const IntPoint& p1, float r0, float r1, const Vector<Gradient::ColorStop>& stops);
-FuncGradientFillRectLinear g_linearGradientFiller = 0;
-FuncGradientFillRectRadial g_radialGradientFiller = 0;
-
-static inline bool isZero(double d)
-{
- return d > 0 ? d <= 1.E-10 : d >= -1.E-10;
-}
-
-// stableRound rounds -0.5 to 0, where lround rounds -0.5 to -1.
-static inline int stableRound(double d)
-{
- if (d > 0)
- return static_cast<int>(d + 0.5);
-
- int i = static_cast<int>(d);
- return i - d > 0.5 ? i - 1 : i;
-}
-
-// Unlike enclosingIntRect(), this function does strict rounding.
-static inline IntRect roundRect(const FloatRect& r)
-{
- return IntRect(stableRound(r.x()), stableRound(r.y()), stableRound(r.maxX()) - stableRound(r.x()), stableRound(r.maxY()) - stableRound(r.y()));
-}
-
-// Rotation transformation
-class RotationTransform {
-public:
- RotationTransform()
- : m_cosA(1.)
- , m_sinA(0.)
- , m_preShiftX(0)
- , m_preShiftY(0)
- , m_postShiftX(0)
- , m_postShiftY(0)
- {
- }
- RotationTransform operator-() const
- {
- RotationTransform rtn;
- rtn.m_cosA = m_cosA;
- rtn.m_sinA = -m_sinA;
- rtn.m_preShiftX = m_postShiftX;
- rtn.m_preShiftY = m_postShiftY;
- rtn.m_postShiftX = m_preShiftX;
- rtn.m_postShiftY = m_preShiftY;
- return rtn;
- }
- void map(double x1, double y1, double* x2, double* y2) const
- {
- x1 += m_preShiftX;
- y1 += m_preShiftY;
- *x2 = x1 * m_cosA + y1 * m_sinA + m_postShiftX;
- *y2 = y1 * m_cosA - x1 * m_sinA + m_postShiftY;
- }
- void map(int x1, int y1, int* x2, int* y2) const
- {
- x1 += m_preShiftX;
- y1 += m_preShiftY;
- *x2 = stableRound(x1 * m_cosA + y1 * m_sinA) + m_postShiftX;
- *y2 = stableRound(y1 * m_cosA - x1 * m_sinA) + m_postShiftY;
- }
-
- double m_cosA;
- double m_sinA;
- int m_preShiftX;
- int m_preShiftY;
- int m_postShiftX;
- int m_postShiftY;
-};
-
-template<class T> static inline IntPoint mapPoint(const IntPoint& p, const T& t)
-{
- int x, y;
- t.map(p.x(), p.y(), &x, &y);
- return IntPoint(x, y);
-}
-
-template<class T> static inline FloatPoint mapPoint(const FloatPoint& p, const T& t)
-{
- double x, y;
- t.map(p.x(), p.y(), &x, &y);
- return FloatPoint(static_cast<float>(x), static_cast<float>(y));
-}
-
-template<class Transform, class Rect, class Value> static inline Rect mapRect(const Rect& rect, const Transform& transform)
-{
- Value x[4], y[4];
- Value l, t, r, b;
- r = rect.maxX() - 1;
- b = rect.maxY() - 1;
- transform.map(rect.x(), rect.y(), x, y);
- transform.map(rect.x(), b, x + 1, y + 1);
- transform.map(r, b, x + 2, y + 2);
- transform.map(r, rect.y(), x + 3, y + 3);
- l = r = x[3];
- t = b = y[3];
- for (int i = 0; i < 3; ++i) {
- if (x[i] < l)
- l = x[i];
- else if (x[i] > r)
- r = x[i];
-
- if (y[i] < t)
- t = y[i];
- else if (y[i] > b)
- b = y[i];
- }
-
- return IntRect(l, t, r - l + 1, b - t + 1);
-}
-
-template<class T> static inline IntRect mapRect(const IntRect& rect, const T& transform)
-{
- return mapRect<T, IntRect, int>(rect, transform);
-}
-
-template<class T> static inline FloatRect mapRect(const FloatRect& rect, const T& transform)
-{
- return mapRect<T, FloatRect, double>(rect, transform);
-}
-
-class GraphicsContextPlatformPrivateData {
-public:
- GraphicsContextPlatformPrivateData()
- : m_transform()
- , m_opacity(1.0)
- {
- }
-
- AffineTransform m_transform;
- float m_opacity;
-};
-
-enum AlphaPaintType {
- AlphaPaintNone,
- AlphaPaintImage,
- AlphaPaintOther,
-};
-
-class GraphicsContextPlatformPrivate : public GraphicsContextPlatformPrivateData {
-public:
- GraphicsContextPlatformPrivate(HDC dc)
- : m_dc(dc)
- {
- }
- ~GraphicsContextPlatformPrivate()
- {
- while (!m_backupData.isEmpty())
- restore();
- }
-
- void translate(float x, float y)
- {
- m_transform.translate(x, y);
- }
-
- void scale(const FloatSize& size)
- {
- m_transform.scaleNonUniform(size.width(), size.height());
- }
-
- void rotate(float radians)
- {
- m_transform.rotate(rad2deg(radians));
- }
-
- void concatCTM(const AffineTransform& transform)
- {
- m_transform *= transform;
- }
-
- void setCTM(const AffineTransform& transform)
- {
- m_transform = transform;
- }
-
- IntRect mapRect(const IntRect& rect) const
- {
- return m_transform.mapRect(rect);
- }
-
- FloatRect mapRect(const FloatRect& rect) const
- {
- return m_transform.mapRect(rect);
- }
-
- IntPoint mapPoint(const IntPoint& point) const
- {
- return m_transform.mapPoint(point);
- }
-
- FloatPoint mapPoint(const FloatPoint& point) const
- {
- return m_transform.mapPoint(point);
- }
-
- FloatSize mapSize(const FloatSize& size) const
- {
- double w, h;
- m_transform.map(size.width(), size.height(), w, h);
- return FloatSize(static_cast<float>(w), static_cast<float>(h));
- }
-
- void save()
- {
- if (m_dc)
- SaveDC(m_dc);
-
- m_backupData.append(*static_cast<GraphicsContextPlatformPrivateData*>(this));
- }
-
- void restore()
- {
- if (m_backupData.isEmpty())
- return;
-
- if (m_dc)
- RestoreDC(m_dc, -1);
-
- GraphicsContextPlatformPrivateData::operator=(m_backupData.last());
- m_backupData.removeLast();
- }
-
- bool hasAlpha() const { return m_bitmap && m_bitmap->hasAlpha(); }
-
- PassRefPtr<SharedBitmap> getTransparentLayerBitmap(IntRect& origRect, AlphaPaintType alphaPaint, RECT& bmpRect, bool checkClipBox, bool force) const
- {
- if (m_opacity <= 0)
- return 0;
-
- if (force || m_opacity < 1.) {
- if (checkClipBox) {
- RECT clipBox;
- int clipType = GetClipBox(m_dc, &clipBox);
- if (clipType == SIMPLEREGION || clipType == COMPLEXREGION)
- origRect.intersect(clipBox);
- if (origRect.isEmpty())
- return 0;
- }
-
- RefPtr<SharedBitmap> bmp = SharedBitmap::create(origRect.size(), alphaPaint == AlphaPaintNone ? BitmapInfo::BitCount16 : BitmapInfo::BitCount32, false);
- SetRect(&bmpRect, 0, 0, origRect.width(), origRect.height());
- if (bmp) {
- switch (alphaPaint) {
- case AlphaPaintNone:
- case AlphaPaintImage:
- {
- SharedBitmap::DCHolder dc(bmp.get());
- if (dc.get()) {
- BitBlt(dc.get(), 0, 0, origRect.width(), origRect.height(), m_dc, origRect.x(), origRect.y(), SRCCOPY);
- if (bmp->is32bit() && (!m_bitmap || m_bitmap->is16bit())) {
- // Set alpha channel
- unsigned* pixels = (unsigned*)bmp->bytes();
- const unsigned* const pixelsEnd = pixels + bmp->bitmapInfo().numPixels();
- while (pixels < pixelsEnd) {
- *pixels |= 0xFF000000;
- ++pixels;
- }
- }
- return bmp;
- }
- }
- break;
- //case AlphaPaintOther:
- default:
- memset(bmp->bytes(), 0xFF, bmp->bitmapInfo().numPixels() * 4);
- return bmp;
- break;
- }
- }
- }
-
- bmpRect = origRect;
- return 0;
- }
-
- void paintBackTransparentLayerBitmap(HDC hdc, SharedBitmap* bmp, const IntRect& origRect, AlphaPaintType alphaPaint, const RECT& bmpRect)
- {
- if (hdc == m_dc)
- return;
-
- if (alphaPaint == AlphaPaintOther && hasAlphaBlendSupport()) {
- ASSERT(bmp && bmp->bytes() && bmp->is32bit());
- unsigned* pixels = (unsigned*)bmp->bytes();
- const unsigned* const pixelsEnd = pixels + bmp->bitmapInfo().numPixels();
- while (pixels < pixelsEnd) {
- *pixels ^= 0xFF000000;
- ++pixels;
- }
- }
- if ((m_opacity < 1. || alphaPaint == AlphaPaintOther) && hasAlphaBlendSupport()) {
- const BLENDFUNCTION blend = { AC_SRC_OVER, 0
- , m_opacity >= 1. ? 255 : (BYTE)(m_opacity * 255)
- , alphaPaint == AlphaPaintNone ? 0 : AC_SRC_ALPHA };
- bool success = alphaBlendIfSupported(m_dc, origRect.x(), origRect.y(), origRect.width(), origRect.height(), hdc, 0, 0, bmpRect.right, bmpRect.bottom, blend);
- ASSERT_UNUSED(success, success);
- } else
- StretchBlt(m_dc, origRect.x(), origRect.y(), origRect.width(), origRect.height(), hdc, 0, 0, bmpRect.right, bmpRect.bottom, SRCCOPY);
- }
-
- HDC m_dc;
- RefPtr<SharedBitmap> m_bitmap;
- Vector<GraphicsContextPlatformPrivateData> m_backupData;
-};
-
-static GDIObject<HPEN> createPen(const Color& col, double fWidth, StrokeStyle style)
-{
- int width = stableRound(fWidth);
- if (width < 1)
- width = 1;
-
- int penStyle = PS_NULL;
- switch (style) {
- case SolidStroke:
- case DoubleStroke:
- case WavyStroke: // FIXME: https://bugs.webkit.org/show_bug.cgi?id=94114 - Needs platform support.
- penStyle = PS_SOLID;
- break;
- case DottedStroke: // not supported on Windows CE
- case DashedStroke:
- penStyle = PS_DASH;
- width = 1;
- break;
- default:
- break;
- }
-
- return adoptGDIObject(::CreatePen(penStyle, width, RGB(col.red(), col.green(), col.blue())));
-}
-
-static inline GDIObject<HBRUSH> createBrush(const Color& col)
-{
- return adoptGDIObject(::CreateSolidBrush(RGB(col.red(), col.green(), col.blue())));
-}
-
-template <typename PixelType, bool Is16bit> static void _rotateBitmap(SharedBitmap* destBmp, const SharedBitmap* sourceBmp, const RotationTransform& transform)
-{
- int destW = destBmp->width();
- int destH = destBmp->height();
- int sourceW = sourceBmp->width();
- int sourceH = sourceBmp->height();
- PixelType* dest = (PixelType*)destBmp->bytes();
- const PixelType* source = (const PixelType*)sourceBmp->bytes();
- int padding;
- int paddedSourceW;
- if (Is16bit) {
- padding = destW & 1;
- paddedSourceW = sourceW + (sourceW & 1);
- } else {
- padding = 0;
- paddedSourceW = sourceW;
- }
- if (isZero(transform.m_sinA)) {
- int cosA = transform.m_cosA > 0 ? 1 : -1;
- for (int y = 0; y < destH; ++y) {
- for (int x = 0; x < destW; ++x) {
- int x1 = x + transform.m_preShiftX;
- int y1 = y + transform.m_preShiftY;
- int srcX = x1 * cosA + transform.m_postShiftX;
- int srcY = y1 * cosA - transform.m_postShiftY;
- if (srcX >= 0 && srcX <= sourceW && srcY >= 0 && srcY <= sourceH)
- *dest++ = source[srcY * paddedSourceW + srcX] | 0xFF000000;
- else
- *dest++ |= 0xFF;
- }
- dest += padding;
- }
- } else if (isZero(transform.m_cosA)) {
- int sinA = transform.m_sinA > 0 ? 1 : -1;
- for (int y = 0; y < destH; ++y) {
- for (int x = 0; x < destW; ++x) {
- int x1 = x + transform.m_preShiftX;
- int y1 = y + transform.m_preShiftY;
- int srcX = y1 * sinA + transform.m_postShiftX;
- int srcY = -x1 * sinA + transform.m_postShiftY;
- if (srcX >= 0 && srcX <= sourceW && srcY >= 0 && srcY <= sourceH)
- *dest++ = source[srcY * paddedSourceW + srcX];
- }
- dest += padding;
- }
- } else {
- for (int y = 0; y < destH; ++y) {
- for (int x = 0; x < destW; ++x) {
- // FIXME: for best quality, we should get weighted sum of four neighbours,
- // but that will be too expensive
- int srcX, srcY;
- transform.map(x, y, &srcX, &srcY);
- if (srcX >= 0 && srcX <= sourceW && srcY >= 0 && srcY <= sourceH)
- *dest++ = source[srcY * paddedSourceW + srcX];
- }
- dest += padding;
- }
- }
-}
-
-static void rotateBitmap(SharedBitmap* destBmp, const SharedBitmap* sourceBmp, const RotationTransform& transform)
-{
- ASSERT(destBmp->is16bit() == sourceBmp->is16bit());
- if (destBmp->is16bit())
- _rotateBitmap<unsigned short, true>(destBmp, sourceBmp, transform);
- else
- _rotateBitmap<unsigned, false>(destBmp, sourceBmp, transform);
-}
-
-class TransparentLayerDC {
- WTF_MAKE_NONCOPYABLE(TransparentLayerDC);
-public:
- TransparentLayerDC(GraphicsContextPlatformPrivate* data, IntRect& origRect, const IntRect* rectBeforeTransform = 0, int alpha = 255, bool paintImage = false);
- ~TransparentLayerDC();
-
- HDC hdc() const { return m_memDc; }
- const RECT& rect() const { return m_bmpRect; }
- IntSize toShift() const { return IntSize(m_bmpRect.left - m_origRect.x(), m_bmpRect.top - m_origRect.y()); }
- void fillAlphaChannel();
-
-private:
- GraphicsContextPlatformPrivate* m_data;
- IntRect m_origRect;
- IntRect m_rotatedOrigRect;
- HDC m_memDc;
- RefPtr<SharedBitmap> m_bitmap;
- RefPtr<SharedBitmap> m_rotatedBitmap;
- RECT m_bmpRect;
- unsigned m_key;
- RotationTransform m_rotation;
- float m_oldOpacity;
- AlphaPaintType m_alphaPaintType;
-};
-
-TransparentLayerDC::TransparentLayerDC(GraphicsContextPlatformPrivate* data, IntRect& origRect, const IntRect* rectBeforeTransform, int alpha, bool paintImage)
-: m_data(data)
-, m_origRect(origRect)
-, m_oldOpacity(data->m_opacity)
-// m_key1 and m_key2 are not initalized here. They are used only in the case that
-// SharedBitmap::getDC() is called, I.E., when m_bitmap is not null.
-{
- m_data->m_opacity *= alpha / 255.;
- bool mustCreateLayer;
- if (!m_data->hasAlpha()) {
- mustCreateLayer = false;
- m_alphaPaintType = AlphaPaintNone;
- } else {
- mustCreateLayer = true;
- m_alphaPaintType = paintImage ? AlphaPaintImage : AlphaPaintOther;
- }
- if (rectBeforeTransform && !isZero(m_data->m_transform.b())) {
- m_rotatedOrigRect = origRect;
- m_rotatedBitmap = m_data->getTransparentLayerBitmap(m_rotatedOrigRect, m_alphaPaintType, m_bmpRect, false, true);
- if (m_rotatedBitmap) {
- double a = m_data->m_transform.a();
- double b = m_data->m_transform.b();
- double c = _hypot(a, b);
- m_rotation.m_cosA = a / c;
- m_rotation.m_sinA = b / c;
-
- int centerX = origRect.x() + origRect.width() / 2;
- int centerY = origRect.y() + origRect.height() / 2;
- m_rotation.m_preShiftX = -centerX;
- m_rotation.m_preShiftY = -centerY;
- m_rotation.m_postShiftX = centerX;
- m_rotation.m_postShiftY = centerY;
-
- m_origRect = mapRect(m_rotatedOrigRect, m_rotation);
-
- m_rotation.m_preShiftX += m_rotatedOrigRect.x();
- m_rotation.m_preShiftY += m_rotatedOrigRect.y();
- m_rotation.m_postShiftX -= m_origRect.x();
- m_rotation.m_postShiftY -= m_origRect.y();
-
- FloatPoint topLeft = m_data->m_transform.mapPoint(FloatPoint(rectBeforeTransform->location()));
- FloatPoint topRight(rectBeforeTransform->maxX() - 1, rectBeforeTransform->y());
- topRight = m_data->m_transform.mapPoint(topRight);
- FloatPoint bottomLeft(rectBeforeTransform->x(), rectBeforeTransform->maxY() - 1);
- bottomLeft = m_data->m_transform.mapPoint(bottomLeft);
- FloatSize sideTop = topRight - topLeft;
- FloatSize sideLeft = bottomLeft - topLeft;
- float width = _hypot(sideTop.width() + 1, sideTop.height() + 1);
- float height = _hypot(sideLeft.width() + 1, sideLeft.height() + 1);
-
- origRect.inflateX(stableRound((width - origRect.width()) * 0.5));
- origRect.inflateY(stableRound((height - origRect.height()) * 0.5));
-
- m_bitmap = SharedBitmap::create(m_origRect.size(), m_rotatedBitmap->is16bit() ? BitmapInfo::BitCount16 : BitmapInfo::BitCount32, true);
- if (m_bitmap)
- rotateBitmap(m_bitmap.get(), m_rotatedBitmap.get(), -m_rotation);
- else
- m_rotatedBitmap = 0;
- }
- } else
- m_bitmap = m_data->getTransparentLayerBitmap(m_origRect, m_alphaPaintType, m_bmpRect, true, mustCreateLayer);
- if (m_bitmap)
- m_memDc = m_bitmap->getDC(&m_key);
- else
- m_memDc = m_data->m_dc;
-}
-
-TransparentLayerDC::~TransparentLayerDC()
-{
- if (m_rotatedBitmap) {
- m_bitmap->releaseDC(m_memDc, m_key);
- m_key = 0;
- rotateBitmap(m_rotatedBitmap.get(), m_bitmap.get(), m_rotation);
- m_memDc = m_rotatedBitmap->getDC(&m_key);
- m_data->paintBackTransparentLayerBitmap(m_memDc, m_rotatedBitmap.get(), m_rotatedOrigRect, m_alphaPaintType, m_bmpRect);
- m_rotatedBitmap->releaseDC(m_memDc, m_key);
- } else if (m_bitmap) {
- m_data->paintBackTransparentLayerBitmap(m_memDc, m_bitmap.get(), m_origRect, m_alphaPaintType, m_bmpRect);
- m_bitmap->releaseDC(m_memDc, m_key);
- }
- m_data->m_opacity = m_oldOpacity;
-}
-
-void TransparentLayerDC::fillAlphaChannel()
-{
- if (!m_bitmap || !m_bitmap->is32bit())
- return;
-
- unsigned* pixels = (unsigned*)m_bitmap->bytes();
- const unsigned* const pixelsEnd = pixels + m_bitmap->bitmapInfo().numPixels();
- while (pixels < pixelsEnd) {
- *pixels |= 0xFF000000;
- ++pixels;
- }
-}
-
-class ScopeDCProvider {
- WTF_MAKE_NONCOPYABLE(ScopeDCProvider);
-public:
- explicit ScopeDCProvider(GraphicsContextPlatformPrivate* data)
- : m_data(data)
- {
- if (m_data->m_bitmap)
- m_data->m_dc = m_data->m_bitmap->getDC(&m_key);
- }
- ~ScopeDCProvider()
- {
- if (m_data->m_bitmap) {
- m_data->m_bitmap->releaseDC(m_data->m_dc, m_key);
- m_data->m_dc = 0;
- }
- }
-private:
- GraphicsContextPlatformPrivate* m_data;
- unsigned m_key;
-};
-
-
-void GraphicsContext::platformInit(PlatformGraphicsContext* dc, bool)
-{
- m_data = new GraphicsContextPlatformPrivate(dc);
-}
-
-void GraphicsContext::platformDestroy()
-{
- delete m_data;
-}
-
-void GraphicsContext::setBitmap(PassRefPtr<SharedBitmap> bmp)
-{
- ASSERT(!m_data->m_dc);
- m_data->m_bitmap = bmp;
-}
-
-HDC GraphicsContext::getWindowsContext(const IntRect& dstRect, bool supportAlphaBlend, bool mayCreateBitmap)
-{
- // FIXME: Add support for AlphaBlend.
- ASSERT(!supportAlphaBlend);
- return m_data->m_dc;
-}
-
-void GraphicsContext::releaseWindowsContext(HDC hdc, const IntRect& dstRect, bool supportAlphaBlend, bool mayCreateBitmap)
-{
-}
-
-void GraphicsContext::savePlatformState()
-{
- m_data->save();
-}
-
-void GraphicsContext::restorePlatformState()
-{
- m_data->restore();
-}
-
-void GraphicsContext::drawRect(const FloatRect& rect, float)
-{
- if (!m_data->m_opacity || paintingDisabled() || rect.isEmpty())
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect trRect = m_data->mapRect(rect);
- TransparentLayerDC transparentDC(m_data, trRect, &rect);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- trRect.move(transparentDC.toShift());
-
- GDIObject<HBRUSH> brush;
- HGDIOBJ oldBrush;
- if (fillColor().alpha()) {
- brush = createBrush(fillColor());
- oldBrush = SelectObject(dc, brush.get());
- } else
- oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH));
-
- GDIObject<HPEN> pen;
- HGDIOBJ oldPen;
- if (strokeStyle() != NoStroke) {
- pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
- oldPen = SelectObject(dc, pen.get());
- } else
- oldPen = SelectObject(dc, GetStockObject(NULL_PEN));
-
- if (brush || pen) {
- if (trRect.width() <= 0)
- trRect.setWidth(1);
- if (trRect.height() <= 0)
- trRect.setHeight(1);
-
- Rectangle(dc, trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY());
- }
-
- SelectObject(dc, oldPen);
- SelectObject(dc, oldBrush);
-}
-
-void GraphicsContext::drawLine(const FloatPoint& point1, const FloatPoint& point2)
-{
- if (!m_data->m_opacity || paintingDisabled() || strokeStyle() == NoStroke || !strokeColor().alpha())
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntPoint trPoint1 = m_data->mapPoint(point1);
- IntPoint trPoint2 = m_data->mapPoint(point2);
-
- IntRect lineRect(trPoint1, trPoint2 - trPoint1);
- lineRect.setHeight(lineRect.height() + strokeThickness());
- TransparentLayerDC transparentDC(m_data, lineRect, 0, strokeColor().alpha());
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- trPoint1 += transparentDC.toShift();
- trPoint2 += transparentDC.toShift();
-
- auto pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
- HGDIOBJ oldPen = SelectObject(dc, pen.get());
-
- MoveToEx(dc, trPoint1.x(), trPoint1.y(), 0);
- LineTo(dc, trPoint2.x(), trPoint2.y());
-
- SelectObject(dc, oldPen);
-}
-
-void GraphicsContext::drawEllipse(const IntRect& rect)
-{
- if (!m_data->m_opacity || paintingDisabled() || (!fillColor().alpha() && strokeStyle() == NoStroke))
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect trRect = m_data->mapRect(rect);
- TransparentLayerDC transparentDC(m_data, trRect, &rect);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- trRect.move(transparentDC.toShift());
-
- GDIObject<HBRUSH> brush;
- HGDIOBJ oldBrush;
- if (fillColor().alpha()) {
- brush = createBrush(fillColor());
- oldBrush = SelectObject(dc, brush.get());
- } else
- oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH));
-
- GDIObject<HPEN> pen;
- HGDIOBJ oldPen = 0;
- if (strokeStyle() != NoStroke) {
- pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
- oldPen = SelectObject(dc, pen.get());
- } else
- oldPen = SelectObject(dc, GetStockObject(NULL_PEN));
-
- if (brush || pen)
- Ellipse(dc, trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY());
-
- SelectObject(dc, oldPen);
- SelectObject(dc, oldBrush);
-}
-
-static inline bool equalAngle(double a, double b)
-{
- return fabs(a - b) < 1E-5;
-}
-
-void getEllipsePointByAngle(double angle, double a, double b, float& x, float& y)
-{
- while (angle < 0)
- angle += 2 * piDouble;
- while (angle >= 2 * piDouble)
- angle -= 2 * piDouble;
-
- if (equalAngle(angle, 0) || equalAngle(angle, 2 * piDouble)) {
- x = a;
- y = 0;
- } else if (equalAngle(angle, piDouble)) {
- x = -a;
- y = 0;
- } else if (equalAngle(angle, .5 * piDouble)) {
- x = 0;
- y = b;
- } else if (equalAngle(angle, 1.5 * piDouble)) {
- x = 0;
- y = -b;
- } else {
- double k = tan(angle);
- double sqA = a * a;
- double sqB = b * b;
- double tmp = 1. / (1. / sqA + (k * k) / sqB);
- tmp = tmp <= 0 ? 0 : sqrt(tmp);
- if (angle > .5 * piDouble && angle < 1.5 * piDouble)
- tmp = -tmp;
- x = tmp;
-
- k = tan(.5 * piDouble - angle);
- tmp = 1. / ((k * k) / sqA + 1 / sqB);
- tmp = tmp <= 0 ? 0 : sqrt(tmp);
- if (angle > piDouble)
- tmp = -tmp;
- y = tmp;
- }
-}
-
-void GraphicsContext::drawConvexPolygon(size_t npoints, const FloatPoint* points, bool shouldAntialias)
-{
- if (!m_data->m_opacity || paintingDisabled() || npoints <= 1 || !points)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- Vector<POINT, 20> winPoints(npoints);
- FloatPoint trPoint = m_data->mapPoint(points[0]);
- winPoints[0].x = stableRound(trPoint.x());
- winPoints[0].y = stableRound(trPoint.y());
- RECT rect = { winPoints[0].x, winPoints[0].y, winPoints[0].x, winPoints[0].y };
- for (size_t i = 1; i < npoints; ++i) {
- trPoint = m_data->mapPoint(points[i]);
- winPoints[i].x = stableRound(trPoint.x());
- winPoints[i].y = stableRound(trPoint.y());
- if (rect.left > winPoints[i].x)
- rect.left = winPoints[i].x;
- else if (rect.right < winPoints[i].x)
- rect.right = winPoints[i].x;
- if (rect.top > winPoints[i].y)
- rect.top = winPoints[i].y;
- else if (rect.bottom < winPoints[i].y)
- rect.bottom = winPoints[i].y;
- }
- rect.bottom += 1;
- rect.right += 1;
-
- IntRect intRect(rect);
- TransparentLayerDC transparentDC(m_data, intRect);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
-
- for (size_t i = 0; i < npoints; ++i) {
- winPoints[i].x += transparentDC.toShift().width();
- winPoints[i].y += transparentDC.toShift().height();
- }
-
- GDIObject<HBRUSH> brush;
- HGDIOBJ oldBrush;
- if (fillColor().alpha()) {
- brush = createBrush(fillColor());
- oldBrush = SelectObject(dc, brush.get());
- } else
- oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH));
-
- GDIObject<HPEN> pen;
- HGDIOBJ oldPen;
- if (strokeStyle() != NoStroke) {
- pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
- oldPen = SelectObject(dc, pen.get());
- } else
- oldPen = SelectObject(dc, GetStockObject(NULL_PEN));
-
- if (brush || pen)
- Polygon(dc, winPoints.data(), npoints);
-
- SelectObject(dc, oldPen);
- SelectObject(dc, oldBrush);
-}
-
-void GraphicsContext::clipConvexPolygon(size_t numPoints, const FloatPoint* points, bool antialiased)
-{
- if (paintingDisabled())
- return;
-
- if (numPoints <= 1)
- return;
-
- // FIXME: IMPLEMENT!!
-}
-
-void GraphicsContext::fillRect(const FloatRect& rect, const Color& color, ColorSpace colorSpace)
-{
- if (paintingDisabled() || !m_data->m_opacity)
- return;
-
- int alpha = color.alpha();
- if (!alpha)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect intRect = enclosingIntRect(rect);
- TransparentLayerDC transparentDC(m_data, m_data->mapRect(intRect), &intRect, alpha);
-
- if (!transparentDC.hdc())
- return;
-
- auto hbrush = adoptGDIObject(::CreateSolidBrush(RGB(color.red(), color.green(), color.blue())));
- FillRect(transparentDC.hdc(), &transparentDC.rect(), hbrush.get());
-}
-
-void GraphicsContext::clip(const FloatRect& rect)
-{
- if (paintingDisabled())
- return;
-
- if (!m_data->m_dc)
- return;
-
- IntRect trRect = enclosingIntRect(m_data->mapRect(rect));
-
- auto clipRgn = adoptGDIObject(::CreateRectRgn(0, 0, 0, 0));
- if (GetClipRgn(m_data->m_dc, clipRgn.get()) > 0)
- IntersectClipRect(m_data->m_dc, trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY());
- else {
- clipRgn = adoptGDIObject(::CreateRectRgn(trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY()));
- SelectClipRgn(m_data->m_dc, clipRgn.get());
- }
-}
-
-void GraphicsContext::clipOut(const FloatRect& rect)
-{
- if (paintingDisabled())
- return;
-
- if (!m_data->m_dc)
- return;
-
- IntRect trRect = m_data->mapRect(rect);
-
- ExcludeClipRect(m_data->m_dc, trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY());
-}
-
-void GraphicsContext::drawFocusRing(const Path& path, int width, int offset, const Color& color)
-{
- // FIXME: implement
-}
-
-void GraphicsContext::drawFocusRing(const Vector<IntRect>& rects, int width, int offset, const Color& color)
-{
- if (!m_data->m_opacity || paintingDisabled())
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- int radius = (width - 1) / 2;
- offset += radius;
-
- unsigned rectCount = rects.size();
- IntRect finalFocusRect;
- for (unsigned i = 0; i < rectCount; i++) {
- IntRect focusRect = rects[i];
- focusRect.inflate(offset);
- finalFocusRect.unite(focusRect);
- }
-
- IntRect intRect = finalFocusRect;
- IntRect trRect = m_data->mapRect(finalFocusRect);
- TransparentLayerDC transparentDC(m_data, trRect, &intRect);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- trRect.move(transparentDC.toShift());
-
- RECT rect = trRect;
- DrawFocusRect(dc, &rect);
-}
-
-FloatRect GraphicsContext::computeLineBoundsForText(const FloatPoint& origin, float width, bool printing)
-{
- return FloatRect(origin, FloatSize(width, strokeThickness()));
-}
-
-void GraphicsContext::drawLineForText(const FloatPoint& origin, float width, bool printing, bool doubleUnderlines)
-{
- if (paintingDisabled())
- return;
-
- StrokeStyle oldStyle = strokeStyle();
- setStrokeStyle(SolidStroke);
- drawLine(roundedIntPoint(origin), roundedIntPoint(origin + FloatSize(width, 0)));
- if (doubleUnderlines)
- drawLine(roundedIntPoint(origin + FloatSize(0, strokeThickness() * 2)), roundedIntPoint(origin + FloatSize(width, strokeThickness() * 2)));
- setStrokeStyle(oldStyle);
-}
-
-void GraphicsContext::drawLinesForText(const FloatPoint& point, const DashArray& widths, bool printing, bool doubleUnderlines)
-{
- for (size_t i = 0; i < widths.size(); i += 2)
- drawLineForText(FloatPoint(point.x() + widths[i], point.y()), widths[i+1] - widths[i], printing, doubleUnderlines);
-}
-
-void GraphicsContext::updateDocumentMarkerResources()
-{
- notImplemented();
-}
-
-void GraphicsContext::drawLineForDocumentMarker(const FloatPoint&, float width, DocumentMarkerLineStyle style)
-{
- notImplemented();
-}
-
-void GraphicsContext::setPlatformFillColor(const Color& col, ColorSpace colorSpace)
-{
- notImplemented();
-}
-
-void GraphicsContext::setPlatformStrokeColor(const Color& col, ColorSpace colorSpace)
-{
- notImplemented();
-}
-
-void GraphicsContext::setPlatformStrokeThickness(float strokeThickness)
-{
- notImplemented();
-}
-
-void GraphicsContext::setURLForRect(const URL& link, const IntRect& destRect)
-{
- notImplemented();
-}
-
-void GraphicsContext::clearRect(const FloatRect& rect)
-{
- if (paintingDisabled())
- return;
-
- if (m_data->hasAlpha()) {
- IntRect trRect = enclosingIntRect(m_data->mapRect(rect));
- m_data->m_bitmap->clearPixels(trRect);
- return;
- }
-
- fillRect(rect, Color(Color::white), ColorSpaceDeviceRGB);
-}
-
-void GraphicsContext::strokeRect(const FloatRect& rect, float width)
-{
- if (!m_data->m_opacity || paintingDisabled() || strokeStyle() == NoStroke)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect intRect = enclosingIntRect(rect);
- IntRect trRect = m_data->mapRect(intRect);
- TransparentLayerDC transparentDC(m_data, trRect, &intRect);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- trRect.move(transparentDC.toShift());
-
- auto pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
- HGDIOBJ oldPen = SelectObject(dc, pen.get());
-
- int right = trRect.maxX() - 1;
- int bottom = trRect.maxY() - 1;
- const POINT intPoints[5] =
- {
- { trRect.x(), trRect.y() },
- { right, trRect.y() },
- { right, bottom },
- { trRect.x(), bottom },
- { trRect.x(), trRect.y() }
- };
-
- Polyline(dc, intPoints, 5);
-
- SelectObject(dc, oldPen);
-}
-
-void GraphicsContext::beginPlatformTransparencyLayer(float opacity)
-{
- m_data->save();
- m_data->m_opacity *= opacity;
-}
-
-void GraphicsContext::endPlatformTransparencyLayer()
-{
- m_data->restore();
-}
-
-bool GraphicsContext::supportsTransparencyLayers()
-{
- return true;
-}
-
-void GraphicsContext::concatCTM(const AffineTransform& transform)
-{
- m_data->concatCTM(transform);
-}
-
-void GraphicsContext::setCTM(const AffineTransform& transform)
-{
- m_data->setCTM(transform);
-}
-
-AffineTransform& GraphicsContext::affineTransform()
-{
- return m_data->m_transform;
-}
-
-const AffineTransform& GraphicsContext::affineTransform() const
-{
- return m_data->m_transform;
-}
-
-void GraphicsContext::resetAffineTransform()
-{
- m_data->m_transform.makeIdentity();
-}
-
-void GraphicsContext::translate(float x, float y)
-{
- m_data->translate(x, y);
-}
-
-void GraphicsContext::rotate(float radians)
-{
- m_data->rotate(radians);
-}
-
-void GraphicsContext::scale(const FloatSize& size)
-{
- m_data->scale(size);
-}
-
-void GraphicsContext::setLineCap(LineCap lineCap)
-{
- notImplemented();
-}
-
-void GraphicsContext::setLineJoin(LineJoin lineJoin)
-{
- notImplemented();
-}
-
-void GraphicsContext::setMiterLimit(float miter)
-{
- notImplemented();
-}
-
-void GraphicsContext::setAlpha(float alpha)
-{
- m_data->m_opacity = alpha;
-}
-
-void GraphicsContext::setPlatformCompositeOperation(CompositeOperator op, BlendMode blendMode)
-{
- notImplemented();
-}
-
-void GraphicsContext::clip(const Path& path, WindRule)
-{
- notImplemented();
-}
-
-void GraphicsContext::canvasClip(const Path& path, WindRule fillRule)
-{
- clip(path, fillRule);
-}
-
-void GraphicsContext::clipOut(const Path&)
-{
- notImplemented();
-}
-
-static inline IntPoint rectCenterPoint(const RECT& rect)
-{
- return IntPoint(rect.left + (rect.right - rect.left) / 2, rect.top + (rect.bottom - rect.top) / 2);
-}
-
-void GraphicsContext::fillRoundedRect(const FloatRoundedRect& rect, const Color& c, ColorSpace colorSpace)
-{
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- FloatSize shadowOffset;
- float shadowBlur = 0;
- Color shadowColor;
- ColorSpace shadowColorSpace;
-
- getShadow(shadowOffset, shadowBlur, shadowColor, shadowColorSpace);
-
- const FloatRect& fillRect = rect.rect();
- IntRect dstRect = fillRect;
-
- dstRect.move(stableRound(shadowOffset.width()), stableRound(shadowOffset.height()));
- dstRect.inflate(stableRound(shadowBlur));
- dstRect = m_data->mapRect(dstRect);
-
- FloatSize newTopLeft(m_data->mapSize(rect.radii().topLeft()));
- FloatSize newTopRight(m_data->mapSize(rect.radii().topRight()));
- FloatSize newBottomLeft(m_data->mapSize(rect.radii().bottomLeft()));
- FloatSize newBottomRight(m_data->mapSize(rect.radii().bottomRight()));
-
- TransparentLayerDC transparentDc(m_data, dstRect, &fillRect);
- HDC dc = transparentDc.hdc();
- if (!dc)
- return;
-
- dstRect.move(transparentDc.toShift());
-
- RECT rectWin = dstRect;
-
- auto brush = createBrush(shadowColor);
- HGDIOBJ oldBrush = SelectObject(dc, brush.get());
-
- SelectObject(dc, GetStockObject(NULL_PEN));
-
- IntPoint centerPoint = rectCenterPoint(rectWin);
- // Draw top left half
- RECT clipRect(rectWin);
- clipRect.right = centerPoint.x();
- clipRect.bottom = centerPoint.y();
-
- auto clipRgn = adoptGDIObject(::CreateRectRgn(0, 0, 0, 0));
- bool needsNewClip = (GetClipRgn(dc, clipRgn.get()) <= 0);
-
- drawRoundCorner(needsNewClip, clipRect, rectWin, dc, stableRound(newTopLeft.width() * 2), stableRound(newTopLeft.height() * 2));
-
- // Draw top right
- clipRect = rectWin;
- clipRect.left = centerPoint.x();
- clipRect.bottom = centerPoint.y();
-
- drawRoundCorner(needsNewClip, clipRect, rectWin, dc, stableRound(newTopRight.width() * 2), stableRound(newTopRight.height() * 2));
-
- // Draw bottom left
- clipRect = rectWin;
- clipRect.right = centerPoint.x();
- clipRect.top = centerPoint.y();
-
- drawRoundCorner(needsNewClip, clipRect, rectWin, dc, stableRound(newBottomLeft.width() * 2), stableRound(newBottomLeft.height() * 2));
-
- // Draw bottom right
- clipRect = rectWin;
- clipRect.left = centerPoint.x();
- clipRect.top = centerPoint.y();
-
- drawRoundCorner(needsNewClip, clipRect, rectWin, dc, stableRound(newBottomRight.width() * 2), stableRound(newBottomRight.height() * 2));
-
- SelectObject(dc, oldBrush);
-}
-
-void GraphicsContext::drawRoundCorner(bool needsNewClip, RECT clipRect, RECT rectWin, HDC dc, int width, int height)
-{
- if (!dc)
- return;
-
- auto clipRgn = adoptGDIObject(::CreateRectRgn(0, 0, 0, 0));
- if (needsNewClip) {
- clipRgn = adoptGDIObject(::CreateRectRgn(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom));
- SelectClipRgn(dc, clipRgn.get());
- } else
- IntersectClipRect(dc, clipRect.left, clipRect.top, clipRect.right, clipRect.bottom);
-
- ::RoundRect(dc, rectWin.left , rectWin.top , rectWin.right , rectWin.bottom , width, height);
-
- SelectClipRgn(dc, needsNewClip ? 0 : clipRgn.get());
-}
-
-
-FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& frect, RoundingMode)
-{
- notImplemented();
- return frect;
-}
-
-Color gradientAverageColor(const Gradient* gradient)
-{
- const Vector<Gradient::ColorStop>& stops = gradient->getStops();
- if (stops.isEmpty())
- return Color();
-
- const Gradient::ColorStop& stop = stops.first();
- if (stops.size() == 1)
- return Color(stop.red, stop.green, stop.blue, stop.alpha);
-
- const Gradient::ColorStop& lastStop = stops.last();
- return Color((stop.red + lastStop.red) * 0.5f
- , (stop.green + lastStop.green) * 0.5f
- , (stop.blue + lastStop.blue) * 0.5f
- , (stop.alpha + lastStop.alpha) * 0.5f);
-}
-
-void GraphicsContext::fillPath(const Path& path)
-{
- if (path.isNull())
- return;
-
- Color c = m_state.fillGradient
- ? gradientAverageColor(m_state.fillGradient.get())
- : fillColor();
-
- if (!c.alpha() || !m_data->m_opacity)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- auto brush = createBrush(c);
-
- if (m_data->m_opacity < 1.0f || m_data->hasAlpha()) {
- IntRect trRect = enclosingIntRect(m_data->mapRect(path.boundingRect()));
- trRect.inflate(1);
- TransparentLayerDC transparentDC(m_data, trRect);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
-
- AffineTransform tr = m_data->m_transform;
- tr.translate(transparentDC.toShift().width(), transparentDC.toShift().height());
-
- SelectObject(dc, GetStockObject(NULL_PEN));
- HGDIOBJ oldBrush = SelectObject(dc, brush.get());
- path.platformPath()->fillPath(dc, &tr);
- SelectObject(dc, oldBrush);
- } else {
- SelectObject(m_data->m_dc, GetStockObject(NULL_PEN));
- HGDIOBJ oldBrush = SelectObject(m_data->m_dc, brush.get());
- path.platformPath()->fillPath(m_data->m_dc, &m_data->m_transform);
- SelectObject(m_data->m_dc, oldBrush);
- }
-}
-
-
-void GraphicsContext::strokePath(const Path& path)
-{
- if (path.isNull() || !m_data->m_opacity)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- auto pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
-
- if (m_data->m_opacity < 1.0f || m_data->hasAlpha()) {
- IntRect trRect = enclosingIntRect(m_data->mapRect(path.boundingRect()));
- trRect.inflate(1);
- TransparentLayerDC transparentDC(m_data, trRect);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
-
- AffineTransform tr = m_data->m_transform;
- tr.translate(transparentDC.toShift().width(), transparentDC.toShift().height());
-
- SelectObject(dc, GetStockObject(NULL_BRUSH));
- HGDIOBJ oldPen = SelectObject(dc, pen.get());
- path.platformPath()->strokePath(dc, &tr);
- SelectObject(dc, oldPen);
- } else {
- SelectObject(m_data->m_dc, GetStockObject(NULL_BRUSH));
- HGDIOBJ oldPen = SelectObject(m_data->m_dc, pen.get());
- path.platformPath()->strokePath(m_data->m_dc, &m_data->m_transform);
- SelectObject(m_data->m_dc, oldPen);
- }
-}
-
-void GraphicsContext::fillRect(const FloatRect& r, const Gradient* gradient)
-{
- if (!m_data->m_opacity)
- return;
-
- const Vector<Gradient::ColorStop>& stops = gradient->getStops();
- if (stops.isEmpty())
- return;
-
- size_t numStops = stops.size();
- if (numStops == 1) {
- const Gradient::ColorStop& stop = stops.first();
- Color color(stop.red, stop.green, stop.blue, stop.alpha);
- fillRect(r, color, ColorSpaceDeviceRGB);
- return;
- }
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect intRect = enclosingIntRect(r);
- IntRect rect = m_data->mapRect(intRect);
- TransparentLayerDC transparentDC(m_data, rect, &intRect, 255, true);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
-
- rect.move(transparentDC.toShift());
- FloatPoint fp0 = m_data->mapPoint(gradient->p0());
- FloatPoint fp1 = m_data->mapPoint(gradient->p1());
- IntPoint p0(stableRound(fp0.x()), stableRound(fp0.y()));
- IntPoint p1(stableRound(fp1.x()), stableRound(fp1.y()));
- p0 += transparentDC.toShift();
- p1 += transparentDC.toShift();
-
- if (gradient->isRadial()) {
- if (g_radialGradientFiller) {
- // FIXME: don't support 2D scaling at this time
- double scale = (m_data->m_transform.a() + m_data->m_transform.d()) * 0.5;
- float r0 = gradient->startRadius() * scale;
- float r1 = gradient->endRadius() * scale;
- g_radialGradientFiller(dc, rect, p0, p1, r0, r1, gradient->getStops());
- return;
- }
- } else if (g_linearGradientFiller) {
- g_linearGradientFiller(dc, rect, p0, p1, gradient->getStops());
- return;
- }
-
- // Simple 1D linear solution that assumes p0 is on the top or left side, and p1 is on the right or bottom side
- size_t numRects = (numStops - 1);
- Vector<TRIVERTEX, 20> tv;
- tv.resize(numRects * 2);
- Vector<GRADIENT_RECT, 10> mesh;
- mesh.resize(numRects);
- int x = rect.x();
- int y = rect.y();
- int width = rect.width();
- int height = rect.height();
- FloatSize d = gradient->p1() - gradient->p0();
- bool vertical = fabs(d.height()) > fabs(d.width());
- for (size_t i = 0; i < numStops; ++i) {
- const Gradient::ColorStop& stop = stops[i];
- int iTv = i ? 2 * i - 1 : 0;
- tv[iTv].Red = stop.red * 0xFFFF;
- tv[iTv].Green = stop.green * 0xFFFF;
- tv[iTv].Blue = stop.blue * 0xFFFF;
- tv[iTv].Alpha = stop.alpha * 0xFFFF;
- if (i) {
- tv[iTv].x = vertical ? x + width: x + width * stop.stop;
- tv[iTv].y = vertical ? y + height * stop.stop : y + height;
- mesh[i - 1].UpperLeft = iTv - 1;
- mesh[i - 1].LowerRight = iTv;
- } else {
- tv[iTv].x = x;
- tv[iTv].y = y;
- }
-
- if (i && i < numRects) {
- tv[iTv + 1] = tv[iTv];
- if (vertical)
- tv[iTv + 1].x = x;
- else
- tv[iTv + 1].y = y;
- }
- }
-
- GradientFill(dc, tv.data(), tv.size(), mesh.data(), mesh.size(), vertical ? GRADIENT_FILL_RECT_V : GRADIENT_FILL_RECT_H);
-}
-
-AffineTransform GraphicsContext::getCTM(IncludeDeviceScale) const
-{
- if (paintingDisabled())
- return AffineTransform();
-
- return m_data->m_transform;
-}
-
-void GraphicsContext::fillRect(const FloatRect& rect)
-{
- savePlatformState();
-
- if (m_state.fillGradient)
- fillRect(rect, m_state.fillGradient.get());
- else
- fillRect(rect, fillColor(), ColorSpaceDeviceRGB);
-
- restorePlatformState();
-}
-
-void GraphicsContext::setPlatformShadow(const FloatSize&, float, const Color&, ColorSpace)
-{
- notImplemented();
-}
-
-void GraphicsContext::clearPlatformShadow()
-{
- notImplemented();
-}
-
-InterpolationQuality GraphicsContext::imageInterpolationQuality() const
-{
- notImplemented();
- return InterpolationDefault;
-}
-
-void GraphicsContext::setImageInterpolationQuality(InterpolationQuality)
-{
- notImplemented();
-}
-
-static inline bool isCharVisible(UChar c)
-{
- return c && c != zeroWidthSpace;
-}
-
-void GraphicsContext::drawText(const Font& font, const TextRun& run, const FloatPoint& point, int from, int to)
-{
- if (paintingDisabled() || !fillColor().alpha() || !m_data->m_opacity)
- return;
-
- bool mustSupportAlpha = m_data->hasAlpha();
-
- if (!mustSupportAlpha && fillColor().alpha() == 0xFF && m_data->m_opacity >= 1.0) {
- font.drawText(this, run, point, from, to);
- return;
- }
-
- float oldOpacity = m_data->m_opacity;
- m_data->m_opacity *= fillColor().alpha() / 255.0;
-
- FloatRect textRect = font.selectionRectForText(run, point, font.fontMetrics().height(), from, to);
- textRect.setY(textRect.y() - font.fontMetrics().ascent());
- IntRect trRect = enclosingIntRect(m_data->mapRect(textRect));
- RECT bmpRect;
- AlphaPaintType alphaPaintType = mustSupportAlpha ? AlphaPaintOther : AlphaPaintNone;
- if (RefPtr<SharedBitmap> bmp = m_data->getTransparentLayerBitmap(trRect, alphaPaintType, bmpRect, true, mustSupportAlpha)) {
- {
- GraphicsContext gc(0);
- gc.setBitmap(bmp);
- gc.scale(FloatSize(m_data->m_transform.a(), m_data->m_transform.d()));
- font.drawText(&gc, run, IntPoint(0, font.fontMetrics().ascent()), from, to);
- }
- unsigned key1;
- HDC memDC = bmp->getDC(&key1);
- if (memDC) {
- m_data->paintBackTransparentLayerBitmap(memDC, bmp.get(), trRect, alphaPaintType, bmpRect);
- bmp->releaseDC(memDC, key1);
- }
- }
-
- m_data->m_opacity = oldOpacity;
-}
-
-void GraphicsContext::drawText(const SimpleFontData* fontData, const GlyphBuffer& glyphBuffer,
- int from, int numGlyphs, const FloatPoint& point)
-{
- if (!m_data->m_opacity)
- return;
-
- for (;;) {
- if (!numGlyphs)
- return;
- if (isCharVisible(*glyphBuffer.glyphs(from)))
- break;
- ++from;
- --numGlyphs;
- }
-
- double scaleX = m_data->m_transform.a();
- double scaleY = m_data->m_transform.d();
-
- int height = fontData->platformData().size() * scaleY;
- int width = fontData->avgCharWidth() * scaleX;
-
- if (!height || !width)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- HFONT hFont = height > 1
- ? fontData->platformData().getScaledFontHandle(height, scaleX == scaleY ? 0 : width)
- : 0;
-
- FloatPoint startPoint(point.x(), point.y() - fontData->fontMetrics().ascent());
- FloatPoint trPoint = m_data->mapPoint(startPoint);
- int y = stableRound(trPoint.y());
-
- Color color = fillColor();
- if (!color.alpha())
- return;
-
- COLORREF fontColor = RGB(color.red(), color.green(), color.blue());
-
- if (!hFont) {
- double offset = trPoint.x();
- const GlyphBufferAdvance* advance = glyphBuffer.advances(from);
- if (scaleX == 1.)
- for (int i = 1; i < numGlyphs; ++i)
- offset += (*advance++).width();
- else
- for (int i = 1; i < numGlyphs; ++i)
- offset += (*advance++).width() * scaleX;
-
- offset += width;
-
- auto hPen = adoptGDIObject(::CreatePen(PS_DASH, 1, fontColor));
- HGDIOBJ oldPen = SelectObject(m_data->m_dc, hPen.get());
-
- MoveToEx(m_data->m_dc, stableRound(trPoint.x()), y, 0);
- LineTo(m_data->m_dc, stableRound(offset), y);
-
- SelectObject(m_data->m_dc, oldPen);
- return;
- }
-
- FloatSize shadowOffset;
- float shadowBlur = 0;
- Color shadowColor;
- ColorSpace shadowColorSpace;
- bool hasShadow = textDrawingMode() == TextModeFill
- && getShadow(shadowOffset, shadowBlur, shadowColor, shadowColorSpace)
- && shadowColor.alpha();
- COLORREF shadowRGBColor;
- FloatPoint trShadowPoint;
- if (hasShadow) {
- shadowRGBColor = RGB(shadowColor.red(), shadowColor.green(), shadowColor.blue());
- trShadowPoint = m_data->mapPoint(startPoint + shadowOffset);
- }
-
- HGDIOBJ hOldFont = SelectObject(m_data->m_dc, hFont);
- COLORREF oldTextColor = GetTextColor(m_data->m_dc);
- int oldTextAlign = GetTextAlign(m_data->m_dc);
- SetTextAlign(m_data->m_dc, 0);
-
- int oldBkMode = GetBkMode(m_data->m_dc);
- SetBkMode(m_data->m_dc, TRANSPARENT);
-
- if (numGlyphs > 1) {
- double offset = trPoint.x();
- Vector<int, 256> glyphSpace(numGlyphs);
- Vector<UChar, 256> text(numGlyphs);
- int* curSpace = glyphSpace.data();
- UChar* curChar = text.data();
- const UChar* srcChar = glyphBuffer.glyphs(from);
- const UChar* const srcCharEnd = srcChar + numGlyphs;
- *curChar++ = *srcChar++;
- int firstOffset = stableRound(offset);
- int lastOffset = firstOffset;
- const GlyphBufferAdvance* advance = glyphBuffer.advances(from);
- // FIXME: ExtTextOut() can flip over each word for RTL languages, even when TA_RTLREADING is off.
- // (this can be GDI bug or font driver bug?)
- // We are not clear how it processes characters and handles specified spaces. On the other side,
- // our glyph buffer is already in the correct order for rendering. So, the solution is that we
- // call ExtTextOut() for each single character when the text contains any RTL character.
- // This solution is not perfect as it is slower than calling ExtTextOut() one time for all characters.
- // Drawing characters one by one may be too slow.
- bool drawOneByOne = false;
- if (scaleX == 1.) {
- for (; srcChar < srcCharEnd; ++srcChar) {
- offset += (*advance++).width();
- int offsetInt = stableRound(offset);
- if (isCharVisible(*srcChar)) {
- if (!drawOneByOne && u_charDirection(*srcChar) == U_RIGHT_TO_LEFT)
- drawOneByOne = true;
- *curChar++ = *srcChar;
- *curSpace++ = offsetInt - lastOffset;
- lastOffset = offsetInt;
- }
- }
- } else {
- for (; srcChar < srcCharEnd; ++srcChar) {
- offset += (*advance++).width() * scaleX;
- int offsetInt = stableRound(offset);
- if (isCharVisible(*srcChar)) {
- if (!drawOneByOne && u_charDirection(*srcChar) == U_RIGHT_TO_LEFT)
- drawOneByOne = true;
- *curChar++ = *srcChar;
- *curSpace++ = offsetInt - lastOffset;
- lastOffset = offsetInt;
- }
- }
- }
- numGlyphs = curChar - text.data();
- if (hasShadow) {
- SetTextColor(m_data->m_dc, shadowRGBColor);
- if (drawOneByOne) {
- int xShadow = firstOffset + stableRound(trShadowPoint.x() - trPoint.x());
- int yShadow = stableRound(trShadowPoint.y());
- for (int i = 0; i < numGlyphs; ++i) {
- ExtTextOut(m_data->m_dc, xShadow, yShadow, 0, NULL, text.data() + i, 1, 0);
- xShadow += glyphSpace[i];
- }
- } else
- ExtTextOut(m_data->m_dc, firstOffset + stableRound(trShadowPoint.x() - trPoint.x()), stableRound(trShadowPoint.y()), 0, NULL, text.data(), numGlyphs, glyphSpace.data());
- }
- SetTextColor(m_data->m_dc, fontColor);
- if (drawOneByOne) {
- int x = firstOffset;
- for (int i = 0; i < numGlyphs; ++i) {
- ExtTextOut(m_data->m_dc, x, y, 0, NULL, text.data() + i, 1, 0);
- x += glyphSpace[i];
- }
- } else
- ExtTextOut(m_data->m_dc, firstOffset, y, 0, NULL, text.data(), numGlyphs, glyphSpace.data());
- } else {
- UChar c = *glyphBuffer.glyphs(from);
- if (hasShadow) {
- SetTextColor(m_data->m_dc, shadowRGBColor);
- ExtTextOut(m_data->m_dc, stableRound(trShadowPoint.x()), stableRound(trShadowPoint.y()), 0, NULL, &c, 1, 0);
- }
- SetTextColor(m_data->m_dc, fontColor);
- ExtTextOut(m_data->m_dc, stableRound(trPoint.x()), y, 0, NULL, &c, 1, 0);
- }
-
- SetTextAlign(m_data->m_dc, oldTextAlign);
- SetTextColor(m_data->m_dc, oldTextColor);
- SetBkMode(m_data->m_dc, oldBkMode);
- SelectObject(m_data->m_dc, hOldFont);
-}
-
-void GraphicsContext::drawFrameControl(const IntRect& rect, unsigned type, unsigned state)
-{
- if (!m_data->m_opacity)
- return;
-
- const int boxWidthBest = 8;
- const int boxHeightBest = 8;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect trRect = m_data->mapRect(rect);
- TransparentLayerDC transparentDC(m_data, trRect, &rect, 255, true);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- trRect.move(transparentDC.toShift());
-
- RECT rectWin = trRect;
-
- if ((rectWin.right - rectWin.left) < boxWidthBest) {
- RefPtr<SharedBitmap> bmp = SharedBitmap::create(IntSize(boxWidthBest, boxHeightBest), BitmapInfo::BitCount16, true);
- SharedBitmap::DCHolder memDC(bmp.get());
- if (memDC.get()) {
- RECT tempRect = {0, 0, boxWidthBest, boxHeightBest};
- DrawFrameControl(memDC.get(), &tempRect, type, state);
-
- ::StretchBlt(dc, rectWin.left, rectWin.top, rectWin.right - rectWin.left, rectWin.bottom - rectWin.top, memDC.get(), 0, 0, boxWidthBest, boxHeightBest, SRCCOPY);
- return;
- }
- }
-
- DrawFrameControl(dc, &rectWin, type, state);
-}
-
-void GraphicsContext::drawFocusRect(const IntRect& rect)
-{
- if (!m_data->m_opacity)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect trRect = m_data->mapRect(rect);
- TransparentLayerDC transparentDC(m_data, trRect, &rect);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- trRect.move(transparentDC.toShift());
-
- RECT rectWin = trRect;
- DrawFocusRect(dc, &rectWin);
-}
-
-void GraphicsContext::paintTextField(const IntRect& rect, unsigned state)
-{
- if (!m_data->m_opacity)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect trRect = m_data->mapRect(rect);
- TransparentLayerDC transparentDC(m_data, trRect, &rect);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- trRect.move(transparentDC.toShift());
-
- RECT rectWin = trRect;
- DrawEdge(dc, &rectWin, EDGE_ETCHED, BF_RECT | BF_ADJUST);
- FillRect(dc, &rectWin, reinterpret_cast<HBRUSH>(((state & DFCS_INACTIVE) ? COLOR_BTNFACE : COLOR_WINDOW) + 1));
-}
-
-void GraphicsContext::drawBitmap(SharedBitmap* bmp, const IntRect& dstRectIn, const IntRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp, BlendMode blendMode)
-{
- if (!m_data->m_opacity)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect dstRect = m_data->mapRect(dstRectIn);
- TransparentLayerDC transparentDC(m_data, dstRect, &dstRectIn, 255, true);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- dstRect.move(transparentDC.toShift());
-
- bmp->draw(dc, dstRect, srcRect, compositeOp, blendMode);
-
- if (bmp->is16bit())
- transparentDC.fillAlphaChannel();
-}
-
-void GraphicsContext::drawBitmapPattern(SharedBitmap* bmp, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRectIn, const IntSize& origSourceSize)
-{
- if (!m_data->m_opacity)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect intDstRect = enclosingIntRect(destRectIn);
- IntRect trRect = m_data->mapRect(intDstRect);
- TransparentLayerDC transparentDC(m_data, trRect, &intDstRect, 255, true);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- trRect.move(transparentDC.toShift());
- FloatRect movedDstRect = m_data->m_transform.inverse().mapRect(FloatRect(trRect));
- FloatSize moved(movedDstRect.location() - destRectIn.location());
- AffineTransform transform = m_data->m_transform;
- transform.translate(moved.width(), moved.height());
-
- bmp->drawPattern(dc, transform, tileRectIn, patternTransform, phase, styleColorSpace, op, destRectIn, origSourceSize);
-
- if (!bmp->hasAlpha())
- transparentDC.fillAlphaChannel();
-}
-
-void GraphicsContext::drawIcon(HICON icon, const IntRect& dstRectIn, UINT flags)
-{
- if (!m_data->m_opacity)
- return;
-
- ScopeDCProvider dcProvider(m_data);
- if (!m_data->m_dc)
- return;
-
- IntRect dstRect = m_data->mapRect(dstRectIn);
- TransparentLayerDC transparentDC(m_data, dstRect, &dstRectIn, 255, true);
- HDC dc = transparentDC.hdc();
- if (!dc)
- return;
- dstRect.move(transparentDC.toShift());
-
- DrawIconEx(dc, dstRect.x(), dstRect.y(), icon, dstRect.width(), dstRect.height(), 0, NULL, flags);
-}
-
-void GraphicsContext::setPlatformShouldAntialias(bool)
-{
- notImplemented();
-}
-
-void GraphicsContext::setLineDash(const DashArray&, float)
-{
- notImplemented();
-}
-
-void GraphicsContext::clipPath(const Path&, WindRule)
-{
- notImplemented();
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-#include "SharedBitmap.h"
-
-namespace WebCore {
-
-class IntSize;
-
-class ImageBufferData {
-public:
- ImageBufferData(const IntSize&);
- RefPtr<SharedBitmap> m_bitmap;
-};
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved.
- * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-#include "config.h"
-#include "ImageBuffer.h"
-
-#include "GraphicsContext.h"
-#include "Image.h"
-#include "ImageData.h"
-#include "NotImplemented.h"
-#include "SharedBitmap.h"
-
-namespace WebCore {
-
-class BufferedImage: public Image {
-
-public:
- BufferedImage(const ImageBufferData* data)
- : m_data(data)
- {
- }
-
- virtual bool currentFrameKnownToBeOpaque() { return !m_data->m_bitmap->hasAlpha() ; }
- virtual IntSize size() const { return IntSize(m_data->m_bitmap->width(), m_data->m_bitmap->height()); }
- virtual void destroyDecodedData(bool destroyAll = true) {}
- virtual unsigned decodedSize() const { return 0; }
- virtual void draw(GraphicsContext*, const FloatRect& dstRect, const FloatRect& srcRect, ColorSpace styleColorSpace, CompositeOperator, BlendMode, ImageOrientationDescription);
- virtual void drawPattern(GraphicsContext*, const FloatRect& srcRect, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator, const FloatRect& destRect);
-
- const ImageBufferData* m_data;
-};
-
-void BufferedImage::draw(GraphicsContext* ctxt, const FloatRect& dstRect, const FloatRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp, BlendMode blendMode, ImageOrientationDescription)
-{
- IntRect intDstRect = enclosingIntRect(dstRect);
- IntRect intSrcRect(srcRect);
- m_data->m_bitmap->draw(ctxt, intDstRect, intSrcRect, styleColorSpace, compositeOp, blendMode);
-}
-
-void BufferedImage::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, BlendMode)
-{
- m_data->m_bitmap->drawPattern(ctxt, tileRectIn, patternTransform, phase, styleColorSpace, op, destRect, size());
-}
-
-ImageBufferData::ImageBufferData(const IntSize& size)
- : m_bitmap(SharedBitmap::create(size, BitmapInfo::BitCount32, false))
-{
- // http://www.w3.org/TR/2009/WD-html5-20090212/the-canvas-element.html#canvaspixelarray
- // "When the canvas is initialized it must be set to fully transparent black."
- m_bitmap->resetPixels(true);
- m_bitmap->setHasAlpha(true);
-}
-
-ImageBuffer::ImageBuffer(const IntSize& size, float resolutionScale, ColorSpace colorSpace, RenderingMode, bool& success)
- : m_data(size)
- , m_size(size)
- , m_logicalSize(size)
-{
- // FIXME: Respect resoutionScale to support high-DPI canvas.
- UNUSED_PARAM(resolutionScale);
- // FIXME: colorSpace is not used
- UNUSED_PARAM(colorSpace);
-
- m_context = adoptPtr(new GraphicsContext(0));
- m_context->setBitmap(m_data.m_bitmap);
- success = true;
-}
-
-ImageBuffer::~ImageBuffer()
-{
-}
-
-GraphicsContext* ImageBuffer::context() const
-{
- return m_context.get();
-}
-
-PassRefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior, ScaleBehavior) const
-{
- ASSERT(copyBehavior == CopyBackingStore);
- return adoptRef(new BufferedImage(&m_data));
-}
-
-BackingStoreCopy ImageBuffer::fastCopyImageMode()
-{
- return CopyBackingStore;
-}
-
-void ImageBuffer::clip(GraphicsContext*, const FloatRect&) const
-{
- notImplemented();
-}
-
-void ImageBuffer::draw(GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
- CompositeOperator op, BlendMode blendMode, bool useLowQualityScale)
-{
- RefPtr<Image> imageCopy = copyImage(CopyBackingStore);
- context->drawImage(imageCopy.get(), styleColorSpace, destRect, srcRect, op, blendMode, ImageOrientationDescription(), useLowQualityScale);
-}
-
-void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
-{
- RefPtr<Image> imageCopy = copyImage(CopyBackingStore);
- imageCopy->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
-}
-
-template <bool premultiplied>
-static PassRefPtr<Uint8ClampedArray> getImageData(const IntRect& rect, const SharedBitmap* bitmap)
-{
- RefPtr<Uint8ClampedArray> imageData = Uint8ClampedArray::createUninitialized(rect.width() * rect.height() * 4);
-
- const unsigned char* src = static_cast<const unsigned char*>(bitmap->bytes());
- if (!src)
- return imageData.release();
-
- IntRect sourceRect(0, 0, bitmap->width(), bitmap->height());
- sourceRect.intersect(rect);
- if (sourceRect.isEmpty())
- return imageData.release();
-
- unsigned char* dst = imageData->data();
- imageData->zeroFill();
- src += (sourceRect.y() * bitmap->width() + sourceRect.x()) * 4;
- dst += ((sourceRect.y() - rect.y()) * rect.width() + sourceRect.x() - rect.x()) * 4;
- int bytesToCopy = sourceRect.width() * 4;
- int srcSkip = (bitmap->width() - sourceRect.width()) * 4;
- int dstSkip = (rect.width() - sourceRect.width()) * 4;
- const unsigned char* dstEnd = dst + sourceRect.height() * rect.width() * 4;
- while (dst < dstEnd) {
- const unsigned char* dstRowEnd = dst + bytesToCopy;
- while (dst < dstRowEnd) {
- // Convert ARGB little endian to RGBA big endian
- int blue = *src++;
- int green = *src++;
- int red = *src++;
- int alpha = *src++;
- if (premultiplied) {
- *dst++ = static_cast<unsigned char>((red * alpha + 254) / 255);
- *dst++ = static_cast<unsigned char>((green * alpha + 254) / 255);
- *dst++ = static_cast<unsigned char>((blue * alpha + 254) / 255);
- *dst++ = static_cast<unsigned char>(alpha);
- } else {
- *dst++ = static_cast<unsigned char>(red);
- *dst++ = static_cast<unsigned char>(green);
- *dst++ = static_cast<unsigned char>(blue);
- *dst++ = static_cast<unsigned char>(alpha);
- ++src;
- }
- }
- src += srcSkip;
- dst += dstSkip;
- }
-
- return imageData.release();
-}
-
-PassRefPtr<Uint8ClampedArray> ImageBuffer::getUnmultipliedImageData(const IntRect& rect, CoordinateSystem) const
-{
- return getImageData<false>(rect, m_data.m_bitmap.get());
-}
-
-PassRefPtr<Uint8ClampedArray> ImageBuffer::getPremultipliedImageData(const IntRect& rect, CoordinateSystem) const
-{
- return getImageData<true>(rect, m_data.m_bitmap.get());
-}
-
-void ImageBuffer::putByteArray(Multiply multiplied, Uint8ClampedArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint, CoordinateSystem)
-{
- SharedBitmap* bitmap = m_data.m_bitmap.get();
- unsigned char* dst = (unsigned char*)bitmap->bytes();
- if (!dst)
- return;
-
- IntRect destRect(destPoint, sourceRect.size());
- destRect.intersect(IntRect(0, 0, bitmap->width(), bitmap->height()));
-
- if (destRect.isEmpty())
- return;
-
- const unsigned char* src = source->data();
- dst += (destRect.y() * bitmap->width() + destRect.x()) * 4;
- src += (sourceRect.y() * sourceSize.width() + sourceRect.x()) * 4;
- int bytesToCopy = destRect.width() * 4;
- int dstSkip = (bitmap->width() - destRect.width()) * 4;
- int srcSkip = (sourceSize.width() - destRect.width()) * 4;
- const unsigned char* dstEnd = dst + destRect.height() * bitmap->width() * 4;
- while (dst < dstEnd) {
- const unsigned char* dstRowEnd = dst + bytesToCopy;
- while (dst < dstRowEnd) {
- // Convert RGBA big endian to ARGB little endian
- int red = *src++;
- int green = *src++;
- int blue = *src++;
- int alpha = *src++;
- if (multiplied == Premultiplied) {
- *dst++ = static_cast<unsigned char>(blue * 255 / alpha);
- *dst++ = static_cast<unsigned char>(green * 255 / alpha);
- *dst++ = static_cast<unsigned char>(red * 255 / alpha);
- *dst++ = static_cast<unsigned char>(alpha);
- } else {
- *dst++ = static_cast<unsigned char>(blue);
- *dst++ = static_cast<unsigned char>(green);
- *dst++ = static_cast<unsigned char>(red);
- *dst++ = static_cast<unsigned char>(alpha);
- }
- }
- src += srcSkip;
- dst += dstSkip;
- }
-}
-
-void ImageBuffer::platformTransformColorSpace(const Vector<int>& lookUpTable)
-{
- UNUSED_PARAM(lookUpTable);
- notImplemented();
-}
-
-String ImageBuffer::toDataURL(const String& mimeType, const double*, CoordinateSystem) const
-{
- if (!m_data.m_bitmap->bytes())
- return "data:,";
-
- notImplemented();
- return String();
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
- * Copyright (C) 2007-2009 Torch Mobile Inc.
- * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "Image.h"
-
-#include "BitmapImage.h"
-#include "GraphicsContext.h"
-#include "ImageDecoder.h"
-#include "NotImplemented.h"
-#include "SharedBuffer.h"
-#include "TransformationMatrix.h"
-#include "WinceGraphicsExtras.h"
-#include <wtf/text/WTFString.h>
-#include <wtf/win/GDIObject.h>
-
-namespace WebCore {
-
-PassNativeImagePtr ImageFrame::asNewNativeImage() const
-{
- return SharedBitmap::create(m_backingStore, m_size, hasAlpha());
-}
-
-bool FrameData::clear(bool clearMetaData)
-{
- if (clearMetaData)
- m_haveMetadata = false;
-
- if (m_frame) {
- m_frame = 0;
- return true;
- }
-
- return false;
-}
-
-bool BitmapImage::getHBITMAPOfSize(HBITMAP bmp, const IntSize* size)
-{
- if (!bmp)
- return false;
-
- BITMAP bmpInfo;
- GetObject(bmp, sizeof(BITMAP), &bmpInfo);
-
- ASSERT(bmpInfo.bmBitsPixel == 32);
- int bufferSize = bmpInfo.bmWidthBytes * bmpInfo.bmHeight;
-
- auto hdc = adoptGDIObject(::CreateCompatibleDC(0));
- HGDIOBJ hOldBmp = SelectObject(hdc.get(), bmp);
-
- {
- GraphicsContext gc(hdc.get());
-
- IntSize imageSize = BitmapImage::size();
- if (size)
- drawFrameMatchingSourceSize(&gc, FloatRect(0, 0, bmpInfo.bmWidth, bmpInfo.bmHeight), *size, ColorSpaceDeviceRGB, CompositeCopy);
- else
- draw(&gc, FloatRect(0, 0, bmpInfo.bmWidth, bmpInfo.bmHeight), FloatRect(0, 0, imageSize.width(), imageSize.height()), ColorSpaceDeviceRGB, CompositeCopy, BlendModeNormal, ImageOrientationDescription());
- }
-
- SelectObject(hdc.get(), hOldBmp);
-
- return true;
-}
-
-void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext* ctxt, const FloatRect& dstRect, const IntSize& srcSize, ColorSpace styleColorSpace, CompositeOperator compositeOp)
-{
- int frames = frameCount();
- for (int i = 0; i < frames; ++i) {
- RefPtr<SharedBitmap> bmp = frameAtIndex(i);
- if (!bmp || bmp->height() != static_cast<unsigned>(srcSize.height()) || bmp->width() != static_cast<unsigned>(srcSize.width()))
- continue;
-
- size_t currentFrame = m_currentFrame;
- m_currentFrame = i;
- draw(ctxt, dstRect, FloatRect(0, 0, srcSize.width(), srcSize.height()), styleColorSpace, compositeOp, BlendModeNormal, ImageOrientationDescription());
- m_currentFrame = currentFrame;
- return;
- }
-
- // No image of the correct size was found, fallback to drawing the current frame
- IntSize imageSize = BitmapImage::size();
- draw(ctxt, dstRect, FloatRect(0, 0, imageSize.width(), imageSize.height()), styleColorSpace, compositeOp, BlendModeNormal, ImageOrientationDescription());
-}
-
-void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dstRect, const FloatRect& srcRectIn, ColorSpace styleColorSpace, CompositeOperator compositeOp, BlendMode blendMode, ImageOrientationDescription)
-{
- if (!m_source.initialized())
- return;
-
- if (mayFillWithSolidColor())
- fillWithSolidColor(ctxt, dstRect, solidColor(), styleColorSpace, compositeOp);
- else {
- IntRect intSrcRect(srcRectIn);
- RefPtr<SharedBitmap> bmp = frameAtIndex(m_currentFrame);
- if (bmp) {
- if (bmp->width() != m_source.size().width()) {
- double scaleFactor = static_cast<double>(bmp->width()) / m_source.size().width();
-
- intSrcRect.setX(stableRound(srcRectIn.x() * scaleFactor));
- intSrcRect.setWidth(stableRound(srcRectIn.width() * scaleFactor));
- intSrcRect.setY(stableRound(srcRectIn.y() * scaleFactor));
- intSrcRect.setHeight(stableRound(srcRectIn.height() * scaleFactor));
- }
- bmp->draw(ctxt, enclosingIntRect(dstRect), intSrcRect, styleColorSpace, compositeOp, blendMode);
- }
- }
-
- startAnimation();
-}
-
-void Image::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
-{
- notImplemented();
-}
-
-void BitmapImage::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
-{
- RefPtr<SharedBitmap> bmp = nativeImageForCurrentFrame();
- if (!bmp)
- return;
-
- bmp->drawPattern(ctxt, tileRectIn, patternTransform, phase, styleColorSpace, op, destRect, m_source.size());
-}
-
-void BitmapImage::determineMinimumSubsamplingLevel() const
-{
- m_minimumSubsamplingLevel = 0;
-}
-
-void BitmapImage::checkForSolidColor()
-{
- if (m_checkedForSolidColor)
- return;
-
- if (frameCount() != 1) {
- m_isSolidColor = false;
- m_checkedForSolidColor = true;
- return;
- }
-
- RefPtr<SharedBitmap> bmp = frameAtIndex(0);
- if (!bmp || !bmp->validHeight()) {
- m_isSolidColor = false;
- return;
- }
-
- if (bmp->width() != 1 || bmp->validHeight() != 1) {
- m_isSolidColor = false;
- m_checkedForSolidColor = true;
- return;
- }
-
- m_isSolidColor = true;
-
- if (bmp->is16bit()) {
- unsigned short c = ((unsigned short *)bmp->bytes())[0];
- int r = (c >> 7) & 0xF8;
- int g = (c >> 2) & 0xF8;
- int b = (c << 3) & 0xF8;
- if (bmp->usesTransparentColor() && bmp->transparentColor() == RGB(r, g, b))
- m_solidColor = Color(r, g, b, 0);
- else
- m_solidColor = Color(r, g, b);
- } else {
- unsigned c = ((unsigned *)bmp->bytes())[0];
- m_solidColor = Color(c);
- }
-
- if (bmp->validHeight() == bmp->height())
- m_checkedForSolidColor = true;
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
- * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef MediaPlayerPrivateWinCE_h
-#define MediaPlayerPrivateWinCE_h
-
-#if ENABLE(VIDEO)
-
-#include <wtf/Forward.h>
-#include "MediaPlayerPrivate.h"
-#include "Timer.h"
-#include <wtf/OwnPtr.h>
-
-namespace WebCore {
-
- class GraphicsContext;
- class IntSize;
- class IntRect;
-
- class MediaPlayerPrivate : public MediaPlayerPrivateInterface {
- public:
- static void registerMediaEngine(MediaEngineRegistrar);
-
- ~MediaPlayerPrivate();
-
- IntSize naturalSize() const;
- bool hasVideo() const;
-
- void load(const String& url);
- void cancelLoad();
-
- void play();
- void pause();
-
- bool paused() const;
- bool seeking() const;
-
- float duration() const;
- float currentTime() const;
- void seek(float time);
-
- void setRate(float);
- void setVolume(float);
-
- MediaPlayer::NetworkState networkState() const { return m_networkState; }
- MediaPlayer::ReadyState readyState() const { return m_readyState; }
-
- std::unique_ptr<PlatformTimeRanges> buffered() const;
- float maxTimeSeekable() const;
- // FIXME: bytesLoaded() should be replaced with didLoadingProgress() (by somebody who can find the implementation of this class).
- unsigned bytesLoaded() const;
- unsigned totalBytes() const;
-
- void setVisible(bool);
- void setSize(const IntSize&);
-
- void loadStateChanged();
- void didEnd();
-
- void paint(GraphicsContext*, const IntRect&);
-
- private:
- MediaPlayerPrivate(MediaPlayer*);
-
- void updateStates();
- void doSeek();
- void cancelSeek();
- void seekTimerFired(Timer<MediaPlayerPrivate>*);
- float maxTimeLoaded() const;
- void sawUnsupportedTracks();
-
- // engine support
- static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
- static void getSupportedTypes(HashSet<String>& types);
- static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
- static bool isAvailable();
-
- virtual String engineDescription() const { return "WinCE"; }
-
- MediaPlayer* m_player;
- float m_seekTo;
- float m_endTime;
- Timer<MediaPlayerPrivate> m_seekTimer;
- MediaPlayer::NetworkState m_networkState;
- MediaPlayer::ReadyState m_readyState;
- unsigned m_enabledTrackCount;
- unsigned m_totalTrackCount;
- bool m_hasUnsupportedTracks;
- bool m_startedPlaying;
- bool m_isStreaming;
- };
-
-}
-
-#endif // ENABLE(VIDEO)
-
-#endif // MediaPlayerPrivateWinCE_h
+++ /dev/null
-/*
- * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-#if ENABLE(VIDEO)
-
-#include "config.h"
-#include "MediaPlayerProxy.h"
-
-#include "BridgeJSC.h"
-#include "DocumentLoader.h"
-#include "HTMLPlugInElement.h"
-#include "HTMLVideoElement.h"
-#include "JSDOMBinding.h"
-#include "JSPluginElementFunctions.h"
-#include "MediaPlayer.h"
-#include "Node.h"
-#include "PluginView.h"
-#include "RenderPartObject.h"
-#include "RenderWidget.h"
-#include "Widget.h"
-#include "c_class.h"
-#include "c_instance.h"
-#include "c_runtime.h"
-#include "npruntime_impl.h"
-#include <runtime/Identifier.h>
-#include <wtf/text/WTFString.h>
-
-using namespace JSC;
-
-namespace WebCore {
-
-using namespace Bindings;
-using namespace HTMLNames;
-
-WebMediaPlayerProxy::WebMediaPlayerProxy(MediaPlayer* player)
- : m_mediaPlayer(player)
- , m_init(false)
- , m_hasSentResponseToPlugin(false)
-{
- if (!m_init)
- initEngine();
-}
-
-WebMediaPlayerProxy::~WebMediaPlayerProxy()
-{
- m_instance.release();
-}
-
-ScriptInstance WebMediaPlayerProxy::pluginInstance()
-{
- if (!m_instance) {
- RenderObject* r = element()->renderer();
- if (!r || !r->isWidget())
- return 0;
-
- Frame* frame = element()->document().frame();
-
- RenderWidget* renderWidget = static_cast<RenderWidget*>(element()->renderer());
- if (renderWidget && renderWidget->widget())
- m_instance = frame->script().createScriptInstanceForWidget(renderWidget->widget());
- }
-
- return m_instance;
-}
-
-void WebMediaPlayerProxy::load(const String& url)
-{
- if (!m_init)
- initEngine();
- if (m_init)
- invokeMethod("play");
-}
-
-void WebMediaPlayerProxy::initEngine()
-{
- HTMLMediaElement* element = toHTMLMediaElement(m_mediaPlayer->mediaPlayerClient());
- String url = element->initialURL();
-
- if (url.isEmpty())
- return;
-
- Frame* frame = element->document().frame();
- Vector<String> paramNames;
- Vector<String> paramValues;
- String serviceType;
-
- // add all attributes set on the embed object
- if (element->hasAttributes()) {
- for (unsigned i = 0; i < element->attributeCount(); ++i) {
- Attribute* it = element->attributeItem(i);
- paramNames.append(it->name().localName().string());
- paramValues.append(it->value().string());
- }
- }
- serviceType = "application/x-mplayer2";
- frame->loader()->subframeLoader()->requestObject(static_cast<RenderPartObject*>(element->renderer()), url, nullAtom, serviceType, paramNames, paramValues);
- m_init = true;
-
-}
-
-HTMLMediaElement* WebMediaPlayerProxy::element()
-{
- return toHTMLMediaElement(m_mediaPlayer->mediaPlayerClient());
-
-}
-
-void WebMediaPlayerProxy::invokeMethod(const String& methodName)
-{
- Frame* frame = element()->document().frame();
- RootObject* root = frame->script().bindingRootObject();
- if (!root)
- return;
- ExecState *exec = root->globalObject()->globalExec();
- Instance* instance = pluginInstance().get();
- if (!instance)
- return;
-
- instance->begin();
- Class *aClass = instance->getClass();
- Identifier iden(exec, methodName);
- MethodList methodList = aClass->methodsNamed(iden, instance);
- ArgList args;
- instance->invokeMethod(exec, methodList , args);
- instance->end();
-}
-
-}
-
-#endif
+++ /dev/null
-/*
- * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-
-#ifndef MediaPlayerProxy_h
-#define MediaPlayerProxy_h
-
-#if ENABLE(VIDEO)
-
-#include <wtf/Forward.h>
-
-namespace WebCore {
-
- class IntRect;
- class IntSize;
- class MediaPlayer;
- class PluginView;
- class HTMLMediaElement;
-
- enum MediaPlayerProxyNotificationType {
- MediaPlayerNotificationPlayPauseButtonPressed,
- Idle,
- Loading,
- Loaded,
- FormatError,
- NetworkError,
- DecodeError
- };
-
- class WebMediaPlayerProxy {
- public:
- WebMediaPlayerProxy(MediaPlayer* player);
- ~WebMediaPlayerProxy();
-
- MediaPlayer* mediaPlayer() {return m_mediaPlayer;}
- void initEngine();
- void load(const String& url);
- HTMLMediaElement* element();
- void invokeMethod(const String& methodName);
- RefPtr<JSC::Bindings::Instance> pluginInstance();
-
- private:
- MediaPlayer* m_mediaPlayer;
- bool m_init;
- WebCore::PluginView* m_pluginView;
- bool m_hasSentResponseToPlugin;
- ScriptInstance m_instance;
- };
-
-}
-#endif // ENABLE(VIDEO)
-
-#endif
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-#include "config.h"
-#include "Path.h"
-
-#include "AffineTransform.h"
-#include "FloatRect.h"
-#include "NotImplemented.h"
-#include "PlatformPathWinCE.h"
-#include <wtf/OwnPtr.h>
-#include <wtf/text/WTFString.h>
-
-namespace WebCore {
-
-Path::Path()
- : m_path(new PlatformPath())
-{
-}
-
-Path::Path(const Path& other)
- : m_path(new PlatformPath(*other.m_path))
-{
-}
-
-Path::~Path()
-{
- delete m_path;
-}
-
-Path& Path::operator=(const Path& other)
-{
- if (&other != this) {
- delete m_path;
- m_path = new PlatformPath(*other.m_path);
- }
- return *this;
-}
-
-bool Path::contains(const FloatPoint& point, WindRule rule) const
-{
- return m_path->contains(point, rule);
-}
-
-void Path::translate(const FloatSize& size)
-{
- m_path->translate(size);
-}
-
-FloatRect Path::boundingRect() const
-{
- return m_path->boundingRect();
-}
-
-void Path::moveTo(const FloatPoint& point)
-{
- m_path->moveTo(point);
-}
-
-void Path::addLineTo(const FloatPoint& point)
-{
- m_path->addLineTo(point);
-}
-
-void Path::addQuadCurveTo(const FloatPoint& cp, const FloatPoint& p)
-{
- m_path->addQuadCurveTo(cp, p);
-}
-
-void Path::addBezierCurveTo(const FloatPoint& cp1, const FloatPoint& cp2, const FloatPoint& p)
-{
- m_path->addBezierCurveTo(cp1, cp2, p);
-}
-
-void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
-{
- m_path->addArcTo(p1, p2, radius);
-}
-
-void Path::closeSubpath()
-{
- m_path->closeSubpath();
-}
-
-void Path::addArc(const FloatPoint& p, float r, float sar, float ear, bool anticlockwise)
-{
- m_path->addEllipse(p, r, r, sar, ear, anticlockwise);
-}
-
-void Path::addRect(const FloatRect& r)
-{
- m_path->addRect(r);
-}
-
-void Path::addEllipse(const FloatRect& r)
-{
- m_path->addEllipse(r);
-}
-
-void Path::addPath(const Path&, const AffineTransform&)
-{
- notImplemented();
-}
-
-void Path::clear()
-{
- m_path->clear();
-}
-
-bool Path::isEmpty() const
-{
- return m_path->isEmpty();
-}
-
-void Path::apply(void* info, PathApplierFunction function) const
-{
- m_path->apply(info, function);
-}
-
-void Path::transform(const AffineTransform& t)
-{
- m_path->transform(t);
-}
-
-FloatRect Path::strokeBoundingRect(StrokeStyleApplier*) const
-{
- notImplemented();
- return FloatRect();
-}
-
-bool Path::strokeContains(StrokeStyleApplier*, const FloatPoint&) const
-{
- notImplemented();
- return false;
-}
-
-bool Path::hasCurrentPoint() const
-{
- // Not sure if this is correct. At the meantime, we do what other ports
- // do.
- // See https://bugs.webkit.org/show_bug.cgi?id=27266,
- // https://bugs.webkit.org/show_bug.cgi?id=27187, and
- // http://trac.webkit.org/changeset/45873
- return !isEmpty();
-}
-
-FloatPoint Path::currentPoint() const
-{
- return m_path->lastPoint();
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-#include "config.h"
-#include "PlatformPathWinCE.h"
-
-#include "AffineTransform.h"
-#include "FloatRect.h"
-#include "GraphicsContext.h"
-#include "Path.h"
-#include "WinCEGraphicsExtras.h"
-#include <wtf/MathExtras.h>
-#include <wtf/OwnPtr.h>
-#include <wtf/text/WTFString.h>
-
-#include <windows.h>
-
-namespace WebCore {
-
-// Implemented in GraphicsContextWinCE.cpp
-void getEllipsePointByAngle(double angle, double a, double b, float& x, float& y);
-
-static void quadCurve(int segments, Vector<PathPoint>& pts, const PathPoint* control)
-{
- const float step = 1.0 / segments;
- register float tA = 0.0;
- register float tB = 1.0;
-
- float c1x = control[0].x();
- float c1y = control[0].y();
- float c2x = control[1].x();
- float c2y = control[1].y();
- float c3x = control[2].x();
- float c3y = control[2].y();
-
- const int offset = pts.size();
- pts.resize(offset + segments);
- PathPoint pp;
- pp.m_x = c1x;
- pp.m_y = c1y;
-
- for (int i = 1; i < segments; ++i) {
- tA += step;
- tB -= step;
-
- const float a = tB * tB;
- const float b = 2.0 * tA * tB;
- const float c = tA * tA;
-
- pp.m_x = c1x * a + c2x * b + c3x * c;
- pp.m_y = c1y * a + c2y * b + c3y * c;
-
- pts[offset + i - 1] = pp;
- }
-
- pp.m_x = c3x;
- pp.m_y = c3y;
- pts[offset + segments - 1] = pp;
-}
-
-static inline void bezier(int segments, Vector<PathPoint>& pts, const PathPoint* control)
-{
- const float step = 1.0 / segments;
- register float tA = 0.0;
- register float tB = 1.0;
-
- float c1x = control[0].x();
- float c1y = control[0].y();
- float c2x = control[1].x();
- float c2y = control[1].y();
- float c3x = control[2].x();
- float c3y = control[2].y();
- float c4x = control[3].x();
- float c4y = control[3].y();
-
- const int offset = pts.size();
- pts.resize(offset + segments);
- PathPoint pp;
- pp.m_x = c1x;
- pp.m_y = c1y;
-
- for (int i = 1; i < segments; ++i) {
- tA += step;
- tB -= step;
- const float tAsq = tA * tA;
- const float tBsq = tB * tB;
-
- const float a = tBsq * tB;
- const float b = 3.0 * tA * tBsq;
- const float c = 3.0 * tB * tAsq;
- const float d = tAsq * tA;
-
- pp.m_x = c1x * a + c2x * b + c3x * c + c4x * d;
- pp.m_y = c1y * a + c2y * b + c3y * c + c4y * d;
-
- pts[offset + i - 1] = pp;
- }
-
- pp.m_x = c4x;
- pp.m_y = c4y;
- pts[offset + segments - 1] = pp;
-}
-
-static bool containsPoint(const FloatRect& r, const FloatPoint& p)
-{
- return p.x() >= r.x() && p.y() >= r.y() && p.x() < r.maxX() && p.y() < r.maxY();
-}
-
-static void normalizeAngle(float& angle)
-{
- angle = fmod(angle, 2 * piFloat);
- if (angle < 0)
- angle += 2 * piFloat;
- if (angle < 0.00001f)
- angle = 0;
-}
-
-static void transformArcPoint(float& x, float& y, const FloatPoint& c)
-{
- x += c.x();
- y += c.y();
-}
-
-static void inflateRectToContainPoint(FloatRect& r, float x, float y)
-{
- if (r.isEmpty()) {
- r.setX(x);
- r.setY(y);
- r.setSize(FloatSize(1, 1));
- return;
- }
- if (x < r.x()) {
- r.setWidth(r.maxX() - x);
- r.setX(x);
- } else {
- float w = x - r.x() + 1;
- if (w > r.width())
- r.setWidth(w);
- }
- if (y < r.y()) {
- r.setHeight(r.maxY() - y);
- r.setY(y);
- } else {
- float h = y - r.y() + 1;
- if (h > r.height())
- r.setHeight(h);
- }
-}
-
-// return 0-based value: 0 - first Quadrant ( 0 - 90 degree)
-static inline int quadrant(const PathPoint& point, const PathPoint& origin)
-{
- return point.m_x < origin.m_x ?
- (point.m_y < origin.m_y ? 2 : 1)
- : (point.m_y < origin.m_y ? 3 : 0);
-}
-
-static inline bool isQuadrantOnLeft(int q) { return q == 1 || q == 2; }
-static inline bool isQuadrantOnRight(int q) { return q == 0 || q == 3; }
-static inline bool isQuadrantOnTop(int q) { return q == 2 || q == 3; }
-static inline bool isQuadrantOnBottom(int q) { return q == 0 || q == 1; }
-
-static inline int nextQuadrant(int q) { return q == 3 ? 0 : q + 1; }
-static inline int quadrantDiff(int q1, int q2)
-{
- int d = q1 - q2;
- while (d < 0)
- d += 4;
- return d;
-}
-
-struct PathVector {
- float m_x;
- float m_y;
-
- PathVector() : m_x(0), m_y(0) {}
- PathVector(float x, float y) : m_x(x), m_y(y) {}
- double angle() const { return atan2(m_y, m_x); }
- operator double () const { return angle(); }
- double length() const { return _hypot(m_x, m_y); }
-};
-
-PathVector operator-(const PathPoint& p1, const PathPoint& p2)
-{
- return PathVector(p1.m_x - p2.m_x, p1.m_y - p2.m_y);
-}
-
-static void addArcPoint(PathPolygon& poly, const PathPoint& center, const PathPoint& radius, double angle)
-{
- PathPoint p;
- getEllipsePointByAngle(angle, radius.m_x, radius.m_y, p.m_x, p.m_y);
- transformArcPoint(p.m_x, p.m_y, center);
- if (poly.isEmpty() || poly.last() != p)
- poly.append(p);
-}
-
-static void addArcPoints(PathPolygon& poly, const PlatformPathElement::ArcTo& data)
-{
- const PathPoint& startPoint = poly.last();
- double curAngle = startPoint - data.m_center;
- double endAngle = data.m_end - data.m_center;
- double angleStep = 2. / std::max(data.m_radius.m_x, data.m_radius.m_y);
- if (data.m_clockwise) {
- if (endAngle <= curAngle || startPoint == data.m_end)
- endAngle += 2 * piDouble;
- } else {
- angleStep = -angleStep;
- if (endAngle >= curAngle || startPoint == data.m_end)
- endAngle -= 2 * piDouble;
- }
-
- for (curAngle += angleStep; data.m_clockwise ? curAngle < endAngle : curAngle > endAngle; curAngle += angleStep)
- addArcPoint(poly, data.m_center, data.m_radius, curAngle);
-
- if (poly.isEmpty() || poly.last() != data.m_end)
- poly.append(data.m_end);
-}
-
-static void drawPolygons(HDC dc, const Vector<PathPolygon>& polygons, bool fill, const AffineTransform* transformation)
-{
- for (Vector<PathPolygon>::const_iterator i = polygons.begin(); i != polygons.end(); ++i) {
- int npoints = i->size();
- if (!npoints)
- continue;
-
- POINT* winPoints = 0;
- if (fill) {
- if (npoints > 2)
- winPoints = new POINT[npoints + 1];
- } else
- winPoints = new POINT[npoints];
-
- if (winPoints) {
- if (transformation) {
- for (int i2 = 0; i2 < npoints; ++i2) {
- FloatPoint trPoint = transformation->mapPoint(i->at(i2));
- winPoints[i2].x = stableRound(trPoint.x());
- winPoints[i2].y = stableRound(trPoint.y());
- }
- } else {
- for (int i2 = 0; i2 < npoints; ++i2) {
- winPoints[i2].x = stableRound(i->at(i2).x());
- winPoints[i2].y = stableRound(i->at(i2).y());
- }
- }
-
- if (fill && winPoints[npoints - 1] != winPoints[0]) {
- winPoints[npoints].x = winPoints[0].x;
- winPoints[npoints].y = winPoints[0].y;
- ++npoints;
- }
-
- if (fill)
- ::Polygon(dc, winPoints, npoints);
- else
- ::Polyline(dc, winPoints, npoints);
- delete[] winPoints;
- }
- }
-}
-
-
-int PlatformPathElement::numControlPoints() const
-{
- switch (m_type) {
- case PathMoveTo:
- case PathLineTo:
- return 1;
- case PathQuadCurveTo:
- case PathArcTo:
- return 2;
- case PathBezierCurveTo:
- return 3;
- default:
- ASSERT(m_type == PathCloseSubpath);
- return 0;
- }
-}
-
-int PlatformPathElement::numPoints() const
-{
- switch (m_type) {
- case PathMoveTo:
- case PathLineTo:
- case PathArcTo:
- return 1;
- case PathQuadCurveTo:
- return 2;
- case PathBezierCurveTo:
- return 3;
- default:
- ASSERT(m_type == PathCloseSubpath);
- return 0;
- }
-}
-
-void PathPolygon::move(const FloatSize& offset)
-{
- for (Vector<PathPoint>::iterator i = begin(); i < end(); ++i)
- i->move(offset);
-}
-
-void PathPolygon::transform(const AffineTransform& t)
-{
- for (Vector<PathPoint>::iterator i = begin(); i < end(); ++i)
- *i = t.mapPoint(*i);
-}
-
-bool PathPolygon::contains(const FloatPoint& point) const
-{
- if (size() < 3)
- return false;
-
- // Test intersections between the polygon and the vertical line: x = point.x()
-
- int intersected = 0;
- const PathPoint* point1 = &last();
- Vector<PathPoint>::const_iterator last = end();
- // wasNegative: -1 means unknown, 0 means false, 1 means true.
- int wasNegative = -1;
- for (Vector<PathPoint>::const_iterator i = begin(); i != last; ++i) {
- const PathPoint& point2 = *i;
- if (point1->x() != point.x()) {
- if (point2.x() == point.x()) {
- // We are getting on the vertical line
- wasNegative = point1->x() < point.x() ? 1 : 0;
- } else if (point2.x() < point.x() != point1->x() < point.x()) {
- float y = (point2.y() - point1->y()) / (point2.x() - point1->x()) * (point.x() - point1->x()) + point1->y();
- if (y >= point.y())
- ++intersected;
- }
- } else {
- // We were on the vertical line
-
- // handle special case
- if (point1->y() == point.y())
- return true;
-
- if (point1->y() > point.y()) {
- if (point2.x() == point.x()) {
- // see if the point is on this segment
- if (point2.y() <= point.y())
- return true;
-
- // We are still on the line
- } else {
- // We are leaving the line now.
- // We have to get back to see which side we come from. If we come from
- // the same side we are leaving, no intersection should be counted
- if (wasNegative < 0) {
- Vector<PathPoint>::const_iterator jLast = i;
- Vector<PathPoint>::const_iterator j = i;
- do {
- if (j == begin())
- j = last;
- else
- --j;
- if (j->x() != point.x()) {
- if (j->x() > point.x())
- wasNegative = 0;
- else
- wasNegative = 1;
- break;
- }
- } while (j != jLast);
-
- if (wasNegative < 0)
- return false;
- }
- if (wasNegative ? point2.x() > point.x() : point2.x() < point.x())
- ++intersected;
- }
- } else if (point2.x() == point.x() && point2.y() >= point.y())
- return true;
- }
- point1 = &point2;
- }
-
- return intersected & 1;
-}
-
-void PlatformPathElement::move(const FloatSize& offset)
-{
- int n = numControlPoints();
- for (int i = 0; i < n; ++i)
- m_data.m_points[i].move(offset);
-}
-
-void PlatformPathElement::transform(const AffineTransform& t)
-{
- int n = numControlPoints();
- for (int i = 0; i < n; ++i) {
- FloatPoint p = t.mapPoint(m_data.m_points[i]);
- m_data.m_points[i].set(p.x(), p.y());
- }
-}
-
-void PlatformPathElement::inflateRectToContainMe(FloatRect& r, const FloatPoint& lastPoint) const
-{
- if (m_type == PathArcTo) {
- const ArcTo& data = m_data.m_arcToData;
- PathPoint startPoint;
- startPoint = lastPoint;
- PathPoint endPoint = data.m_end;
- if (!data.m_clockwise)
- std::swap(startPoint, endPoint);
-
- int q0 = quadrant(startPoint, data.m_center);
- int q1 = quadrant(endPoint, data.m_center);
- bool containsExtremes[4] = { false }; // bottom, left, top, right
- static const PathPoint extremeVectors[4] = { { 0, 1 }, { -1, 0 }, { 0, -1 }, { 1, 0 } };
- if (q0 == q1) {
- if (startPoint.m_x == endPoint.m_x || isQuadrantOnBottom(q0) != startPoint.m_x > endPoint.m_x) {
- for (int i = 0; i < 4; ++i)
- containsExtremes[i] = true;
- }
- } else {
- int extreme = q0;
- int diff = quadrantDiff(q1, q0);
- for (int i = 0; i < diff; ++i) {
- containsExtremes[extreme] = true;
- extreme = nextQuadrant(extreme);
- }
- }
-
- inflateRectToContainPoint(r, startPoint.m_x, startPoint.m_y);
- inflateRectToContainPoint(r, endPoint.m_x, endPoint.m_y);
- for (int i = 0; i < 4; ++i) {
- if (containsExtremes[i])
- inflateRectToContainPoint(r, data.m_center.m_x + data.m_radius.m_x * extremeVectors[i].m_x, data.m_center.m_y + data.m_radius.m_y * extremeVectors[i].m_y);
- }
- } else {
- int n = numPoints();
- for (int i = 0; i < n; ++i)
- inflateRectToContainPoint(r, m_data.m_points[i].m_x, m_data.m_points[i].m_y);
- }
-}
-
-PathElementType PlatformPathElement::type() const
-{
- switch (m_type) {
- case PathMoveTo:
- return PathElementMoveToPoint;
- case PathLineTo:
- return PathElementAddLineToPoint;
- case PathArcTo:
- // FIXME: there's no arcTo type for PathElement
- return PathElementAddLineToPoint;
- // return PathElementAddQuadCurveToPoint;
- case PathQuadCurveTo:
- return PathElementAddQuadCurveToPoint;
- case PathBezierCurveTo:
- return PathElementAddCurveToPoint;
- default:
- ASSERT(m_type == PathCloseSubpath);
- return PathElementCloseSubpath;
- }
-}
-
-PlatformPath::PlatformPath()
- : m_penLifted(true)
-{
- m_currentPoint.clear();
-}
-
-void PlatformPath::ensureSubpath()
-{
- if (m_penLifted) {
- m_penLifted = false;
- m_subpaths.append(PathPolygon());
- m_subpaths.last().append(m_currentPoint);
- } else
- ASSERT(!m_subpaths.isEmpty());
-}
-
-void PlatformPath::addToSubpath(const PlatformPathElement& e)
-{
- if (e.platformType() == PlatformPathElement::PathMoveTo) {
- m_penLifted = true;
- m_currentPoint = e.pointAt(0);
- } else if (e.platformType() == PlatformPathElement::PathCloseSubpath) {
- m_penLifted = true;
- if (!m_subpaths.isEmpty()) {
- if (m_currentPoint != m_subpaths.last()[0]) {
- // According to W3C, we have to draw a line from current point to the initial point
- m_subpaths.last().append(m_subpaths.last()[0]);
- m_currentPoint = m_subpaths.last()[0];
- }
- } else
- m_currentPoint.clear();
- } else {
- ensureSubpath();
- switch (e.platformType()) {
- case PlatformPathElement::PathLineTo:
- m_subpaths.last().append(e.pointAt(0));
- break;
- case PlatformPathElement::PathArcTo:
- addArcPoints(m_subpaths.last(), e.arcTo());
- break;
- case PlatformPathElement::PathQuadCurveTo:
- {
- PathPoint control[] = {
- m_currentPoint,
- e.pointAt(0),
- e.pointAt(1),
- };
- // FIXME: magic number?
- quadCurve(50, m_subpaths.last(), control);
- }
- break;
- case PlatformPathElement::PathBezierCurveTo:
- {
- PathPoint control[] = {
- m_currentPoint,
- e.pointAt(0),
- e.pointAt(1),
- e.pointAt(2),
- };
- // FIXME: magic number?
- bezier(100, m_subpaths.last(), control);
- }
- break;
- default:
- ASSERT_NOT_REACHED();
- break;
- }
- m_currentPoint = m_subpaths.last().last();
- }
-}
-
-void PlatformPath::append(const PlatformPathElement& e)
-{
- e.inflateRectToContainMe(m_boundingRect, lastPoint());
- addToSubpath(e);
- m_elements.append(e);
-}
-
-void PlatformPath::append(const PlatformPath& p)
-{
- const PlatformPathElements& e = p.elements();
- for (PlatformPathElements::const_iterator it(e.begin()); it != e.end(); ++it) {
- addToSubpath(*it);
- it->inflateRectToContainMe(m_boundingRect, lastPoint());
- m_elements.append(*it);
- }
-}
-
-void PlatformPath::clear()
-{
- m_elements.clear();
- m_boundingRect = FloatRect();
- m_subpaths.clear();
- m_currentPoint.clear();
- m_penLifted = true;
-}
-
-void PlatformPath::strokePath(HDC dc, const AffineTransform* transformation) const
-{
- drawPolygons(dc, m_subpaths, false, transformation);
-}
-
-void PlatformPath::fillPath(HDC dc, const AffineTransform* transformation) const
-{
- HGDIOBJ oldPen = SelectObject(dc, GetStockObject(NULL_PEN));
- drawPolygons(dc, m_subpaths, true, transformation);
- SelectObject(dc, oldPen);
-}
-
-void PlatformPath::translate(const FloatSize& size)
-{
- for (PlatformPathElements::iterator it(m_elements.begin()); it != m_elements.end(); ++it)
- it->move(size);
-
- m_boundingRect.move(size);
- for (Vector<PathPolygon>::iterator it = m_subpaths.begin(); it != m_subpaths.end(); ++it)
- it->move(size);
-}
-
-void PlatformPath::transform(const AffineTransform& t)
-{
- for (PlatformPathElements::iterator it(m_elements.begin()); it != m_elements.end(); ++it)
- it->transform(t);
-
- m_boundingRect = t.mapRect(m_boundingRect);
- for (Vector<PathPolygon>::iterator it = m_subpaths.begin(); it != m_subpaths.end(); ++it)
- it->transform(t);
-}
-
-bool PlatformPath::contains(const FloatPoint& point, WindRule rule) const
-{
- // optimization: check the bounding rect first
- if (!containsPoint(m_boundingRect, point))
- return false;
-
- for (Vector<PathPolygon>::const_iterator i = m_subpaths.begin(); i != m_subpaths.end(); ++i) {
- if (i->contains(point))
- return true;
- }
-
- return false;
-}
-
-void PlatformPath::moveTo(const FloatPoint& point)
-{
- PlatformPathElement::MoveTo data = { { point.x(), point.y() } };
- PlatformPathElement pe(data);
- append(pe);
-}
-
-void PlatformPath::addLineTo(const FloatPoint& point)
-{
- PlatformPathElement::LineTo data = { { point.x(), point.y() } };
- PlatformPathElement pe(data);
- append(pe);
-}
-
-void PlatformPath::addQuadCurveTo(const FloatPoint& cp, const FloatPoint& p)
-{
- PlatformPathElement::QuadCurveTo data = { { cp.x(), cp.y() }, { p.x(), p.y() } };
- PlatformPathElement pe(data);
- append(pe);
-}
-
-void PlatformPath::addBezierCurveTo(const FloatPoint& cp1, const FloatPoint& cp2, const FloatPoint& p)
-{
- PlatformPathElement::BezierCurveTo data = { { cp1.x(), cp1.y() }, { cp2.x(), cp2.y() }, { p.x(), p.y() } };
- PlatformPathElement pe(data);
- append(pe);
-}
-
-void PlatformPath::addArcTo(const FloatPoint& fp1, const FloatPoint& fp2, float radius)
-{
- const PathPoint& p0 = m_currentPoint;
- PathPoint p1;
- p1 = fp1;
- PathPoint p2;
- p2 = fp2;
- if (!radius || p0 == p1 || p1 == p2) {
- addLineTo(p1);
- return;
- }
-
- PathVector v01 = p0 - p1;
- PathVector v21 = p2 - p1;
-
- // sin(A - B) = sin(A) * cos(B) - sin(B) * cos(A)
- double cross = v01.m_x * v21.m_y - v01.m_y * v21.m_x;
-
- if (fabs(cross) < 1E-10) {
- // on one line
- addLineTo(p1);
- return;
- }
-
- double d01 = v01.length();
- double d21 = v21.length();
- double angle = (piDouble - fabs(asin(cross / (d01 * d21)))) * 0.5;
- double span = radius * tan(angle);
- double rate = span / d01;
- PathPoint startPoint;
- startPoint.m_x = p1.m_x + v01.m_x * rate;
- startPoint.m_y = p1.m_y + v01.m_y * rate;
-
- addLineTo(startPoint);
-
- PathPoint endPoint;
- rate = span / d21;
- endPoint.m_x = p1.m_x + v21.m_x * rate;
- endPoint.m_y = p1.m_y + v21.m_y * rate;
-
- PathPoint midPoint;
- midPoint.m_x = (startPoint.m_x + endPoint.m_x) * 0.5;
- midPoint.m_y = (startPoint.m_y + endPoint.m_y) * 0.5;
-
- PathVector vm1 = midPoint - p1;
- double dm1 = vm1.length();
- double d = _hypot(radius, span);
-
- PathPoint centerPoint;
- rate = d / dm1;
- centerPoint.m_x = p1.m_x + vm1.m_x * rate;
- centerPoint.m_y = p1.m_y + vm1.m_y * rate;
-
- PlatformPathElement::ArcTo data = {
- endPoint,
- centerPoint,
- { radius, radius },
- cross < 0
- };
- PlatformPathElement pe(data);
- append(pe);
-}
-
-void PlatformPath::closeSubpath()
-{
- PlatformPathElement pe;
- append(pe);
-}
-
-// add a circular arc centred at p with radius r from start angle sar (radians) to end angle ear
-void PlatformPath::addEllipse(const FloatPoint& p, float a, float b, float sar, float ear, bool anticlockwise)
-{
- float startX, startY, endX, endY;
-
- normalizeAngle(sar);
- normalizeAngle(ear);
-
- getEllipsePointByAngle(sar, a, b, startX, startY);
- getEllipsePointByAngle(ear, a, b, endX, endY);
-
- transformArcPoint(startX, startY, p);
- transformArcPoint(endX, endY, p);
-
- FloatPoint start(startX, startY);
- moveTo(start);
-
- PlatformPathElement::ArcTo data = { { endX, endY }, { p.x(), p.y() }, { a, b }, !anticlockwise };
- PlatformPathElement pe(data);
- append(pe);
-}
-
-
-void PlatformPath::addRect(const FloatRect& r)
-{
- moveTo(r.location());
-
- float right = r.maxX() - 1;
- float bottom = r.maxY() - 1;
- addLineTo(FloatPoint(right, r.y()));
- addLineTo(FloatPoint(right, bottom));
- addLineTo(FloatPoint(r.x(), bottom));
- addLineTo(r.location());
-}
-
-void PlatformPath::addEllipse(const FloatRect& r)
-{
- FloatSize radius(r.width() * 0.5, r.height() * 0.5);
- addEllipse(r.location() + radius, radius.width(), radius.height(), 0, 0, true);
-}
-
-void PlatformPath::apply(void* info, PathApplierFunction function) const
-{
- PathElement pelement;
- FloatPoint points[3];
- pelement.points = points;
-
- for (PlatformPathElements::const_iterator it(m_elements.begin()); it != m_elements.end(); ++it) {
- pelement.type = it->type();
- int n = it->numPoints();
- for (int i = 0; i < n; ++i)
- points[i] = it->pointAt(i);
- function(info, &pelement);
- }
-}
-
-} // namespace Webcore
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-#ifndef PlatformPathWinCE_h
-#define PlatformPathWinCE_h
-
-#include "FloatPoint.h"
-#include "FloatRect.h"
-#include "Path.h"
-#include <windows.h>
-#include <wtf/Vector.h>
-
-namespace WebCore {
-
- class GraphicsContext;
-
- struct PathPoint {
- float m_x;
- float m_y;
- const float& x() const { return m_x; }
- const float& y() const { return m_y; }
- void set(float x, float y)
- {
- m_x = x;
- m_y = y;
- };
- operator FloatPoint() const { return FloatPoint(m_x, m_y); }
- void move(const FloatSize& offset)
- {
- m_x += offset.width();
- m_y += offset.height();
- }
- PathPoint& operator=(const FloatPoint& p)
- {
- m_x = p.x();
- m_y = p.y();
- return *this;
- }
- void clear() { m_x = m_y = 0; }
- };
-
- struct PathPolygon: public Vector<PathPoint> {
- void move(const FloatSize& offset);
- void transform(const AffineTransform& t);
- bool contains(const FloatPoint& point) const;
- };
-
- class PlatformPathElement {
- public:
- enum PlaformPathElementType {
- PathMoveTo,
- PathLineTo,
- PathArcTo,
- PathQuadCurveTo,
- PathBezierCurveTo,
- PathCloseSubpath,
- };
-
- struct MoveTo {
- PathPoint m_end;
- };
-
- struct LineTo {
- PathPoint m_end;
- };
-
- struct ArcTo {
- PathPoint m_end;
- PathPoint m_center;
- PathPoint m_radius;
- bool m_clockwise;
- };
-
- struct QuadCurveTo {
- PathPoint m_point0;
- PathPoint m_point1;
- };
-
- struct BezierCurveTo {
- PathPoint m_point0;
- PathPoint m_point1;
- PathPoint m_point2;
- };
-
- PlatformPathElement(): m_type(PathCloseSubpath) { m_data.m_points[0].set(0, 0); }
- PlatformPathElement(const MoveTo& data): m_type(PathMoveTo) { m_data.m_moveToData = data; }
- PlatformPathElement(const LineTo& data): m_type(PathLineTo) { m_data.m_lineToData = data; }
- PlatformPathElement(const ArcTo& data): m_type(PathArcTo) { m_data.m_arcToData = data; }
- PlatformPathElement(const QuadCurveTo& data): m_type(PathQuadCurveTo) { m_data.m_quadCurveToData = data; }
- PlatformPathElement(const BezierCurveTo& data): m_type(PathBezierCurveTo) { m_data.m_bezierCurveToData = data; }
-
- const MoveTo& moveTo() const { return m_data.m_moveToData; }
- const LineTo& lineTo() const { return m_data.m_lineToData; }
- const ArcTo& arcTo() const { return m_data.m_arcToData; }
- const QuadCurveTo& quadCurveTo() const { return m_data.m_quadCurveToData; }
- const BezierCurveTo& bezierCurveTo() const { return m_data.m_bezierCurveToData; }
- const PathPoint& lastPoint() const
- {
- int n = numPoints();
- return n > 1 ? m_data.m_points[n - 1] : m_data.m_points[0];
- }
- const PathPoint& pointAt(int index) const { return m_data.m_points[index]; }
- int numPoints() const;
- int numControlPoints() const;
- void move(const FloatSize& offset);
- void transform(const AffineTransform& t);
- PathElementType type() const;
- PlaformPathElementType platformType() const { return m_type; }
- void inflateRectToContainMe(FloatRect& r, const FloatPoint& lastPoint) const;
-
- private:
- PlaformPathElementType m_type;
- union {
- MoveTo m_moveToData;
- LineTo m_lineToData;
- ArcTo m_arcToData;
- QuadCurveTo m_quadCurveToData;
- BezierCurveTo m_bezierCurveToData;
- PathPoint m_points[4];
- } m_data;
- };
-
- typedef Vector<PlatformPathElement> PlatformPathElements;
-
- class PlatformPath {
- public:
- PlatformPath();
- const PlatformPathElements& elements() const { return m_elements; }
- void append(const PlatformPathElement& e);
- void append(const PlatformPath& p);
- void clear();
- bool isEmpty() const { return m_elements.isEmpty(); }
-
- void strokePath(HDC, const AffineTransform* tr) const;
- void fillPath(HDC, const AffineTransform* tr) const;
- FloatPoint lastPoint() const { return m_elements.isEmpty() ? FloatPoint(0, 0) : m_elements.last().lastPoint(); }
-
- const FloatRect& boundingRect() const { return m_boundingRect; }
- bool contains(const FloatPoint& point, WindRule rule) const;
- void translate(const FloatSize& size);
- void transform(const AffineTransform& t);
-
- void moveTo(const FloatPoint&);
- void addLineTo(const FloatPoint&);
- void addQuadCurveTo(const FloatPoint& controlPoint, const FloatPoint& point);
- void addBezierCurveTo(const FloatPoint& controlPoint1, const FloatPoint& controlPoint2, const FloatPoint&);
- void addArcTo(const FloatPoint&, const FloatPoint&, float radius);
- void closeSubpath();
- void addEllipse(const FloatPoint& p, float a, float b, float sar, float ear, bool anticlockwise);
- void addRect(const FloatRect& r);
- void addEllipse(const FloatRect& r);
- void apply(void* info, PathApplierFunction function) const;
-
- private:
- void ensureSubpath();
- void addToSubpath(const PlatformPathElement& e);
-
- PlatformPathElements m_elements;
- FloatRect m_boundingRect;
- Vector<PathPolygon> m_subpaths;
- PathPoint m_currentPoint;
- bool m_penLifted;
- };
-
-}
-
-#endif // PlatformPathWinCE_h
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile, Inc. All rights reserved.
- * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-#include "config.h"
-#include "SharedBitmap.h"
-
-#include "GDIExtras.h"
-#include "GraphicsContext.h"
-#include "GraphicsTypes.h"
-#include "TransformationMatrix.h"
-#include "WinCEGraphicsExtras.h"
-#include <wtf/HashSet.h>
-#include <wtf/OwnPtr.h>
-#include <wtf/RefCountedLeakCounter.h>
-#include <wtf/StdLibExtras.h>
-
-#include <windows.h>
-
-namespace WebCore {
-
-#ifndef NDEBUG
-static WTF::RefCountedLeakCounter sharedBitmapLeakCounter("SharedBitmap");
-#endif
-
-
-PassRefPtr<SharedBitmap> SharedBitmap::create(const IntSize& size, BitmapInfo::BitCount bitCount, bool initPixels)
-{
- RefPtr<SharedBitmap> resultantBitmap = adoptRef(new SharedBitmap(size, bitCount, initPixels));
- if (resultantBitmap && !resultantBitmap->bytes())
- return 0;
- return resultantBitmap.release();
-}
-
-PassRefPtr<SharedBitmap> SharedBitmap::create(const Vector<unsigned>& data, const IntSize& size, bool hasAlpha)
-{
- RefPtr<SharedBitmap> result = create(size, BitmapInfo::BitCount32, false);
- if (!result)
- return 0;
- memcpy(result->bytes(), data.data(), data.size() * sizeof(unsigned));
- result->setHasAlpha(hasAlpha);
- return result.release();
-}
-
-SharedBitmap::SharedBitmap(const IntSize& size, BitmapInfo::BitCount bitCount, bool initPixels)
- : m_bmpInfo(BitmapInfo::createBottomUp(size, bitCount))
- , m_locked(false)
- , m_usesTransparentColor(false)
- , m_transparentColor(RGB(0, 0, 0))
- , m_pixels(0)
- , m_hasAlpha(false)
- , m_validHeight(abs(size.height()))
-{
-#ifndef NDEBUG
- sharedBitmapLeakCounter.increment();
-#endif
-
- unsigned bufferSize = m_bmpInfo.numPixels();
- if (bitCount == BitmapInfo::BitCount16)
- bufferSize /= 2;
-
- m_pixelData = std::make_unique<unsigned[]>(bufferSize);
- m_pixels = m_pixelData.get();
-
- if (initPixels)
- resetPixels();
-}
-
-SharedBitmap::~SharedBitmap()
-{
-#ifndef NDEBUG
- sharedBitmapLeakCounter.decrement();
-#endif
-}
-
-void SharedBitmap::resetPixels(bool black)
-{
- if (!m_pixels)
- return;
-
- unsigned bufferSize = m_bmpInfo.numPixels();
- if (black) {
- unsigned bufferSizeInBytes = bufferSize * (is16bit() ? 2 : 4);
- memset(m_pixels, 0, bufferSizeInBytes);
- return;
- }
-
- if (is16bit()) {
- // Fill it with white color
- wmemset(static_cast<wchar_t*>(m_pixels), 0xFFFF, bufferSize);
- return;
- }
-
- // Make it white but transparent
- unsigned* pixel = static_cast<unsigned*>(m_pixels);
- const unsigned* bufferEnd = pixel + bufferSize;
- while (pixel < bufferEnd)
- *pixel++ = 0x00FFFFFF;
-}
-
-static inline unsigned short convert32To16(unsigned pixel)
-{
- unsigned short r = static_cast<unsigned short>((pixel & 0x00F80000) >> 8);
- unsigned short g = static_cast<unsigned short>((pixel & 0x0000FC00) >> 5);
- unsigned short b = static_cast<unsigned short>((pixel & 0x000000F8) >> 3);
- return r | g | b;
-}
-
-bool SharedBitmap::to16bit()
-{
- if (m_locked)
- return false;
- if (is16bit())
- return true;
-
- BitmapInfo newBmpInfo = BitmapInfo::create(m_bmpInfo.size(), BitmapInfo::BitCount16);
-
- int width = newBmpInfo.width();
- int paddedWidth = newBmpInfo.paddedWidth();
- int bufferSize = paddedWidth * newBmpInfo.height();
- auto newPixelData = std::make_unique<unsigned[]>(bufferSize / 2);
- void* newPixels = newPixelData.get();
-
- if (!newPixels)
- return false;
-
- unsigned short* p16 = static_cast<unsigned short*>(newPixels);
- const unsigned* p32 = static_cast<const unsigned*>(m_pixels);
-
- bool skips = paddedWidth != width;
-
- const unsigned short* p16end = p16 + bufferSize;
- while (p16 < p16end) {
- for (unsigned short* p16lineEnd = p16 + width; p16 < p16lineEnd; )
- *p16++ = convert32To16(*p32++);
-
- if (skips)
- *p16++ = 0;
- }
-
- if (m_hbitmap)
- m_hbitmap = nullptr;
- else
- m_pixelData = newPixelData.release();
-
- m_pixels = newPixels;
- m_bmpInfo = newBmpInfo;
-
- setHasAlpha(false);
- return true;
-}
-
-bool SharedBitmap::freeMemory()
-{
- if (m_locked)
- return false;
-
- if (m_hbitmap) {
- m_hbitmap = nullptr;
- m_pixels = 0;
- return true;
- }
-
- if (m_pixels) {
- m_pixelData = nullptr;
- m_pixels = 0;
- return true;
- }
-
- return false;
-}
-
-GDIObject<HBITMAP> SharedBitmap::createHandle(void** pixels, BitmapInfo* bmpInfo, int height, bool use16bit) const
-{
- if (!m_pixels)
- return nullptr;
-
- if (height == -1)
- height = this->height();
- *bmpInfo = BitmapInfo::createBottomUp(IntSize(width(), height), (use16bit || is16bit()) ? BitmapInfo::BitCount16 : BitmapInfo::BitCount32);
-
- auto hbmp = adoptGDIObject(::CreateDIBSection(0, bmpInfo, DIB_RGB_COLORS, pixels, 0, 0));
-
- if (!hbmp)
- return nullptr;
-
- auto bmpDC = adoptGDIObject(::CreateCompatibleDC(0));
- HGDIOBJ hOldBmp = SelectObject(bmpDC.get(), hbmp.get());
-
- StretchDIBits(bmpDC.get(), 0, 0, width(), height, 0, 0, width(), height, m_pixels, &m_bmpInfo, DIB_RGB_COLORS, SRCCOPY);
-
- SelectObject(bmpDC.get(), hOldBmp);
-
- return hbmp;
-}
-
-bool SharedBitmap::ensureHandle()
-{
- if (m_hbitmap)
- return true;
-
- if (!m_pixels)
- return false;
-
- if (m_locked)
- return false;
-
- BitmapInfo bmpInfo;
- void* pixels;
- m_hbitmap = createHandle(&pixels, &bmpInfo, -1, !hasAlpha());
-
- if (!m_hbitmap)
- return false;
-
- m_pixelData = nullptr;
- m_pixels = pixels;
- m_bmpInfo = bmpInfo;
-
- return true;
-}
-
-void SharedBitmap::draw(GraphicsContext* ctxt, const IntRect& dstRect, const IntRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp, BlendMode blendMode)
-{
- if (!m_pixels)
- return;
- ctxt->drawBitmap(this, dstRect, srcRect, styleColorSpace, compositeOp, blendMode);
-}
-
-void SharedBitmap::draw(HDC hdc, const IntRect& dstRect, const IntRect& srcRect, CompositeOperator compositeOp, BlendMode blendMode)
-{
- if (!m_pixels)
- return;
-
- if (dstRect.isEmpty() || srcRect.isEmpty())
- return;
-
- HBITMAP hbitmap = 0;
- GDIObject<HBITMAP> hTempBitmap;
- bool usingHandle = compositeOp == CompositeSourceOver && (hasAlpha() && hasAlphaBlendSupport() || usesTransparentColor());
-
- if (usingHandle) {
- if (ensureHandle())
- hbitmap = m_hbitmap.get();
- else {
- void* pixels;
- BitmapInfo bmpInfo;
- hTempBitmap = createHandle(&pixels, &bmpInfo, -1, usesTransparentColor());
- hbitmap = hTempBitmap.get();
- }
- }
- if (!hbitmap) {
- // FIXME: handle other composite operation types?
- DWORD rop = compositeOp == CompositeCopy ? SRCCOPY
- : compositeOp == CompositeXOR ? PATINVERT
- : compositeOp == CompositeClear ? WHITENESS
- : SRCCOPY;
-
- StretchDIBits(hdc, dstRect.x(), dstRect.y(), dstRect.width(), dstRect.height(),
- srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height(), m_pixels, &m_bmpInfo, DIB_RGB_COLORS, rop);
- return;
- }
-
- auto hmemdc = adoptGDIObject(::CreateCompatibleDC(hdc));
- HGDIOBJ hOldBmp = SelectObject(hmemdc.get(), hbitmap);
-
- if (!usesTransparentColor() && hasAlphaBlendSupport()) {
- static const BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
- bool success = alphaBlendIfSupported(hdc, dstRect.x(), dstRect.y(), dstRect.width(), dstRect.height(), hmemdc.get(),
- srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height(), blend);
- ASSERT_UNUSED(success, success);
- } else {
- TransparentBlt(hdc, dstRect.x(), dstRect.y(), dstRect.width(), dstRect.height(), hmemdc.get(),
- srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height(), transparentColor());
- }
-
- SelectObject(hmemdc.get(), hOldBmp);
-}
-
-GDIObject<HBITMAP> SharedBitmap::clipBitmap(const IntRect& rect, bool useAlpha, BitmapInfo& bmpInfo, void*& pixels)
-{
- if (!bytes())
- return nullptr;
-
- int oldWidth = width();
- int oldHeight = height();
- int copyWidth = std::min<int>(rect.width(), oldWidth - rect.x());
- int copyHeight = std::min<int>(rect.height(), oldHeight - rect.y());
- if (!copyWidth || !copyHeight)
- return nullptr;
-
- bmpInfo = BitmapInfo::createBottomUp(IntSize(copyWidth, copyHeight), (useAlpha && is32bit()) ? BitmapInfo::BitCount32 : BitmapInfo::BitCount16);
- auto newBmp = adoptGDIObject(::CreateDIBSection(0, &bmpInfo, DIB_RGB_COLORS, &pixels, 0, 0));
-
- if (!newBmp)
- return nullptr;
-
- auto dcNew = adoptGDIObject(::CreateCompatibleDC(0));
- HGDIOBJ tmpNew = SelectObject(dcNew.get(), newBmp.get());
-
- StretchDIBits(dcNew.get(), 0, 0, copyWidth, copyHeight, rect.x(), rect.y(), copyWidth, copyHeight,
- bytes(), &bitmapInfo(), DIB_RGB_COLORS, SRCCOPY);
-
- SelectObject(dcNew.get(), tmpNew);
- return newBmp;
-}
-
-PassRefPtr<SharedBitmap> SharedBitmap::clipBitmap(const IntRect& rect, bool useAlpha)
-{
- int oldWidth = width();
- int oldHeight = height();
- int copyWidth = std::min<int>(rect.width(), oldWidth - rect.x());
- int copyHeight = std::min<int>(rect.height(), oldHeight - rect.y());
- if (!copyWidth || !copyHeight)
- return 0;
-
- RefPtr<SharedBitmap> newBmp = create(IntSize(copyWidth, copyHeight), useAlpha && is32bit() ? BitmapInfo::BitCount32 : BitmapInfo::BitCount16, false);
-
- if (!newBmp || !newBmp->bytes())
- return 0;
-
- DCHolder dcNew(newBmp.get());
-
- StretchDIBits(dcNew.get(), 0, 0, copyWidth, copyHeight, rect.x(), rect.y(), copyWidth, copyHeight,
- bytes(), &bitmapInfo(), DIB_RGB_COLORS, SRCCOPY);
-
- return newBmp;
-}
-
-static void drawPatternSimple(HDC hdc, const RECT& destRect, HBITMAP hbmp, const POINT& phase)
-{
- auto hBrush = adoptGDIObject(::CreatePatternBrush(hbmp));
- if (!hBrush)
- return;
-
- POINT oldOrg;
- SetBrushOrgEx(hdc, destRect.left - phase.x, destRect.top - phase.y, &oldOrg);
- FillRect(hdc, &destRect, hBrush.get());
- SetBrushOrgEx(hdc, oldOrg.x, oldOrg.y, 0);
-}
-
-static void drawPatternSimple(HDC hdc, const RECT& destRect, const SharedBitmap* bmp, const SIZE& bmpSize, const POINT& phase)
-{
- int dstY = destRect.top;
- for (int sourceY = phase.y; dstY < destRect.bottom; ) {
- int sourceH = std::min<int>(bmpSize.cy - sourceY, destRect.bottom - dstY);
- int dstX = destRect.left;
- for (int sourceX = phase.x; dstX < destRect.right; ) {
- int sourceW = std::min<int>(bmpSize.cx - sourceX, destRect.right - dstX);
-
- StretchDIBits(hdc, dstX, dstY, sourceW, sourceH, sourceX, sourceY, sourceW, sourceH,
- bmp->bytes(), &bmp->bitmapInfo(), DIB_RGB_COLORS, SRCCOPY);
-
- dstX += sourceW;
- sourceX = 0;
- }
-
- dstY += sourceH;
- sourceY = 0;
- }
-}
-
-static LONG normalizePhase(LONG phase, int limit)
-{
- if (!phase || limit < 2)
- return 0;
-
- if (limit == 2)
- return phase & 1;
-
- if (phase < 0) {
- phase = -phase;
- if (phase > limit)
- phase = static_cast<LONG>(static_cast<unsigned>(phase) % static_cast<unsigned>(limit));
- if (phase)
- phase = limit - phase;
- return phase;
- }
-
- if (phase < limit)
- return phase;
-
- return static_cast<LONG>(static_cast<unsigned>(phase) % static_cast<unsigned>(limit));
-}
-
-void SharedBitmap::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, const IntSize& origSourceSize)
-{
- if (!m_pixels)
- return;
- ctxt->drawBitmapPattern(this, tileRectIn, patternTransform, phase, styleColorSpace, op, destRect, origSourceSize);
-}
-
-void SharedBitmap::drawPattern(HDC hdc, const AffineTransform& transform, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, const IntSize& origSourceSize)
-{
- if (!m_pixels)
- return;
-
- if (tileRectIn.width() <= 0 || tileRectIn.height() <= 0)
- return;
-
- bool useAlpha = op == CompositeSourceOver && hasAlpha() && is32bit();
-
- int bmpWidth = width();
- int bmpHeight = height();
-
- FloatRect tileRect(tileRectIn);
- if (bmpWidth != origSourceSize.width()) {
- double rate = static_cast<double>(bmpWidth) / origSourceSize.width();
- double temp = tileRect.width() * rate;
- tileRect.setX(tileRect.x() * rate);
- tileRect.setWidth(temp);
- temp = tileRect.height() * rate;
- tileRect.setY(tileRect.y() * rate);
- tileRect.setHeight(temp);
- }
-
- GDIObject<HBITMAP> clippedBmp;
-
- if (tileRect.x() || tileRect.y() || tileRect.width() != bmpWidth || tileRect.height() != bmpHeight) {
- BitmapInfo patternBmpInfo;
- void* patternPixels;
- clippedBmp = clipBitmap(IntRect(tileRect), useAlpha, patternBmpInfo, patternPixels);
- if (!clippedBmp)
- return;
-
- bmpWidth = tileRect.width();
- bmpHeight = tileRect.height();
- }
-
- AffineTransform tf = patternTransform * transform;
-
- FloatRect trRect = tf.mapRect(destRect);
-
- RECT clipBox;
- int clipType = GetClipBox(hdc, &clipBox);
- if (clipType == SIMPLEREGION)
- trRect.intersect(FloatRect(clipBox.left, clipBox.top, clipBox.right - clipBox.left, clipBox.bottom - clipBox.top));
- else if (clipType == COMPLEXREGION) {
- auto clipRgn = adoptGDIObject(::CreateRectRgn(0, 0, 0, 0));
- if (GetClipRgn(hdc, clipRgn.get()) > 0) {
- DWORD regionDataSize = GetRegionData(clipRgn.get(), sizeof(RGNDATA), 0);
- if (regionDataSize) {
- Vector<RGNDATA> regionData(regionDataSize);
- GetRegionData(clipRgn.get(), regionDataSize, regionData.data());
- RECT* rect = reinterpret_cast<RECT*>(regionData[0].Buffer);
- for (DWORD i = 0; i < regionData[0].rdh.nCount; ++i, ++rect)
- trRect.intersect(FloatRect(rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top));
- }
- }
- }
-
- if (trRect.width() <= 0 || trRect.height() <= 0)
- return;
-
- trRect.inflate(1);
- IntRect visibleDstRect = enclosingIntRect(tf.inverse().mapRect(trRect));
- visibleDstRect.intersect(IntRect(destRect));
-
- if (visibleDstRect.width() <= 0 || visibleDstRect.height() <= 0)
- return;
-
- trRect = tf.mapRect(visibleDstRect);
- RECT dstRectWin = {
- stableRound(trRect.x()),
- stableRound(trRect.y()),
- stableRound(trRect.maxX()),
- stableRound(trRect.maxY()),
- };
- if (dstRectWin.right <= dstRectWin.left || dstRectWin.bottom <= dstRectWin.top)
- return;
-
- SIZE bmpSize = { bmpWidth, bmpHeight };
-
- // Relative to destination, in bitmap pixels
- POINT phaseWin = { stableRound(visibleDstRect.x() - phase.x()), stableRound(visibleDstRect.y() - phase.y()) };
- phaseWin.x = normalizePhase(phaseWin.x, bmpSize.cx);
- phaseWin.y = normalizePhase(phaseWin.y, bmpSize.cy);
-
- RECT srcRectWin = {
- 0,
- 0,
- stableRound(visibleDstRect.maxX()) - stableRound(visibleDstRect.x()),
- stableRound(visibleDstRect.maxY()) - stableRound(visibleDstRect.y())
- };
- if (srcRectWin.right <= 0 || srcRectWin.bottom <= 0)
- return;
-
- BitmapInfo bmpInfo = BitmapInfo::createBottomUp(IntSize(srcRectWin.right, srcRectWin.bottom), useAlpha ? BitmapInfo::BitCount32 : BitmapInfo::BitCount16);
- void* pixels;
- auto hbmpTemp = adoptGDIObject(::CreateDIBSection(0, &bmpInfo, DIB_RGB_COLORS, &pixels, 0, 0));
-
- if (!hbmpTemp)
- return;
-
- auto hmemdc = adoptGDIObject(::CreateCompatibleDC(hdc));
- HGDIOBJ oldBmp = SelectObject(hmemdc.get(), hbmpTemp.get());
- if (clippedBmp)
- drawPatternSimple(hmemdc.get(), srcRectWin, clippedBmp.get(), phaseWin);
- else if ((op != CompositeSourceOver || canUseDIBits()) && srcRectWin.right <= bmpSize.cx * 2 && srcRectWin.bottom <= bmpSize.cy * 2)
- drawPatternSimple(hmemdc.get(), srcRectWin, this, bmpSize, phaseWin);
- else if (ensureHandle())
- drawPatternSimple(hmemdc.get(), srcRectWin, getHandle(), phaseWin);
- else {
- void* pixels;
- BitmapInfo bmpInfo;
- auto hbmp = createHandle(&pixels, &bmpInfo, -1, false);
- if (hbmp)
- drawPatternSimple(hmemdc.get(), srcRectWin, hbmp.get(), phaseWin);
- else {
- SelectObject(hmemdc.get(), oldBmp);
- return;
- }
- }
-
- if (useAlpha && hasAlphaBlendSupport()) {
- static const BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
- bool success = alphaBlendIfSupported(hdc, dstRectWin.left, dstRectWin.top, dstRectWin.right - dstRectWin.left, dstRectWin.bottom - dstRectWin.top,
- hmemdc.get(), 0, 0, srcRectWin.right, srcRectWin.bottom, blend);
- ASSERT_UNUSED(success, success);
- } else if (useAlpha && !hasAlphaBlendSupport() || op == CompositeSourceOver && usesTransparentColor()) {
- TransparentBlt(hdc, dstRectWin.left, dstRectWin.top, dstRectWin.right - dstRectWin.left,
- dstRectWin.bottom - dstRectWin.top, hmemdc.get(), 0, 0, srcRectWin.right, srcRectWin.bottom, transparentColor());
- } else {
- DWORD bmpOp = op == CompositeCopy ? SRCCOPY
- : op == CompositeSourceOver ? SRCCOPY
- : op == CompositeXOR ? PATINVERT
- : op == CompositeClear ? WHITENESS
- : SRCCOPY; // FIXEME: other types?
-
- StretchDIBits(hdc, dstRectWin.left, dstRectWin.top, dstRectWin.right - dstRectWin.left,
- dstRectWin.bottom - dstRectWin.top, 0, 0, srcRectWin.right, srcRectWin.bottom,
- pixels, &bmpInfo, DIB_RGB_COLORS, bmpOp);
- }
- SelectObject(hmemdc.get(), oldBmp);
-}
-
-SharedBitmap::DCProvider* SharedBitmap::s_dcProvider = new SharedBitmap::DCProvider;
-
-HDC SharedBitmap::DCProvider::getDC(SharedBitmap* bmp, unsigned* key)
-{
- if (!bmp || !bmp->ensureHandle())
- return 0;
-
- HDC hdc = CreateCompatibleDC(0);
- if (!hdc)
- return 0;
-
- *key = reinterpret_cast<unsigned>(SelectObject(hdc, bmp->getHandle()));
- RECT rect = { 0, 0, bmp->width(), bmp->height() };
- auto clipRgn = adoptGDIObject(::CreateRectRgnIndirect(&rect));
- SelectClipRgn(hdc, clipRgn.get());
-
- return hdc;
-}
-
-void SharedBitmap::DCProvider::releaseDC(SharedBitmap*, HDC hdc, unsigned key1)
-{
- if (!hdc)
- return;
-
- SelectObject(hdc, reinterpret_cast<HGDIOBJ>(key1));
- DeleteDC(hdc);
-}
-
-void SharedBitmap::clearPixels(const IntRect& rect)
-{
- if (!m_pixels)
- return;
-
- IntRect bmpRect(0, 0, width(), height());
- bmpRect.intersect(rect);
- if (is16bit()) {
- unsigned w = m_bmpInfo.paddedWidth();
- unsigned short* dst = static_cast<unsigned short*>(m_pixels);
- dst += bmpRect.y() * w + bmpRect.x();
- int wordsToSet = bmpRect.width();
- const unsigned short* dstEnd = dst + bmpRect.height() * w;
- while (dst < dstEnd) {
- wmemset(reinterpret_cast<wchar_t*>(dst), 0, wordsToSet);
- dst += w;
- }
- return;
- }
-
- unsigned w = width();
- unsigned* dst = static_cast<unsigned*>(m_pixels);
- dst += bmpRect.y() * w + bmpRect.x();
- int wordsToSet = bmpRect.width() * 2;
- const unsigned* dstEnd = dst + bmpRect.height() * w;
- while (dst < dstEnd) {
- wmemset(reinterpret_cast<wchar_t*>(dst), 0, wordsToSet);
- dst += w;
- }
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile, Inc. All rights reserved.
- * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-#ifndef SharedBitmap_h
-#define SharedBitmap_h
-
-#include "AffineTransform.h"
-#include "BitmapInfo.h"
-#include "ColorSpace.h"
-#include "GraphicsTypes.h"
-#include <memory>
-#include <wtf/PassOwnPtr.h>
-#include <wtf/PassRefPtr.h>
-#include <wtf/RefCounted.h>
-#include <wtf/Vector.h>
-#include <wtf/win/GDIObject.h>
-
-namespace WebCore {
-
-class FloatPoint;
-class FloatRect;
-class GraphicsContext;
-class IntRect;
-class IntSize;
-class TransformationMatrix;
-
-class SharedBitmap: public RefCounted<SharedBitmap> {
-public:
- ~SharedBitmap();
- static PassRefPtr<SharedBitmap> create(const IntSize&, BitmapInfo::BitCount = BitmapInfo::BitCount32, bool initPixels = true);
- static PassRefPtr<SharedBitmap> create(const Vector<unsigned>&, const IntSize&, bool hasAlpha = true);
-
- const BitmapInfo& bitmapInfo() const { return m_bmpInfo; }
- void* bytes() { return m_pixels; }
- const void* bytes() const { return m_pixels; }
- unsigned width() const { return m_bmpInfo.width(); }
- unsigned height() const { return m_bmpInfo.height(); }
- unsigned validHeight() const { return m_validHeight; }
- void setValidHeight(unsigned validHeight) { m_validHeight = validHeight; }
- void resetPixels(bool black = false);
- void clearPixels(const IntRect& r);
- bool locked() const { return m_locked; }
- void lock() { m_locked = true; }
- void unlock() { m_locked = false; }
- bool freeMemory();
- bool is16bit() const { return m_bmpInfo.is16bit(); }
- bool is32bit() const { return m_bmpInfo.is32bit(); }
- bool to16bit();
- bool hasAlpha() const { return m_hasAlpha; }
- void setHasAlpha(bool alpha) { m_hasAlpha = alpha; }
- bool ensureHandle();
- HBITMAP getHandle() { return m_hbitmap.get(); }
- GDIObject<HBITMAP> createHandle(void** pixels, BitmapInfo* bmpInfo, int h = -1, bool use16bit = true) const;
- bool usesTransparentColor() const { return m_usesTransparentColor; }
- COLORREF transparentColor() const { return m_transparentColor; }
- void setTransparentColor(COLORREF c)
- {
- m_usesTransparentColor = true;
- m_transparentColor = c;
- }
- bool canUseDIBits() const { return !hasAlpha() && !usesTransparentColor(); }
-
- GDIObject<HBITMAP> clipBitmap(const IntRect&, bool useAlpha, BitmapInfo&, void*& pixels);
-
- PassRefPtr<SharedBitmap> clipBitmap(const IntRect& rect, bool useAlpha);
-
- void draw(GraphicsContext* ctxt, const IntRect& dstRect, const IntRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp, BlendMode blendMode);
- void drawPattern(GraphicsContext* ctxt, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, const IntSize& origSourceSize);
- void draw(HDC, const IntRect& dstRect, const IntRect& srcRect, CompositeOperator compositeOp, BlendMode blendMode);
- void drawPattern(HDC, const AffineTransform&, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
- const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, const IntSize& origSourceSize);
-
- class DCProvider {
- public:
- virtual HDC getDC(SharedBitmap*, unsigned*);
- virtual void releaseDC(SharedBitmap*, HDC, unsigned);
- };
-
- static DCProvider* s_dcProvider;
-
- HDC getDC(unsigned* key1) { return s_dcProvider->getDC(this, key1); }
- void releaseDC(HDC hdc, unsigned key1) { s_dcProvider->releaseDC(this, hdc, key1); }
-
- class DCHolder {
- public:
- DCHolder(SharedBitmap* bmp = 0) { setInternal(bmp); }
- ~DCHolder() { clearInternal(); }
- void set(SharedBitmap* bmp = 0)
- {
- clearInternal();
- setInternal(bmp);
- }
- HDC get() const { return m_hdc; }
- private:
- DCHolder& operator=(const DCHolder&);
- DCHolder(const DCHolder&);
- void clearInternal()
- {
- if (m_hdc)
- m_bitmap->releaseDC(m_hdc, m_key);
- }
- void setInternal(SharedBitmap* bmp)
- {
- m_bitmap = bmp;
- m_hdc = bmp ? bmp->getDC(&m_key) : 0;
- }
- SharedBitmap* m_bitmap;
- HDC m_hdc;
- unsigned m_key;
- };
-
-private:
- SharedBitmap(const IntSize&, BitmapInfo::BitCount, bool initPixels);
- BitmapInfo m_bmpInfo;
- GDIObject<HBITMAP> m_hbitmap;
- void* m_pixels;
- std::unique_ptr<unsigned[]> m_pixelData;
- COLORREF m_transparentColor;
- int m_validHeight;
- bool m_locked;
- bool m_usesTransparentColor;
- bool m_hasAlpha;
-};
-
-} // namespace WebCore
-
-#endif // SharedBitmap_h
+++ /dev/null
-/*
- * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
- * Copyright (C) 2007-2009 Torch Mobile, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of Apple Inc. ("Apple") nor the names of
- * its contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "SimpleFontData.h"
-
-#include "FloatRect.h"
-#include "Font.h"
-#include "FontCache.h"
-#include "FontDescription.h"
-#include <mlang.h>
-#include <wtf/MathExtras.h>
-
-namespace WebCore {
-
-extern HDC g_screenDC;
-
-void SimpleFontData::platformInit()
-{
- if (!m_platformData.isValid())
- return;
-
- const TEXTMETRIC& tm = m_platformData.metrics();
- m_isSystemFont = m_platformData.isSystemFont();
-
- float ascent = (tm.tmAscent * m_platformData.size() + 36) / 72.0f;
- float descent = (tm.tmDescent * m_platformData.size() + 36) / 72.0f;
- float lineGap = (tm.tmExternalLeading * m_platformData.size() + 36) / 72.0f;
- m_fontMetrics.setAscent(ascent);
- m_fontMetrics.setDescent(descent);
- m_fontMetrics.setLineGap(lineGap);
- m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
- m_fontMetrics.setXHeight(ascent * 0.56f);
-}
-
-void SimpleFontData::platformDestroy()
-{
-}
-
-PassRefPtr<SimpleFontData> SimpleFontData::platformCreateScaledFontData(const FontDescription& fontDescription, float scaleFactor) const
-{
- FontDescription fontDesc(fontDescription);
- fontDesc.setComputedSize(lroundf(scaleFactor * fontDesc.computedSize()));
- fontDesc.setSpecifiedSize(lroundf(scaleFactor * fontDesc.specifiedSize()));
- fontDesc.setKeywordSize(lroundf(scaleFactor * fontDesc.keywordSize()));
- FontPlatformData* result = fontCache().getCachedFontPlatformData(fontDesc, m_platformData.family());
- if (!result)
- return 0;
- return SimpleFontData::create(*result);
-}
-
-DWORD getKnownFontCodePages(const wchar_t* family);
-
-bool SimpleFontData::containsCharacters(const UChar* characters, int length) const
-{
- if (m_platformData.isDisabled())
- return true;
-
- // FIXME: Microsoft documentation seems to imply that characters can be output using a given font and DC
- // merely by testing code page intersection. This seems suspect though. Can't a font only partially
- // cover a given code page?
-
- // FIXME: in the case that we failed to get the interface, still use the font.
- IMLangFontLinkType* langFontLink = fontCache().getFontLinkInterface();
- if (!langFontLink)
- return true;
-
- DWORD fontCodePages = m_platformData.codePages();
- if (!fontCodePages)
- return false;
-
- DWORD acpCodePages = 0;
- langFontLink->CodePageToCodePages(CP_ACP, &acpCodePages);
-
- DWORD actualCodePages;
- long numCharactersProcessed;
- while (length) {
- langFontLink->GetStrCodePages(characters, length, acpCodePages, &actualCodePages, &numCharactersProcessed);
- if (actualCodePages && !(actualCodePages & fontCodePages))
- return false;
-
- length -= numCharactersProcessed;
- characters += numCharactersProcessed;
- }
-
- return true;
-}
-
-void SimpleFontData::determinePitch()
-{
- if (!m_platformData.isValid())
- return;
-
- const TEXTMETRIC& tm = m_platformData.metrics();
-
- // Yes, this looks backwards, but the fixed pitch bit is actually set if the font
- // is *not* fixed pitch. Unbelievable but true.
- m_treatAsFixedPitch = !(tm.tmPitchAndFamily & TMPF_FIXED_PITCH);
-}
-
-FloatRect SimpleFontData::platformBoundsForGlyph(Glyph) const
-{
- return FloatRect();
-}
-
-float SimpleFontData::platformWidthForGlyph(Glyph glyph) const
-{
- if (m_platformData.isDisabled())
- return 0;
-
- HGDIOBJ hOldFont = SelectObject(g_screenDC, m_platformData.hfont());
-
- SIZE fontSize;
- wchar_t c = glyph;
- GetTextExtentPoint32(g_screenDC, &c, 1, &fontSize);
-
- SelectObject(g_screenDC, hOldFont);
-
- return (float)fontSize.cx * (float)m_platformData.size() / 72.f;
-}
-
-
-void SimpleFontData::platformCharWidthInit()
-{
- if (!m_platformData.isValid())
- return;
-
- const TEXTMETRIC& tm = m_platformData.metrics();
- m_avgCharWidth = (tm.tmAveCharWidth * m_platformData.size() + 36) / 72;
- m_maxCharWidth = (tm.tmMaxCharWidth * m_platformData.size() + 36) / 72;
-}
-
-} // namespace WebCore
+++ /dev/null
-/*
- * Copyright (C) 2007-2009 Torch Mobile, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-
-#ifndef WinCEGraphicsExtras_h
-#define WinCEGraphicsExtras_h
-
-// This file is used to contain small utilities used by WINCE graphics code.
-
-namespace WebCore {
- // Always round to same direction. 0.5 is rounded to 1,
- // and -0.5 (0.5 - 1) is rounded to 0 (1 - 1), so that it
- // is consistent when transformation shifts.
- static inline int stableRound(double d)
- {
- if (d > 0)
- return static_cast<int>(d + 0.5);
-
- int i = static_cast<int>(d);
- return i - d > 0.5 ? i - 1 : i;
- }
-}
-
-#endif WinCEGraphicsExtras_h
#include <stdio.h> // Needed by jpeglib.h for FILE.
#include <wtf/OwnPtr.h>
-#if OS(WINCE)
-// Remove warning: 'FAR' macro redefinition
-#undef FAR
-
-// jmorecfg.h in libjpeg checks for XMD_H with the comment: "X11/xmd.h correctly defines INT32"
-// fix INT32 redefinition error by pretending we are X11/xmd.h
-#define XMD_H
-#endif
-
extern "C" {
#include "jpeglib.h"
}
memset(&m_overlapped, 0, sizeof(m_overlapped));
-// FIXME: Check m_overlapped on WinCE.
-#if !OS(WINCE)
m_overlapped.hEvent = ::CreateEvent(0, false, false, 0);
::RegisterWaitForSingleObject(&m_waitHandle, m_overlapped.hEvent, addrChangeCallback, this, INFINITE, 0);
registerForAddressChange();
-#endif
}
} // namespace WebCore
#include <wtf/Assertions.h>
#include <wtf/HashTraits.h>
-#if !OS(WINCE)
-#include <guiddef.h>
-#endif
-
typedef long HRESULT;
// FIXME: Should we put this into the WebCore namespace and use "using" on it
#include "TextEncoding.h"
#include "markup.h"
#include <shlobj.h>
+#include <shlwapi.h>
#include <wininet.h> // for INTERNET_MAX_URL_LENGTH
#include <wtf/StringExtras.h>
#include <wtf/text/CString.h>
#include <wtf/text/StringBuilder.h>
-#if !OS(WINCE)
-#include <shlwapi.h>
-#endif
#if USE(CF)
#include <CoreFoundation/CoreFoundation.h>
#include "ContextMenu.h"
-#if OS(WINCE)
-#ifndef MFS_DISABLED
-#define MFS_DISABLED MF_GRAYED
-#endif
-#ifndef MIIM_FTYPE
-#define MIIM_FTYPE MIIM_TYPE
-#endif
-#ifndef MIIM_STRING
-#define MIIM_STRING 0
-#endif
-#endif
-
namespace WebCore {
ContextMenuItem::ContextMenuItem(const MENUITEMINFO& info)
git://git.webkit.org / WebKit-https.git / commitdiff