diff options
Diffstat (limited to 'Source/WebCore/platform/graphics/haiku')
22 files changed, 2446 insertions, 0 deletions
diff --git a/Source/WebCore/platform/graphics/haiku/ColorHaiku.cpp b/Source/WebCore/platform/graphics/haiku/ColorHaiku.cpp new file mode 100644 index 0000000..a9ac186 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/ColorHaiku.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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 COMPUTER, 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 COMPUTER, 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 "Color.h" + +#include <InterfaceDefs.h> + + +namespace WebCore { + +Color::Color(const rgb_color& color) + : m_color(makeRGBA(color.red, color.green, color.blue, color.alpha)) + , m_valid(true) +{ +} + +Color::operator rgb_color() const +{ + return make_color(red(), green(), blue(), alpha()); +} + + +Color focusRingColor() +{ + return Color(keyboard_navigation_color()); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/FloatPointHaiku.cpp b/Source/WebCore/platform/graphics/haiku/FloatPointHaiku.cpp new file mode 100644 index 0000000..0f50898 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/FloatPointHaiku.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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 COMPUTER, 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 COMPUTER, 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 "FloatPoint.h" + +#include <Point.h> + + +namespace WebCore { + +FloatPoint::FloatPoint(const BPoint& point) + : m_x(point.x) + , m_y(point.y) +{ +} + +FloatPoint::operator BPoint() const +{ + return BPoint(m_x, m_y); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/FloatRectHaiku.cpp b/Source/WebCore/platform/graphics/haiku/FloatRectHaiku.cpp new file mode 100644 index 0000000..18fd94b --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/FloatRectHaiku.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de> + * + * 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 COMPUTER, 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 COMPUTER, 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 "FloatRect.h" + +#include <Rect.h> + + +namespace WebCore { + +FloatRect::FloatRect(const BRect& rect) + : m_location(rect.LeftTop()) + , m_size(rect.Width() + 1, rect.Height() + 1) +{ +} + +FloatRect::operator BRect() const +{ + return BRect(BPoint(x(), y()), BSize(width() - 1, height() - 1)); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/FontCacheHaiku.cpp b/Source/WebCore/platform/graphics/haiku/FontCacheHaiku.cpp new file mode 100644 index 0000000..f8c2aa0 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/FontCacheHaiku.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2006 Dirk Mueller <mueller@kde.org> + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de> + * + * 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. + * 3. Neither the name of Apple Computer, 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 "FontPlatformData.h" +#include "NotImplemented.h" +#include <String.h> +#include <interface/Font.h> + +namespace WebCore { + +void FontCache::platformInit() +{ +} + +const SimpleFontData* FontCache::getFontDataForCharacters(const Font& font, const UChar* characters, int length) +{ + FontPlatformData data(font.fontDescription(), font.family().family()); + return getCachedFontData(&data); +} + +SimpleFontData* FontCache::getSimilarFontPlatformData(const Font& font) +{ + notImplemented(); + return 0; +} + +SimpleFontData* FontCache::getLastResortFallbackFont(const FontDescription& fontDescription) +{ + font_family family; + font_style style; + be_plain_font->GetFamilyAndStyle(&family, &style); + AtomicString plainFontFamily(family); + return getCachedFontData(fontDescription, plainFontFamily); +} + +FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family) +{ + return new FontPlatformData(fontDescription, family); +} + +void FontCache::getTraitsInFamily(const AtomicString& familyName, Vector<unsigned>& traitsMasks) +{ + notImplemented(); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/FontCustomPlatformData.cpp b/Source/WebCore/platform/graphics/haiku/FontCustomPlatformData.cpp new file mode 100644 index 0000000..ce7ec46 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/FontCustomPlatformData.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2008 Alp Toker <alp@atoker.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 "FontCustomPlatformData.h" + +#include "SharedBuffer.h" +#include "FontPlatformData.h" + + +namespace WebCore { + +FontCustomPlatformData::~FontCustomPlatformData() +{ +} + +FontPlatformData FontCustomPlatformData::fontPlatformData(int size, bool bold, bool italic, FontOrientation, FontRenderingMode) +{ + return FontPlatformData(size, bold, italic); +} + +FontCustomPlatformData* createFontCustomPlatformData(SharedBuffer* buffer) +{ + // FIXME: We need support in Haiku to read fonts from memory to implement this. + return 0; +} + +bool FontCustomPlatformData::supportsFormat(const String& /* format */) +{ + return false; +} + +} diff --git a/Source/WebCore/platform/graphics/haiku/FontCustomPlatformData.h b/Source/WebCore/platform/graphics/haiku/FontCustomPlatformData.h new file mode 100644 index 0000000..cc348e3 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/FontCustomPlatformData.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2008 Alp Toker <alp@atoker.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 FontCustomPlatformData_h +#define FontCustomPlatformData_h + +#include "FontOrientation.h" +#include "FontRenderingMode.h" +#include <wtf/Forward.h> +#include <wtf/Noncopyable.h> + +namespace WebCore { + + class FontPlatformData; + class SharedBuffer; + + struct FontCustomPlatformData : Noncopyable { + public: + FontCustomPlatformData() { } + ~FontCustomPlatformData(); + + static bool supportsFormat(const String&); + + FontPlatformData fontPlatformData(int size, bool bold, bool italic, FontOrientation = Horizontal, FontRenderingMode = NormalRenderingMode); + }; + + FontCustomPlatformData* createFontCustomPlatformData(SharedBuffer*); + +} + +#endif diff --git a/Source/WebCore/platform/graphics/haiku/FontHaiku.cpp b/Source/WebCore/platform/graphics/haiku/FontHaiku.cpp new file mode 100644 index 0000000..819fecb --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/FontHaiku.cpp @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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 COMPUTER, 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 COMPUTER, 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 "FontData.h" +#include "FontDescription.h" +#include "FontSelector.h" +#include "GraphicsContext.h" +#include "NotImplemented.h" +#include <Font.h> +#include <String.h> +#include <View.h> + + +// FIXME: Temp routine to convert unicode character to UTF8. +int charUnicodeToUTF8HACK(unsigned short glyph, char* out) +{ + int i = 0; + + if (glyph < 0x0080) + out[i++] = static_cast<char>(glyph); + else if (glyph < 0x0800) { // 2 bytes + out[i++] = 0xc0 | (glyph >> 6); + out[i++] = 0x80 | (glyph & 0x3F); + } else if (glyph > 0x0800) { // 3 bytes + out[i++] = 0xe0 | (glyph >> 12); + out[i++] = 0x80 | ((glyph >> 6) & 0x3F); + out[i++] = 0x80 | (glyph & 0x3F); + } + + out[i] = '\0'; + return i; +} + +namespace WebCore { + +bool Font::canReturnFallbackFontsForComplexText() +{ + return false; +} + +void Font::drawGlyphs(GraphicsContext* graphicsContext, const SimpleFontData* font, + const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point) const +{ + Color color = graphicsContext->fillColor(); + BView* view = graphicsContext->platformContext(); + BFont* m_font = font->platformData().font(); + + graphicsContext->setCompositeOperation(CompositeSourceOver); + view->SetHighColor(color); + view->SetFont(m_font); + + GlyphBufferGlyph* glyphs = const_cast<GlyphBufferGlyph*>(glyphBuffer.glyphs(from)); + float offset = point.x(); + for (int i = 0; i < numGlyphs; i++) { + char out[4]; + charUnicodeToUTF8HACK(glyphs[i], out); + + view->DrawString(out, sizeof(out), BPoint(offset, point.y())); + offset += glyphBuffer.advanceAt(from + i); + } +} + +void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const FloatPoint& point, + int from, int to) const +{ + notImplemented(); +} + +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 +{ + notImplemented(); + return 0; +} + +FloatRect Font::selectionRectForComplexText(const TextRun&, const FloatPoint&, int, int, int) const +{ + notImplemented(); + return FloatRect(); +} + +int Font::offsetForPositionForComplexText(const TextRun&, float, bool) const +{ + notImplemented(); + return 0; +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/FontPlatformData.h b/Source/WebCore/platform/graphics/haiku/FontPlatformData.h new file mode 100644 index 0000000..4e86e16 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/FontPlatformData.h @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2006 Apple Computer, Inc. + * Copyright (C) 2006 Zack Rusin <zack@kde.org> + * Copyright (C) 2006 Dirk Mueller <mueller@kde.org> + * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org> + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * Copyright (C) 2009 Maxime Simon <simon.maxime@gmail.com> + * + * 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., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + * + */ + +#ifndef FontPlatformData_h +#define FontPlatformData_h + +#include "FontDescription.h" +#include "GlyphBuffer.h" +#include <interface/Font.h> + +namespace WebCore { + + class FontPlatformData { + public: + FontPlatformData(WTF::HashTableDeletedValueType) + : m_font(hashTableDeletedFontValue()) + { } + + FontPlatformData() + : m_font(0) + { } + + FontPlatformData(const FontDescription&, const AtomicString& family); + FontPlatformData(float size, bool bold, bool oblique); + FontPlatformData(const FontPlatformData&); + + ~FontPlatformData(); + + BFont* font() const { return m_font; } + + bool isFixedPitch(); + float size() const { return m_size; } + bool bold() const { return m_bold; } + bool oblique() const { return m_oblique; } + + unsigned hash() const; + bool isHashTableDeletedValue() const; + + bool operator==(const FontPlatformData&) const; + +#ifndef NDEBUG + String description() const; +#endif + + BFont* m_font; + float m_size; + bool m_bold; + bool m_oblique; + + private: + static BFont* hashTableDeletedFontValue() { return reinterpret_cast<BFont*>(-1); } + }; + +} // namespace WebCore + +#endif + diff --git a/Source/WebCore/platform/graphics/haiku/GlyphPageTreeNodeHaiku.cpp b/Source/WebCore/platform/graphics/haiku/GlyphPageTreeNodeHaiku.cpp new file mode 100644 index 0000000..3ae9aeb --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/GlyphPageTreeNodeHaiku.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2006 George Staikos <staikos@kde.org> + * Copyright (C) 2006 Dirk Mueller <mueller@kde.org> + * Copyright (C) 2006 Zack Rusin <zack@kde.org> + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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 COMPUTER, 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 COMPUTER, 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 "GlyphPageTreeNode.h" + +#include "SimpleFontData.h" +#include <wtf/Assertions.h> +#include <wtf/unicode/Unicode.h> + + +namespace WebCore { + +bool GlyphPage::fill(unsigned offset, unsigned length, UChar* characterBuffer, unsigned bufferLength, const SimpleFontData* fontData) +{ + bool isUtf16 = bufferLength != GlyphPage::size; + bool haveGlyphs = false; + + for (unsigned i = 0; i < GlyphPage::size; i++) { + UChar32 character; + + if (isUtf16) { + UChar lead = characterBuffer[i * 2]; + UChar trail = characterBuffer[i * 2 + 1]; + character = U16_GET_SUPPLEMENTARY(lead, trail); + } else + character = characterBuffer[i]; + + if (!character) + setGlyphDataForIndex(offset + i, 0, 0); + else { + haveGlyphs = true; + setGlyphDataForIndex(offset + i, character, fontData); + } + } + + return haveGlyphs; +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/GradientHaiku.cpp b/Source/WebCore/platform/graphics/haiku/GradientHaiku.cpp new file mode 100644 index 0000000..fdc4690 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/GradientHaiku.cpp @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2008 Kevin Ollivier <kevino@theolliviers.com> All rights reserved. + * Copyright (C) 2009 Maxime Simon <simon.maxime@theolliviers.com> + * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de> + * + * 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 COMPUTER, 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 COMPUTER, 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 "Gradient.h" + +#include "GraphicsContext.h" +#include <GradientLinear.h> +#include <GradientRadial.h> +#include <View.h> + + +namespace WebCore { + +void Gradient::platformDestroy() +{ + delete m_gradient; +} + +PlatformGradient Gradient::platformGradient() +{ + if (m_gradient) + return m_gradient; + + if (m_radial) { + // TODO: Support m_r0? + m_gradient = new BGradientRadial(m_p0, m_r1); + } else + m_gradient = new BGradientLinear(m_p0, m_p1); + size_t size = m_stops.size(); + for (size_t i = 0; i < size; i++) { + const ColorStop& stop = m_stops[i]; + rgb_color color; + color.red = static_cast<uint8>(stop.red * 255); + color.green = static_cast<uint8>(stop.green * 255); + color.blue = static_cast<uint8>(stop.blue * 255); + color.alpha = static_cast<uint8>(stop.alpha * 255); + m_gradient->AddColor(color, stop.stop); + } + return m_gradient; +} + +void Gradient::fill(GraphicsContext* context, const FloatRect& rect) +{ + context->platformContext()->FillRect(rect, *platformGradient()); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/GraphicsContextHaiku.cpp b/Source/WebCore/platform/graphics/haiku/GraphicsContextHaiku.cpp new file mode 100644 index 0000000..acd431d --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/GraphicsContextHaiku.cpp @@ -0,0 +1,536 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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 COMPUTER, 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 COMPUTER, 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 "GraphicsContext.h" + +#include "AffineTransform.h" +#include "Color.h" +#include "Font.h" +#include "FontData.h" +#include "NotImplemented.h" +#include "Path.h" +#include "Pen.h" +#include <wtf/text/CString.h> +#include <GraphicsDefs.h> +#include <Region.h> +#include <View.h> +#include <Window.h> +#include <stdio.h> + + +namespace WebCore { + +class GraphicsContextPlatformPrivate { +public: + GraphicsContextPlatformPrivate(BView* view); + ~GraphicsContextPlatformPrivate(); + + BView* m_view; +}; + +GraphicsContextPlatformPrivate::GraphicsContextPlatformPrivate(BView* view) + : m_view(view) +{ +} + +GraphicsContextPlatformPrivate::~GraphicsContextPlatformPrivate() +{ +} + +void GraphicsContext::platformInit(PlatformGraphicsContext* context) +{ + m_data = new GraphicsContextPlatformPrivate(context); + setPaintingDisabled(!context); +} + +void GraphicsContext::platformDestroy() +{ + delete m_data; +} + +PlatformGraphicsContext* GraphicsContext::platformContext() const +{ + return m_data->m_view; +} + +void GraphicsContext::savePlatformState() +{ + m_data->m_view->PushState(); +} + +void GraphicsContext::restorePlatformState() +{ + m_data->m_view->PopState(); +} + +// Draws a filled rectangle with a stroked border. +void GraphicsContext::drawRect(const IntRect& rect) +{ + if (paintingDisabled()) + return; + + m_data->m_view->FillRect(rect); + if (strokeStyle() != NoStroke) + m_data->m_view->StrokeRect(rect, getHaikuStrokeStyle()); +} + +// This is only used to draw borders. +void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2) +{ + if (paintingDisabled()) + return; + + if (strokeStyle() == NoStroke) + return; + + m_data->m_view->StrokeLine(point1, point2, getHaikuStrokeStyle()); +} + +// This method is only used to draw the little circles used in lists. +void GraphicsContext::drawEllipse(const IntRect& rect) +{ + if (paintingDisabled()) + return; + + m_data->m_view->FillEllipse(rect); + if (strokeStyle() != NoStroke) + m_data->m_view->StrokeEllipse(rect, getHaikuStrokeStyle()); +} + +void GraphicsContext::strokeArc(const IntRect& rect, int startAngle, int angleSpan) +{ + if (paintingDisabled()) + return; + + m_data->m_view->StrokeArc(rect, startAngle, angleSpan, getHaikuStrokeStyle()); +} + +void GraphicsContext::strokePath(const Path&) +{ + notImplemented(); +} + +void GraphicsContext::drawConvexPolygon(size_t pointsLength, const FloatPoint* points, bool shouldAntialias) +{ + if (paintingDisabled()) + return; + + BPoint bPoints[pointsLength]; + for (size_t i = 0; i < pointsLength; i++) + bPoints[i] = points[i]; + + m_data->m_view->FillPolygon(bPoints, pointsLength); + if (strokeStyle() != NoStroke) + // Stroke with low color + m_data->m_view->StrokePolygon(bPoints, pointsLength, true, getHaikuStrokeStyle()); +} + +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()) + return; + + rgb_color oldColor = m_data->m_view->HighColor(); + m_data->m_view->SetHighColor(color); + m_data->m_view->FillRect(rect); + m_data->m_view->SetHighColor(oldColor); +} + +void GraphicsContext::fillRect(const FloatRect& rect) +{ + if (paintingDisabled()) + return; +} + +void GraphicsContext::fillRoundedRect(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color& color, ColorSpace colorSpace) +{ + if (paintingDisabled() || !color.alpha()) + return; + + notImplemented(); + // FIXME: A simple implementation could just use FillRoundRect if all + // the sizes are the same, or even if they are not. Otherwise several + // FillRect and FillArc calls are needed. +} + +void GraphicsContext::fillPath(const Path&) +{ + notImplemented(); +} + +void GraphicsContext::clip(const FloatRect& rect) +{ + if (paintingDisabled()) + return; + + BRegion region(rect); + m_data->m_view->ConstrainClippingRegion(®ion); +} + +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 (paintingDisabled()) + return; + + unsigned rectCount = rects.size(); + + // FIXME: maybe we should implement this with BShape? + + if (rects.size() > 1) { + BRegion region; + for (int i = 0; i < rectCount; ++i) + region.Include(BRect(rects[i])); + + m_data->m_view->SetHighColor(color); + m_data->m_view->StrokeRect(region.Frame(), B_MIXED_COLORS); + } +} + +void GraphicsContext::drawLineForText(const IntPoint& origin, int width, bool printing) +{ + if (paintingDisabled()) + return; + + IntPoint endPoint = origin + IntSize(width, 0); + drawLine(origin, endPoint); +} + +void GraphicsContext::drawLineForTextChecking(const IntPoint&, int width, TextCheckingLineStyle) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& rect) +{ + notImplemented(); + return rect; +} + +void GraphicsContext::beginTransparencyLayer(float opacity) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::endTransparencyLayer() +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::clearRect(const FloatRect& rect) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::strokeRect(const FloatRect& rect, float width) +{ + if (paintingDisabled()) + return; + + float oldSize = m_data->m_view->PenSize(); + m_data->m_view->SetPenSize(width); + m_data->m_view->StrokeRect(rect, getHaikuStrokeStyle()); + m_data->m_view->SetPenSize(oldSize); +} + +void GraphicsContext::setLineCap(LineCap lineCap) +{ + if (paintingDisabled()) + return; + + cap_mode mode = B_BUTT_CAP; + switch (lineCap) { + case RoundCap: + mode = B_ROUND_CAP; + break; + case SquareCap: + mode = B_SQUARE_CAP; + break; + case ButtCap: + default: + break; + } + + m_data->m_view->SetLineMode(mode, m_data->m_view->LineJoinMode(), m_data->m_view->LineMiterLimit()); +} + +void GraphicsContext::setLineJoin(LineJoin lineJoin) +{ + if (paintingDisabled()) + return; + + join_mode mode = B_MITER_JOIN; + switch (lineJoin) { + case RoundJoin: + mode = B_ROUND_JOIN; + break; + case BevelJoin: + mode = B_BEVEL_JOIN; + break; + case MiterJoin: + default: + break; + } + + m_data->m_view->SetLineMode(m_data->m_view->LineCapMode(), mode, m_data->m_view->LineMiterLimit()); +} + +void GraphicsContext::setMiterLimit(float limit) +{ + if (paintingDisabled()) + return; + + m_data->m_view->SetLineMode(m_data->m_view->LineCapMode(), m_data->m_view->LineJoinMode(), limit); +} + +void GraphicsContext::setAlpha(float opacity) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::setPlatformCompositeOperation(CompositeOperator op) +{ + if (paintingDisabled()) + return; + + drawing_mode mode = B_OP_COPY; + switch (op) { + case CompositeClear: + case CompositeCopy: + // Use the default above + break; + case CompositeSourceOver: + mode = B_OP_OVER; + break; + default: + printf("GraphicsContext::setPlatformCompositeOperation: Unsupported composite operation %s\n", + compositeOperatorName(op).utf8().data()); + } + m_data->m_view->SetDrawingMode(mode); +} + +void GraphicsContext::clip(const Path& path) +{ + if (paintingDisabled()) + return; + + m_data->m_view->ConstrainClippingRegion(path.platformPath()); +} + +void GraphicsContext::canvasClip(const Path& path) +{ + clip(path); +} + +void GraphicsContext::clipOut(const Path& path) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::clipToImageBuffer(const FloatRect&, const ImageBuffer*) +{ + notImplemented(); +} + +AffineTransform GraphicsContext::getCTM() const +{ + notImplemented(); + return AffineTransform(); +} + +void GraphicsContext::translate(float x, float y) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::rotate(float radians) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::scale(const FloatSize& size) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::clipOut(const IntRect& rect) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect, int thickness) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::concatCTM(const AffineTransform& transform) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::setPlatformShouldAntialias(bool enable) +{ + if (paintingDisabled()) + return; + + notImplemented(); +} + +void GraphicsContext::setImageInterpolationQuality(InterpolationQuality) +{ +} + +InterpolationQuality GraphicsContext::imageInterpolationQuality() const +{ + notImplemented(); + return InterpolationDefault; +} + +void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect) +{ + notImplemented(); +} + +void GraphicsContext::setPlatformFont(const Font& font) +{ + m_data->m_view->SetFont(font.primaryFont()->platformData().font()); +} + +void GraphicsContext::setPlatformStrokeColor(const Color& color, ColorSpace colorSpace) +{ + if (paintingDisabled()) + return; + + m_data->m_view->SetHighColor(color); +} + +pattern GraphicsContext::getHaikuStrokeStyle() +{ + switch (strokeStyle()) { + case SolidStroke: + return B_SOLID_HIGH; + break; + case DottedStroke: + return B_MIXED_COLORS; + break; + case DashedStroke: + // FIXME: use a better dashed stroke! + notImplemented(); + return B_MIXED_COLORS; + break; + default: + return B_SOLID_LOW; + break; + } +} + +void GraphicsContext::setPlatformStrokeStyle(StrokeStyle strokeStyle) +{ + // FIXME: see getHaikuStrokeStyle. + notImplemented(); +} + +void GraphicsContext::setPlatformStrokeThickness(float thickness) +{ + if (paintingDisabled()) + return; + + m_data->m_view->SetPenSize(thickness); +} + +void GraphicsContext::setPlatformFillColor(const Color& color, ColorSpace colorSpace) +{ + if (paintingDisabled()) + return; + + m_data->m_view->SetHighColor(color); +} + +void GraphicsContext::clearPlatformShadow() +{ + notImplemented(); +} + +void GraphicsContext::setPlatformShadow(FloatSize const&, float, Color const&, ColorSpace) +{ + notImplemented(); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/IconHaiku.cpp b/Source/WebCore/platform/graphics/haiku/IconHaiku.cpp new file mode 100644 index 0000000..3663ee2 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/IconHaiku.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + * + */ + +#include "config.h" +#include "Icon.h" + +#include "GraphicsContext.h" +#include "IntRect.h" +#include "NotImplemented.h" +#include "PlatformString.h" + + +namespace WebCore { + +Icon::~Icon() +{ + notImplemented(); +} + +PassRefPtr<Icon> Icon::createIconForFiles(const Vector<String>& filenames) +{ + notImplemented(); + return 0; +} + +void Icon::paint(GraphicsContext*, const IntRect&) +{ + notImplemented(); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/ImageBufferData.h b/Source/WebCore/platform/graphics/haiku/ImageBufferData.h new file mode 100644 index 0000000..7c676cd --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/ImageBufferData.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de> + * + * 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 COMPUTER, 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 COMPUTER, 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 ImageBufferData_h +#define ImageBufferData_h + +#include <Bitmap.h> +#include <View.h> + +namespace WebCore { + +class IntSize; + +class ImageBufferData { +public: + ImageBufferData(const IntSize&); + ~ImageBufferData(); + + BBitmap m_bitmap; + BView m_view; +}; + +} // namespace WebCore + +#endif // ImageBufferData_h + diff --git a/Source/WebCore/platform/graphics/haiku/ImageBufferHaiku.cpp b/Source/WebCore/platform/graphics/haiku/ImageBufferHaiku.cpp new file mode 100644 index 0000000..bdad6a0 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/ImageBufferHaiku.cpp @@ -0,0 +1,375 @@ +/* + * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de> + * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. 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 COMPUTER, 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 COMPUTER, 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 "ImageBuffer.h" + +#include "Base64.h" +#include "GraphicsContext.h" +#include "ImageData.h" +#include "MIMETypeRegistry.h" +#include "StillImageHaiku.h" +#include <wtf/text/CString.h> +#include <wtf/text/StringConcatenate.h> +#include <BitmapStream.h> +#include <String.h> +#include <TranslatorRoster.h> + +namespace WebCore { + +ImageBufferData::ImageBufferData(const IntSize& size) + : m_bitmap(BRect(0, 0, size.width() - 1, size.height() - 1), B_RGBA32, true) + , m_view(m_bitmap.Bounds(), "WebKit ImageBufferData", 0, 0) +{ + // Always keep the bitmap locked, we are the only client. + m_bitmap.Lock(); + m_bitmap.AddChild(&m_view); + + // Fill with completely transparent color. + memset(m_bitmap.Bits(), 0, m_bitmap.BitsLength()); + + // Since ImageBuffer is used mainly for Canvas, explicitly initialize + // its view's graphics state with the corresponding canvas defaults + // NOTE: keep in sync with CanvasRenderingContext2D::State + m_view.SetLineMode(B_BUTT_CAP, B_MITER_JOIN, 10); + m_view.SetDrawingMode(B_OP_ALPHA); + m_view.SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE); +} + +ImageBufferData::~ImageBufferData() +{ + // Remove the view from the bitmap, keeping it from being free'd twice. + m_view.RemoveSelf(); + m_bitmap.Unlock(); +} + +ImageBuffer::ImageBuffer(const IntSize& size, ImageColorSpace imageColorSpace, RenderingMode, bool& success) + : m_data(size) + , m_size(size) +{ + m_context.set(new GraphicsContext(&m_data.m_view)); + success = true; +} + +ImageBuffer::~ImageBuffer() +{ +} + +GraphicsContext* ImageBuffer::context() const +{ + ASSERT(m_data.m_view.Window()); + + return m_context.get(); +} + +Image* ImageBuffer::image() const +{ + if (!m_image) { + // It's assumed that if image() is called, the actual rendering to the + // GraphicsContext must be done. + ASSERT(context()); + m_data.m_view.Sync(); + m_image = StillImage::create(m_data.m_bitmap); + } + + return m_image.get(); +} + +void ImageBuffer::platformTransformColorSpace(const Vector<int>& lookUpTable) +{ + uint8* rowData = reinterpret_cast<uint8*>(m_data.m_bitmap.Bits()); + unsigned bytesPerRow = m_data.m_bitmap.BytesPerRow(); + unsigned rows = m_size.height(); + unsigned columns = m_size.width(); + for (unsigned y = 0; y < rows; y++) { + uint8* pixel = rowData; + for (unsigned x = 0; x < columns; x++) { + // lookUpTable doesn't seem to support a LUT for each color channel + // separately (judging from the other ports). We don't need to + // convert from/to pre-multiplied color space since BBitmap storage + // is not pre-multiplied. + pixel[0] = lookUpTable[pixel[0]]; + pixel[1] = lookUpTable[pixel[1]]; + pixel[2] = lookUpTable[pixel[2]]; + // alpha stays unmodified. + pixel += 4; + } + rowData += bytesPerRow; + } +} + +static inline void convertFromData(const uint8* sourceRows, unsigned sourceBytesPerRow, + uint8* destRows, unsigned destBytesPerRow, + unsigned rows, unsigned columns) +{ + for (unsigned y = 0; y < rows; y++) { + const uint8* sourcePixel = sourceRows; + uint8* destPixel = destRows; + for (unsigned x = 0; x < columns; x++) { + // RGBA -> BGRA or BGRA -> RGBA + destPixel[0] = sourcePixel[2]; + destPixel[1] = sourcePixel[1]; + destPixel[2] = sourcePixel[0]; + destPixel[3] = sourcePixel[3]; + destPixel += 4; + sourcePixel += 4; + } + sourceRows += sourceBytesPerRow; + destRows += destBytesPerRow; + } +} + +static inline void convertFromInternalData(const uint8* sourceRows, unsigned sourceBytesPerRow, + uint8* destRows, unsigned destBytesPerRow, + unsigned rows, unsigned columns, + bool premultiplied) +{ + if (premultiplied) { + // Internal storage is not pre-multiplied, pre-multiply on the fly. + for (unsigned y = 0; y < rows; y++) { + const uint8* sourcePixel = sourceRows; + uint8* destPixel = destRows; + for (unsigned x = 0; x < columns; x++) { + // RGBA -> BGRA or BGRA -> RGBA + destPixel[0] = static_cast<uint16>(sourcePixel[2]) * sourcePixel[3] / 255; + destPixel[1] = static_cast<uint16>(sourcePixel[1]) * sourcePixel[3] / 255; + destPixel[2] = static_cast<uint16>(sourcePixel[0]) * sourcePixel[3] / 255; + destPixel[3] = sourcePixel[3]; + destPixel += 4; + sourcePixel += 4; + } + sourceRows += sourceBytesPerRow; + destRows += destBytesPerRow; + } + } else { + convertFromData(sourceRows, sourceBytesPerRow, + destRows, destBytesPerRow, + rows, columns); + } +} + +static inline void convertToInternalData(const uint8* sourceRows, unsigned sourceBytesPerRow, + uint8* destRows, unsigned destBytesPerRow, + unsigned rows, unsigned columns, + bool premultiplied) +{ + if (premultiplied) { + // Internal storage is not pre-multiplied, de-multiply source data. + for (unsigned y = 0; y < rows; y++) { + const uint8* sourcePixel = sourceRows; + uint8* destPixel = destRows; + for (unsigned x = 0; x < columns; x++) { + // RGBA -> BGRA or BGRA -> RGBA + if (sourcePixel[3]) { + destPixel[0] = static_cast<uint16>(sourcePixel[2]) * 255 / sourcePixel[3]; + destPixel[1] = static_cast<uint16>(sourcePixel[1]) * 255 / sourcePixel[3]; + destPixel[2] = static_cast<uint16>(sourcePixel[0]) * 255 / sourcePixel[3]; + destPixel[3] = sourcePixel[3]; + } else { + destPixel[0] = 0; + destPixel[1] = 0; + destPixel[2] = 0; + destPixel[3] = 0; + } + destPixel += 4; + sourcePixel += 4; + } + sourceRows += sourceBytesPerRow; + destRows += destBytesPerRow; + } + } else { + convertFromData(sourceRows, sourceBytesPerRow, + destRows, destBytesPerRow, + rows, columns); + } +} + +static PassRefPtr<ImageData> getImageData(const IntRect& rect, const ImageBufferData& imageData, const IntSize& size, bool premultiplied) +{ + RefPtr<ImageData> result = ImageData::create(IntSize(rect.width(), rect.height())); + unsigned char* data = result->data()->data()->data(); + + // If the destination image is larger than the source image, the outside + // regions need to be transparent. This way is simply, although with a + // a slight overhead for the inside region. + if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > size.width() || (rect.y() + rect.height()) > size.height()) + memset(data, 0, result->data()->length()); + + // If the requested image is outside the source image, we can return at + // this point. + if (rect.x() > size.width() || rect.y() > size.height() || rect.right() < 0 || rect.bottom() < 0) + return result.release(); + + // Now we know there must be an intersection rect which we need to extract. + BRect sourceRect(0, 0, size.width() - 1, size.height() - 1); + sourceRect = BRect(rect) & sourceRect; + + unsigned destBytesPerRow = 4 * rect.width(); + unsigned char* destRows = data; + // Offset the destination pointer to point at the first pixel of the + // intersection rect. + destRows += (rect.x() - static_cast<int>(sourceRect.left)) * 4 + + (rect.y() - static_cast<int>(sourceRect.top)) * destBytesPerRow; + + const uint8* sourceRows = reinterpret_cast<const uint8*>(imageData.m_bitmap.Bits()); + uint32 sourceBytesPerRow = imageData.m_bitmap.BytesPerRow(); + // Offset the source pointer to point at the first pixel of the + // intersection rect. + sourceRows += static_cast<int>(sourceRect.left) * 4 + + static_cast<int>(sourceRect.top) * sourceBytesPerRow; + + unsigned rows = sourceRect.IntegerHeight() + 1; + unsigned columns = sourceRect.IntegerWidth() + 1; + convertFromInternalData(sourceRows, sourceBytesPerRow, destRows, destBytesPerRow, + rows, columns, premultiplied); + + return result.release(); +} + + +PassRefPtr<ImageData> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const +{ + // Make sure all asynchronous drawing has finished + m_data.m_view.Sync(); + return getImageData(rect, m_data, m_size, false); +} + +PassRefPtr<ImageData> ImageBuffer::getPremultipliedImageData(const IntRect& rect) const +{ + // Make sure all asynchronous drawing has finished + m_data.m_view.Sync(); + return getImageData(rect, m_data, m_size, true); +} + +static void putImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint, ImageBufferData& imageData, const IntSize& size, bool premultiplied) +{ + // If the source image is outside the destination image, we can return at + // this point. + // FIXME: Check if this isn't already done in WebCore. + if (destPoint.x() > size.width() || destPoint.y() > size.height() + || destPoint.x() + sourceRect.width() < 0 + || destPoint.y() + sourceRect.height() < 0) { + return; + } + + const unsigned char* sourceRows = source->data()->data()->data(); + unsigned sourceBytesPerRow = 4 * source->width(); + // Offset the source pointer to the first pixel of the source rect. + sourceRows += sourceRect.x() * 4 + sourceRect.y() * sourceBytesPerRow; + + // We know there must be an intersection rect. + BRect destRect(destPoint.x(), destPoint.y(), sourceRect.width() - 1, sourceRect.height() - 1); + destRect = destRect & BRect(0, 0, size.width() - 1, size.height() - 1); + + unsigned char* destRows = reinterpret_cast<unsigned char*>(imageData.m_bitmap.Bits()); + uint32 destBytesPerRow = imageData.m_bitmap.BytesPerRow(); + // Offset the source pointer to point at the first pixel of the + // intersection rect. + destRows += static_cast<int>(destRect.left) * 4 + + static_cast<int>(destRect.top) * destBytesPerRow; + + unsigned rows = sourceRect.height(); + unsigned columns = sourceRect.width(); + convertToInternalData(sourceRows, sourceBytesPerRow, destRows, destBytesPerRow, + rows, columns, premultiplied); +} + +void ImageBuffer::putUnmultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint) +{ + // Make sure all asynchronous drawing has finished + m_data.m_view.Sync(); + putImageData(source, sourceRect, destPoint, m_data, m_size, false); +} + +void ImageBuffer::putPremultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint) +{ + // Make sure all asynchronous drawing has finished + m_data.m_view.Sync(); + putImageData(source, sourceRect, destPoint, m_data, m_size, true); +} + +String ImageBuffer::toDataURL(const String& mimeType, const double*) const +{ + if (!MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType)) + return "data:,"; + + BString mimeTypeString(mimeType); + + uint32 translatorType = 0; + + BTranslatorRoster* roster = BTranslatorRoster::Default(); + translator_id* translators; + int32 translatorCount; + roster->GetAllTranslators(&translators, &translatorCount); + for (int32 i = 0; i < translatorCount; i++) { + // Skip translators that don't support archived BBitmaps as input data. + const translation_format* inputFormats; + int32 formatCount; + roster->GetInputFormats(translators[i], &inputFormats, &formatCount); + bool supportsBitmaps = false; + for (int32 j = 0; j < formatCount; j++) { + if (inputFormats[j].type == B_TRANSLATOR_BITMAP) { + supportsBitmaps = true; + break; + } + } + if (!supportsBitmaps) + continue; + + const translation_format* outputFormats; + roster->GetOutputFormats(translators[i], &outputFormats, &formatCount); + for (int32 j = 0; j < formatCount; j++) { + if (outputFormats[j].group == B_TRANSLATOR_BITMAP + && mimeTypeString == outputFormats[j].MIME) { + translatorType = outputFormats[j].type; + } + } + if (translatorType) + break; + } + + + BMallocIO translatedStream; + BBitmap* bitmap = const_cast<BBitmap*>(&m_data.m_bitmap); + // BBitmapStream doesn't take "const Bitmap*"... + BBitmapStream bitmapStream(bitmap); + if (roster->Translate(&bitmapStream, 0, 0, &translatedStream, translatorType, + B_TRANSLATOR_BITMAP, mimeType.utf8().data()) != B_OK) { + bitmapStream.DetachBitmap(&bitmap); + return "data:,"; + } + + bitmapStream.DetachBitmap(&bitmap); + + Vector<char> encodedBuffer; + base64Encode(reinterpret_cast<const char*>(translatedStream.Buffer()), + translatedStream.BufferLength(), encodedBuffer); + + return makeString("data:", mimeType, ";base64,", encodedBuffer); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/ImageHaiku.cpp b/Source/WebCore/platform/graphics/haiku/ImageHaiku.cpp new file mode 100644 index 0000000..5a55d7c --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/ImageHaiku.cpp @@ -0,0 +1,195 @@ +/* + * Copyright (C) 2006 Dirk Mueller <mueller@kde.org> + * Copyright (C) 2006 Zack Rusin <zack@kde.org> + * Copyright (C) 2006 Simon Hausmann <hausmann@kde.org> + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * Copyright (C) 2008 Andrea Anzani <andrea.anzani@gmail.com> + * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de> + * + * 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 COMPUTER, 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 COMPUTER, 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 "Image.h" + +#include "BitmapImage.h" +#include "FloatRect.h" +#include "GraphicsContext.h" +#include "ImageObserver.h" +#include "NotImplemented.h" +#include "PlatformString.h" +#include "SharedBuffer.h" +#include "TransformationMatrix.h" +#include <Application.h> +#include <Bitmap.h> +#include <View.h> + +// This function loads resources from WebKit +Vector<char> loadResourceIntoArray(const char*); + + +namespace WebCore { + +bool FrameData::clear(bool clearMetadata) +{ + if (clearMetadata) + m_haveMetadata = false; + + if (m_frame) { + delete m_frame; + m_frame = 0; + m_duration = 0.0f; + m_hasAlpha = true; + return true; + } + + return false; +} + +WTF::PassRefPtr<Image> Image::loadPlatformResource(const char* name) +{ + Vector<char> array = loadResourceIntoArray(name); + WTF::PassRefPtr<BitmapImage> image = BitmapImage::create(); + RefPtr<SharedBuffer> buffer = SharedBuffer::create(array.data(), array.size()); + image->setData(buffer, true); + + return image; +} + +void BitmapImage::initPlatformData() +{ +} + +void BitmapImage::invalidatePlatformData() +{ +} + +// Drawing Routines +void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst, const FloatRect& src, ColorSpace styleColorSpace, CompositeOperator op) +{ + if (!m_source.initialized()) + return; + + // Spin the animation to the correct frame before we try to draw it, so we + // don't draw an old frame and then immediately need to draw a newer one, + // causing flicker and wasting CPU. + startAnimation(); + + BBitmap* image = nativeImageForCurrentFrame(); + if (!image || !image->IsValid()) // If the image hasn't fully loaded. + return; + + if (mayFillWithSolidColor()) { + fillWithSolidColor(ctxt, dst, solidColor(), styleColorSpace, op); + return; + } + + ctxt->save(); + ctxt->setCompositeOperation(op); + + BRect srcRect(src); + BRect dstRect(dst); + + // Test using example site at + // http://www.meyerweb.com/eric/css/edge/complexspiral/demo.html + ctxt->platformContext()->SetDrawingMode(B_OP_ALPHA); + ctxt->platformContext()->DrawBitmapAsync(image, srcRect, dstRect); + ctxt->restore(); + + if (imageObserver()) + imageObserver()->didDraw(this); +} + +void Image::drawPattern(GraphicsContext* context, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace, CompositeOperator op, const FloatRect& dstRect) +{ + BBitmap* image = nativeImageForCurrentFrame(); + if (!image || !image->IsValid()) // If the image hasn't fully loaded. + return; + + // Figure out if the image has any alpha transparency, we can use faster drawing if not + bool hasAlpha = false; + + uint8* bits = reinterpret_cast<uint8*>(image->Bits()); + uint32 width = image->Bounds().IntegerWidth() + 1; + uint32 height = image->Bounds().IntegerHeight() + 1; + + uint32 bytesPerRow = image->BytesPerRow(); + for (uint32 y = 0; y < height && !hasAlpha; y++) { + uint8* p = bits; + for (uint32 x = 0; x < width && !hasAlpha; x++) { + hasAlpha = p[3] < 255; + p += 4; + } + bits += bytesPerRow; + } + + context->save(); + if (hasAlpha) + context->platformContext()->SetDrawingMode(B_OP_ALPHA); + else + context->platformContext()->SetDrawingMode(B_OP_COPY); + context->clip(enclosingIntRect(dstRect)); + float currentW = phase.x(); + BRect bTileRect(tileRect); + while (currentW < dstRect.x() + dstRect.width()) { + float currentH = phase.y(); + while (currentH < dstRect.y() + dstRect.height()) { + BRect bDstRect(currentW, currentH, currentW + width - 1, currentH + height - 1); + context->platformContext()->DrawBitmapAsync(image, bTileRect, bDstRect); + currentH += height; + } + currentW += width; + } + context->restore(); + + if (imageObserver()) + imageObserver()->didDraw(this); +} + +void BitmapImage::checkForSolidColor() +{ + m_isSolidColor = false; + m_checkedForSolidColor = true; + + if (frameCount() > 1) + return; + + BBitmap* image = getBBitmap(); + if (!image || !image->Bounds().IsValid() + || image->Bounds().IntegerWidth() > 0 || image->Bounds().IntegerHeight() > 0) { + return; + } + + m_isSolidColor = true; + uint8* bits = reinterpret_cast<uint8*>(image->Bits()); + m_solidColor = Color(bits[2], bits[1], bits[0], bits[3]); +} + +BBitmap* BitmapImage::getBBitmap() const +{ + return const_cast<BitmapImage*>(this)->frameAtIndex(0); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/IntPointHaiku.cpp b/Source/WebCore/platform/graphics/haiku/IntPointHaiku.cpp new file mode 100644 index 0000000..327e503 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/IntPointHaiku.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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 COMPUTER, 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 COMPUTER, 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 "IntPoint.h" + +#include <Point.h> + + +namespace WebCore { + +IntPoint::IntPoint(const BPoint& point) + : m_x(static_cast<int>(point.x)) + , m_y(static_cast<int>(point.y)) +{ +} + +IntPoint::operator BPoint() const +{ + return BPoint(m_x, m_y); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/IntRectHaiku.cpp b/Source/WebCore/platform/graphics/haiku/IntRectHaiku.cpp new file mode 100644 index 0000000..5ee7207 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/IntRectHaiku.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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 COMPUTER, 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 COMPUTER, 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 "IntRect.h" + +#include <Rect.h> + + +namespace WebCore { + +IntRect::IntRect(const BRect& rect) + : m_location(rect.LeftTop()) + , m_size(rect.IntegerWidth() + 1, rect.IntegerHeight() + 1) +{ +} + +IntRect::operator BRect() const +{ + return BRect(BPoint(x(), y()), BSize(width() - 1, height() - 1)); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/IntSizeHaiku.cpp b/Source/WebCore/platform/graphics/haiku/IntSizeHaiku.cpp new file mode 100644 index 0000000..08c3a9d --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/IntSizeHaiku.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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 COMPUTER, 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 COMPUTER, 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 "IntSize.h" + +#include <Size.h> + + +namespace WebCore { + +IntSize::IntSize(const BSize& size) + : m_width(size.IntegerWidth()) + , m_height(size.IntegerHeight()) +{ +} + +IntSize::operator BSize() const +{ + return BSize(width(), height()); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/PathHaiku.cpp b/Source/WebCore/platform/graphics/haiku/PathHaiku.cpp new file mode 100644 index 0000000..5377e10 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/PathHaiku.cpp @@ -0,0 +1,164 @@ +/* + * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> + * + * 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 COMPUTER, 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 COMPUTER, 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 "Path.h" + +#include "AffineTransform.h" +#include "FloatRect.h" +#include "NotImplemented.h" +#include "PlatformString.h" +#include <Region.h> + + +namespace WebCore { + +Path::Path() + : m_path(new BRegion()) +{ +} + +Path::~Path() +{ + delete m_path; +} + +Path::Path(const Path& other) + : m_path(new BRegion(*other.platformPath())) +{ +} + +Path& Path::operator=(const Path& other) +{ + if (&other != this) + m_path = other.platformPath(); + + return *this; +} + +bool Path::hasCurrentPoint() const +{ + return !isEmpty(); +} + +FloatPoint Path::currentPoint() const +{ + // FIXME: implement safe way to return current point of subpath. + notImplemented(); + float quietNaN = std::numeric_limits<float>::quiet_NaN(); + return FloatPoint(quietNaN, quietNaN); +} + +bool Path::contains(const FloatPoint& point, WindRule rule) const +{ + return m_path->Contains(point); +} + +void Path::translate(const FloatSize& size) +{ + notImplemented(); +} + +FloatRect Path::boundingRect() const +{ + return m_path->Frame(); +} + +void Path::moveTo(const FloatPoint& point) +{ + // FIXME: Use OffsetBy? + notImplemented(); +} + +void Path::addLineTo(const FloatPoint& p) +{ + notImplemented(); +} + +void Path::addQuadCurveTo(const FloatPoint& cp, const FloatPoint& p) +{ + notImplemented(); +} + +void Path::addBezierCurveTo(const FloatPoint& cp1, const FloatPoint& cp2, const FloatPoint& p) +{ + notImplemented(); +} + +void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius) +{ + notImplemented(); +} + +void Path::closeSubpath() +{ + notImplemented(); +} + +void Path::addArc(const FloatPoint& p, float r, float sar, float ear, bool anticlockwise) +{ + notImplemented(); +} + +void Path::addRect(const FloatRect& r) +{ + m_path->Include(r); +} + +void Path::addEllipse(const FloatRect& r) +{ + notImplemented(); +} + +void Path::clear() +{ + m_path->MakeEmpty(); +} + +bool Path::isEmpty() const +{ + return !m_path->Frame().IsValid(); +} + +void Path::apply(void* info, PathApplierFunction function) const +{ + notImplemented(); +} + +void Path::transform(const AffineTransform& transform) +{ + notImplemented(); +} + +FloatRect Path::strokeBoundingRect(StrokeStyleApplier* applier) +{ + notImplemented(); + return FloatRect(); +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/SimpleFontDataHaiku.cpp b/Source/WebCore/platform/graphics/haiku/SimpleFontDataHaiku.cpp new file mode 100644 index 0000000..b1e7082 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/SimpleFontDataHaiku.cpp @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2006 Apple Computer, Inc. All rights reserved. + * Copyright (C) 2009 Maxime Simon <simon.maxime@gmail.com> 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. + * 3. Neither the name of Apple Computer, 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 "FontCache.h" +#include "FontDescription.h" +#include "NotImplemented.h" +#include "TextEncoding.h" +#include <wtf/text/CString.h> + + +namespace WebCore { + +void SimpleFontData::platformInit() +{ + const BFont* font = m_platformData.font(); + if (!font) + return; + + font_height height; + font->GetHeight(&height); + m_ascent = static_cast<int>(height.ascent); + m_descent = static_cast<int>(height.descent); + m_lineSpacing = m_ascent + m_descent; + m_xHeight = height.ascent * 0.56f; // Hack taken from the win port. + m_lineGap = height.leading; +} + +void SimpleFontData::platformCharWidthInit() +{ + m_avgCharWidth = 0.f; + m_maxCharWidth = 0.f; + initCharWidths(); +} + +void SimpleFontData::platformDestroy() +{ +} + +SimpleFontData* SimpleFontData::scaledFontData(const FontDescription& fontDescription, float scaleFactor) const +{ + FontDescription desc = FontDescription(fontDescription); + desc.setSpecifiedSize(scaleFactor * fontDescription.computedSize()); + FontPlatformData fontPlatformData(desc, desc.family().family()); + return new SimpleFontData(fontPlatformData, isCustomFont(), false); +} + +SimpleFontData* SimpleFontData::smallCapsFontData(const FontDescription& fontDescription) const +{ + if (!m_derivedFontData) + m_derivedFontData = DerivedFontData::create(isCustomFont()); + if (!m_derivedFontData->smallCaps) + m_derivedFontData->smallCaps = scaledFontData(fontDescription, .7); + + return m_derivedFontData->smallCaps.get(); +} + +SimpleFontData* SimpleFontData::emphasisMarkFontData(const FontDescription& fontDescription) const +{ + if (!m_derivedFontData) + m_derivedFontData = DerivedFontData::create(isCustomFont()); + if (!m_derivedFontData->emphasisMark) + m_derivedFontData->emphasisMark = scaledFontData(fontDescription, .5); + + return m_derivedFontData->emphasisMark.get(); +} + +bool SimpleFontData::containsCharacters(const UChar* characters, int length) const +{ + // FIXME: We will need to implement this to load non-ASCII encoding sites + return true; +} + +void SimpleFontData::determinePitch() +{ + m_treatAsFixedPitch = m_platformData.font() && m_platformData.font()->IsFixed(); +} + +GlyphMetrics SimpleFontData::platformMetricsForGlyph(Glyph glyph, GlyphMetricsMode) const +{ + GlyphMetrics metrics; + if (!m_platformData.font()) + return metrics; + + CString encoded = UTF8Encoding().encode(static_cast<UChar*>(&glyph), 1, + URLEncodedEntitiesForUnencodables); + float escapements[1]; + m_platformData.font()->GetEscapements(encoded.data(), 1, escapements); + metrics.horizontalAdvance = escapements[0] * m_platformData.font()->Size(); + return metrics; +} + +} // namespace WebCore + diff --git a/Source/WebCore/platform/graphics/haiku/StillImageHaiku.cpp b/Source/WebCore/platform/graphics/haiku/StillImageHaiku.cpp new file mode 100644 index 0000000..7f9fb15 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/StillImageHaiku.cpp @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de> + * + * 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 COMPUTER, 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 COMPUTER, 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 "StillImageHaiku.h" + +#include "GraphicsContext.h" +#include "IntSize.h" +#include <View.h> + +namespace WebCore { + +StillImage::StillImage(const BBitmap& bitmap) + : m_bitmap(&bitmap) +{ +} + +void StillImage::destroyDecodedData(bool destroyAll) +{ + // This is used for "large" animations to free image data. + // It appears it would not apply to StillImage. +} + +unsigned StillImage::decodedSize() const +{ + // FIXME: It could be wise to return 0 here, since we don't want WebCore + // to think we eat up memory, since we are not freeing any in + // destroyDecodedData() either. + return m_bitmap.BitsLength(); +} + +IntSize StillImage::size() const +{ + return IntSize(m_bitmap.Bounds().IntegerWidth() + 1, m_bitmap.Bounds().IntegerHeight() + 1); +} + +NativeImagePtr StillImage::nativeImageForCurrentFrame() +{ + return &m_bitmap; +} + +void StillImage::draw(GraphicsContext* context, const FloatRect& destRect, + const FloatRect& sourceRect, ColorSpace, CompositeOperator op) +{ + if (!m_bitmap.IsValid()) + return; + + context->save(); + context->setCompositeOperation(op); + context->platformContext()->DrawBitmap(&m_bitmap, sourceRect, destRect); + context->restore(); +} + +} diff --git a/Source/WebCore/platform/graphics/haiku/StillImageHaiku.h b/Source/WebCore/platform/graphics/haiku/StillImageHaiku.h new file mode 100644 index 0000000..f4bcbe1 --- /dev/null +++ b/Source/WebCore/platform/graphics/haiku/StillImageHaiku.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de> + * + * 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 COMPUTER, 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 COMPUTER, 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 StillImageHaiku_h +#define StillImageHaiku_h + +#include "Image.h" +#include <Bitmap.h> + +namespace WebCore { + +class StillImage : public Image { +public: + static PassRefPtr<StillImage> create(const BBitmap& bitmap) + { + return adoptRef(new StillImage(bitmap)); + } + + virtual void destroyDecodedData(bool destroyAll = true); + virtual unsigned decodedSize() const; + + virtual IntSize size() const; + virtual NativeImagePtr nativeImageForCurrentFrame(); + virtual void draw(GraphicsContext*, const FloatRect& dstRect, const FloatRect& srcRect, ColorSpace styleColorSpace, CompositeOperator); + +private: + StillImage(const BBitmap&); + + BBitmap m_bitmap; +}; + +} // namespace WebCore + +#endif // StillImageHaiku_h |