parcss1.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_SW_SOURCE_FILTER_HTML_PARCSS1_HXX
#define INCLUDED_SW_SOURCE_FILTER_HTML_PARCSS1_HXX
 
#include <rtl/ustring.hxx>
#include <tools/color.hxx>
 
#include <memory>
#include <utility>
 
// tokens of the CSS1 parser
enum CSS1Token
{
    CSS1_NULL,
 
    CSS1_IDENT,
    CSS1_STRING,
    CSS1_NUMBER,
    CSS1_PERCENTAGE,
    CSS1_LENGTH,    // absolute length in 1/100 MM
    CSS1_PIXLENGTH, // length in pixels
    CSS1_EMS,
    CSS1_EMX,
    CSS1_HEXCOLOR,
 
    CSS1_DOT_W_WS,
    CSS1_DOT_WO_WS,
    CSS1_COLON,
    CSS1_SLASH,
    CSS1_PLUS,
    CSS1_MINUS,
    CSS1_OBRACE,
    CSS1_CBRACE,
    CSS1_SEMICOLON,
    CSS1_COMMA,
    CSS1_HASH,
 
    CSS1_IMPORT_SYM,
    CSS1_PAGE_SYM, // Feature: PrintExt
 
    CSS1_IMPORTANT_SYM,
 
    CSS1_URL,
    CSS1_RGB
};
 
enum CSS1ParserState
{
    CSS1_PAR_ACCEPTED = 0,
    CSS1_PAR_WORKING
};
 
enum CSS1SelectorType
{
    CSS1_SELTYPE_ELEMENT,
    CSS1_SELTYPE_ELEM_CLASS,
    CSS1_SELTYPE_CLASS,
    CSS1_SELTYPE_ID,
    CSS1_SELTYPE_PSEUDO,
    CSS1_SELTYPE_PAGE // Feature: PrintExt
};
 
class CSS1Selector
{
    CSS1SelectorType m_eType; // the type
    OUString m_aSelector;     // the selector itself
    CSS1Selector *m_pNext;    // the following component
 
public:
    CSS1Selector( CSS1SelectorType eTyp, OUString aSel )
        : m_eType(eTyp), m_aSelector(std::move( aSel )), m_pNext( nullptr )
    {}
 
    ~CSS1Selector();
 
    CSS1SelectorType GetType() const { return m_eType; }
    const OUString& GetString() const { return m_aSelector; }
 
    void SetNext( CSS1Selector *pNxt ) { m_pNext = pNxt; }
    const CSS1Selector *GetNext() const { return m_pNext; }
};
 
struct CSS1Expression
{
private:
    sal_Unicode cOp; // type of the link with its predecessor
    CSS1Token eType; // type of the expression
    OUString aValue; // value as string
    double nValue;   // value as number (TWIPs for LENGTH)
    CSS1Expression *pNext; // the following component
 
public:
    CSS1Expression( CSS1Token eTyp, OUString aVal,
                    double nVal, sal_Unicode cO = 0 )
        : cOp(cO), eType(eTyp), aValue(std::move(aVal)), nValue(nVal), pNext(nullptr)
    {}
 
    ~CSS1Expression();
 
    inline void Set( CSS1Token eTyp, const OUString &rVal, double nVal );
 
    CSS1Token GetType() const { return eType; }
    const OUString& GetString() const { return aValue; }
    double GetNumber() const { return nValue; }
    inline sal_uInt32 GetULength() const;
    inline sal_Int32 GetSLength() const;
    sal_Unicode GetOp() const { return cOp; }
 
    void GetURL( OUString& rURL ) const;
    bool GetColor( Color &rRGB ) const;
 
    void SetNext( CSS1Expression *pNxt ) { pNext = pNxt; }
    const CSS1Expression *GetNext() const { return pNext; }
};
 
inline void CSS1Expression::Set( CSS1Token eTyp, const OUString &rVal,
                                 double nVal )
{
    cOp = 0; eType = eTyp; aValue = rVal; nValue = nVal; pNext = nullptr;
}
 
inline sal_uInt32 CSS1Expression::GetULength() const
{
    return nValue < 0. ? 0UL : static_cast<sal_uInt32>(nValue + .5);
}
 
inline sal_Int32 CSS1Expression::GetSLength() const
{
    return static_cast<sal_Int32>(nValue + (nValue < 0. ? -.5 : .5 ));
}
 
class CSS1Parser
{
    bool m_bWhiteSpace : 1; // read a whitespace?
    bool m_bEOF : 1; // is end of "file"?
 
    sal_Unicode m_cNextCh; // next character
 
    sal_Int32 m_nInPos; // current position in the input string
 
    sal_uInt32 m_nlLineNr; // current row number
    sal_uInt32 m_nlLinePos; // current column number
 
    double m_nValue; // value of the token as number
 
    CSS1ParserState m_eState; // current state of the parser
    CSS1Token m_nToken; // the current token
 
    OUString m_aIn; // the string to parse
    OUString m_aToken; // token as string
 
    void InitRead( const OUString& rIn );
 
    sal_Unicode GetNextChar();
 
    CSS1Token GetNextToken();
 
    bool IsParserWorking() const { return CSS1_PAR_WORKING == m_eState; }
 
    bool IsEOF() const { return m_bEOF; }
 
    // parse parts of the grammar
    void ParseRule();
    std::unique_ptr<CSS1Selector> ParseSelector();
    std::unique_ptr<CSS1Expression> ParseDeclaration( OUString& rProperty );
 
protected:
    void ParseStyleSheet();
 
    void ParseStyleSheet( const OUString& rIn );
 
    void ParseStyleOption( const OUString& rIn );
 
    virtual void SelectorParsed( std::unique_ptr<CSS1Selector> pSelector, bool bFirst );
 
    virtual void DeclarationParsed( const OUString& rProperty,
                                    std::unique_ptr<CSS1Expression> pExpr );
 
public:
    CSS1Parser();
    virtual ~CSS1Parser();
};
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */