C++博客-加文-文章分类-CEGUI

xml 命名空间

加文 — Tue, 24 Apr 2012 04:43:00 GMT

1. 有前缀和无前缀的命名空间

有前缀的命名空间：Xmlns：前缀=命名空间的名字；

无前缀的命名空间：xmlns=命名空间的名字

命名空间的前缀只是方便的引用命名空间而已，下面声明了三个不同的名称空间：

Xmlns:a=”Liaoning”

Xmlns:a=”liaoning”

Xmlns:b=”beijing”

上面的“liaoning”，“Liaoning”属于不同的命名空间。

2. 标记中声明命名空间：

<张山 xmlns:p1=”liaoning”>1990年出生，大学毕业张山>

3. 名称空间的作用域

a) 有前缀的命名空间

张山 xmlns:p1=”LiaoNing”>

1976年出生，大学毕业

张小山>

在小学读书

张小山>

张山>

上述的标签，张山和张小山同属于一个命名空间“LiaoNing”

b) 无前缀的命名空间

如果标记中声明的是无前缀的命名空间，那么该标记及其子标记都默认隶属于这个名称空间。线面的xml中，所有的标记都默认隶属于名字为：http://www.heimofang.com的名称空间

Java基础教程

Jsp基础教程

c) 尽管子标记可以通过引用父标记声明的有前缀的名称空间，但子标记也可以重新声明新的名称空间

张山 xmlns:p1=”Liaoning”>

1976年出生，大学毕业

张小山 xmlns:p1=”Americian”>

在小学读书

张小山>

张山>

上述xml中的“张山”，“张小山”分别属于“Liaoning”和“Americian”名称空间，“张小山”通过p1引用的名称空间是该标记中自己声明的名称空间。

d) 如果父标记声明的是无前缀的名称空间，子标记也可以重新声明名称空间

<张山 xmlns=”LiaoNing”>

1976年出生，大学毕业

<张小山 xmlns=”Beijing”>

在小学读书

张小山 xmlns:p1=”Americian”>张小山>

张小山>

张山>

上述xml中的“张山”属于名字空间“LiaoNing”，两个名字相同的标记：“张小山”分别隶属于“BeiJing”和“Americian”名称相同。

4. 名称空间的名字

名称空间的名字的目的是区分不同的标记，w3c推荐使用URL

加文 2012-04-24 12:43 发表评论

xml注释

加文 — Tue, 24 Apr 2012 03:02:00 GMT

Xml文件的注释和html相同，注释以“

加文 2012-04-24 11:02 发表评论

xml 属性

加文 — Tue, 24 Apr 2012 02:49:00 GMT

1. 属性的构成

属性是一个名值对，属性必须在费空标记的开始标记或者空标记中声明，语法如下：

<桌子 width =”300” height = “600” length =”1000”>吃饭用的桌子>

<椅子 color=”red”/>

属性名字的命名规则和标记的命名规则相同。属性值是一个用单引号或者双引号括起来的字符串。

2. 使用属性的原则

属性不体现数据的结构，只是数据的附加信息，一个信息是否作为一个标记的属性或者作为该编辑的子标记，取决于具体的问题。

加文 2012-04-24 10:49 发表评论

标记的文本数据

加文 — Tue, 24 Apr 2012 02:41:00 GMT

一个标记的内容有两部分构成：文本数据部分，子标记部分。一个标记的文本数据中可以有普通字符、CDATA段、字符引用、实体引用。

例子>

这是我写的一个例子！

&张小三&

]]>

这是子标记的文本内容！

加文 2012-04-24 10:41 发表评论

CDATA段

加文 — Tue, 24 Apr 2012 02:30:00 GMT

CDATA段得开始符为“”,结束符为“]]>”，以下为正确的CDATA段：

Boolean boo = true&&false;

<你好>

]]>

加文 2012-04-24 10:30 发表评论

xml特殊字符

加文 — Mon, 23 Apr 2012 14:40:00 GMT

Xml有5种字符属于特殊字符：“<”，“>”，“&”，“’”，“””；对于这些特殊字符，xml有特殊的用途，比如标记使用”<””>”表示。标记的内容有文本数据也标记，依照w3C的制定规范，文本数据中不可以包含特殊字符。

要想在文本数据中包含这些特殊字符，办法之一是通过实体引用。Xml有五种预定义实体，实体引用格式如下：

A. <引用左尖括号“<”

B. >引用右尖括号“>”

C. &apos,引用单引号“‘”

D. "引用双引号“””

E. &引用与符号“&”

解析器在解析标记的数据时，实体引用将被替换为引用的符号。对于有些特殊，比如希腊字符，我们无法从键盘输入，但是可以通过字符引用来解决，比如：&#开始引用的字符，使用代码点的十进制；&#x开始引用的字符，使用代码点的十六进制。

加文 2012-04-23 22:40 发表评论

xml标记

加文 — Mon, 23 Apr 2012 14:29:00 GMT

1. 空标记

<张西欧 age=”24” sex=”男” />

2. 非空标记

男 1980年10月

3. 非空标记的内容

<游戏>

华容道

初级

我喜欢

游戏>

上述xml文件中，标记“游戏”的文本数据为：华容道，我喜欢；标记的子标记是

标记<游戏>游戏>的子标记是grade，该标记的文本内容是初级。

请读者注意，以下3个标记所标记的文本的内容是不同：

<名称>

电视

名称>

<名称>电视

<名称/>

<名称>电视名称>

4. 标记的名称

规则是：字母，数字，下划线，点，连字符组成。例如：Kevin与Kevin

5. 根标记

Xml文件必须有个跟标记，所有标记必须封装在跟标记中，xml文件的标记必须形成树的结构。

加文 2012-04-23 22:29 发表评论

xml声明

加文 — Mon, 23 Apr 2012 14:11:00 GMT

1. Xml声明中的版本属性

2. xml声明中的编码属性

3. xml声明中的独立属性

加文 2012-04-23 22:11 发表评论

Event 介绍

加文 — Sun, 08 Apr 2012 16:36:00 GMT

/************************************************************************
    filename:   CEGUIEvent.h
    created:    Tue Feb 28 2006
    author:     Paul D Turner
*************************************************************************/
/***************************************************************************
*   Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
*
*   Permission is hereby granted, free of charge, to any person obtaining
*   a copy of this software and associated documentation files (the
*   "Software"), to deal in the Software without restriction, including
*   without limitation the rights to use, copy, modify, merge, publish,
*   distribute, sublicense, and/or sell copies of the Software, and to
*   permit persons to whom the Software is furnished to do so, subject to
*   the following conditions:
*
*   The above copyright notice and this permission notice shall be
*   included in all copies or substantial portions of the Software.
*
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
*   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
*   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
*   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
*   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
*   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
*   OTHER DEALINGS IN THE SOFTWARE.
***************************************************************************/
#ifndef _CEGUIEvent_h_
#define _CEGUIEvent_h_

#include "CEGUIString.h"
#include "CEGUIBoundSlot.h"
#include "CEGUISubscriberSlot.h"
#include "CEGUIRefCounted.h"

#include

#if defined(_MSC_VER)
#    pragma warning(push)
#    pragma warning(disable : 4251)
#endif

// Start of CEGUI namespace section
namespace CEGUI
{
/*!
\brief
    Defines an 'event' which can be subscribed to by interested parties.

    An Event can be subscribed by a function, a member function, or a function
    object.  Whichever option is taken, the function signature needs to be as
    follows:
    \par
    bool function_name(const EventArgs& args);
    \note
        An Event object may not be copied.
*/
class /*CEGUIEXPORT*/ Event
{
public:
    /*!
    \brief
        Connection object.  This is a thin 'smart pointer' wrapper around the
        actual BoundSlot that represents the connection.  You can use this
        object to inspect the current connection state and also to disconnect
        from the event.
    */
    typedef RefCounted Connection;

    /*!
    \brief
        Subscriber object type.  This is now just a typedef to SubscriberSlot,
        the use of the name Event::Subscriber is maintained for hostorical and
        compatability reasons.
    */
    typedef CEGUI::SubscriberSlot Subscriber;

    /*!
    \brief
        Type for a subscriber group.  You can use the subscriber group to
        order calls to multiple subscribers.  Groups are called in ascending
        order, with subscribers with no group called last.
    */
    typedef unsigned int Group;

    /*!
    \brief
        Event::Connection wrapper that automatically disconnects the connection
        when the object is deleted (or goes out of scope).
    */
    class ScopedConnection : public Connection
    {
    public:
        ScopedConnection() {}

        ~ScopedConnection()
            { disconnect(); }

        ScopedConnection(const Event::Connection& connection) :
            d_connection(connection)
        {}

        ScopedConnection& operator=(const Event::Connection& connection)
        {
            d_connection = connection;
            return *this;
        }

        bool connected() const
            { return d_connection.isValid() ? d_connection->connected() : false; }

        void disconnect()
            { if (d_connection.isValid()) d_connection->disconnect(); }

    private:
        Event::Connection d_connection;
    };

    /*!
    \brief
        Constructs a new Event object with the specified name
    */
    Event(const String& name);

    /*!
    \brief
        Destructor for Event objects.  Note that this is non-virtual and so you
        should not sub-class Event.
    */
    ~Event();

    /*!
    \brief
        Return the name given to this Event object when it was created.

    \return
        String object containing the name of the Event object.
    */
    const String& getName(void) const
        { return d_name; }

    /*!
    \brief
        Subscribes some function or object to the Event

    \param subscriber
        A function, static member function, or function object, with the
        signature void function_name(const EventArgs& args).  To subscribe a
        member function you should explicitly create an Event::Subscriber as
        this parameter.

    \return
        A Connection object which can be used to disconnect (unsubscribe) from
        the Event, and also to check the connection state.
    */
    Connection subscribe(const Subscriber& slot);

    /*!
    \brief
        Subscribes some function or object to the Event

    \param group
        The Event group to subscribe to, subscription groups are called in
        ascending order, followed by subscriptions with no group.
        Note that calling order of connections to the same group is unspecified.

    \param subscriber
        A function, static member function, or function object, with the
        signature void function_name(const EventArgs& args).  To subscribe a
        member function you should explicitly create an Event::Subscriber as
        this parameter.

    \return
        A Connection object which can be used to disconnect (unsubscribe) from
        the Event, and also to check the connection state.
    */
    Connection subscribe(Group group, const Subscriber& slot);

    /*!
    \brief
        Fires the event.  All event subscribers get called in the appropriate
        sequence.

    \param args
        An object derived from EventArgs to be passed to each event subscriber.
        The 'handled' field will be set to true if any of the called subscribers
        return that they handled the event.

    \return
        Nothing.
    */
    void operator()(EventArgs& args);

private:
    friend void CEGUI::BoundSlot::disconnect();
    /*!
    \brief
        Disconnects and removes the given BoundSlot from the collection of bound
        slots attached to this Event, thus 'unsubscribing' it.

    \note
        This is an implementation member, and is not available to client code.
        In order to detach / unsubscribe from an Event you should be using the
        Connection object(s) returned when you initially subscribed.
    */
    void unsubscribe(const BoundSlot& slot);

    // Copy constructor and assignment are not allowed for events
    Event(const Event&) {}
    Event& operator=(const Event&)  {return *this;}

    typedef std::multimap SlotContainer;
    SlotContainer d_slots;  //!< Collection holding ref-counted bound slots
    const String d_name;    //!< Name of this event
};

} // End of  CEGUI namespace section

#if defined(_MSC_VER)
#    pragma warning(pop)
#endif

#endif  // end of guard _CEGUIEvent_h_

subscribe函数是给这个事件注册一个处理函数，operator（）当这个时间被激发后会被调用，这个函数是便利所有的处理类，并且调用该类的处理函数。unsubscribe函数取消一个处理类和这个事件的关联，BoundSlot的disconnect函数会调用她
Event::Connection Event::subscribe(Event::Group group, const Event::Subscriber& slot)
{
    Event::Connection c(new BoundSlot(group, slot, *this));
    d_slots.insert(std::pair(group, c));
    return c;
}
void Event::operator()(EventArgs& args)
{
    SlotContainer::iterator iter(d_slots.begin());
    const SlotContainer::const_iterator end_iter(d_slots.end());

    // execute all subscribers, updating the 'handled' state as we go
    for (; iter != end_iter; ++iter)
        if ((*iter->second->d_subscriber)(args))
            ++args.handled;
}
void Event::unsubscribe(const BoundSlot& slot)
{
    // try to find the slot in our collection
    SlotContainer::iterator curr =
        std::find_if(d_slots.begin(),
                     d_slots.end(),
                     SubComp(slot));

    // erase our reference to the slot, if we had one.
    if (curr != d_slots.end())
        d_slots.erase(curr);
}

加文 2012-04-09 00:36 发表评论

RefCounted类的介绍

加文 — Sun, 08 Apr 2012 16:20:00 GMT

/************************************************************************
    filename:   CEGUIRefCounted.h
    created:    Wed Mar 1 2006
    author:     Paul D Turner
*************************************************************************/
/***************************************************************************
*   Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
*
*   Permission is hereby granted, free of charge, to any person obtaining
*   a copy of this software and associated documentation files (the
*   "Software"), to deal in the Software without restriction, including
*   without limitation the rights to use, copy, modify, merge, publish,
*   distribute, sublicense, and/or sell copies of the Software, and to
*   permit persons to whom the Software is furnished to do so, subject to
*   the following conditions:
*
*   The above copyright notice and this permission notice shall be
*   included in all copies or substantial portions of the Software.
*
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
*   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
*   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
*   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
*   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
*   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
*   OTHER DEALINGS IN THE SOFTWARE.
***************************************************************************/
#ifndef _CEGUIRefCounted_h_
#define _CEGUIRefCounted_h_

// Start of CEGUI namespace section
namespace CEGUI
{
/*!
\brief
    Simple, generic, reference counted pointer class.  This is primarily here
    for use by the Events system to track when to delete slot bindings.
*/
template
class RefCounted
{
public:
    /*!
    \brief
        Default constructor.
    */
    RefCounted() :
        d_object(0),
        d_count(0)
    {
    }

    /*!
    \brief
        Contruct a RefCounted object that wraps the pointer \a ob.
    */
    RefCounted(T* ob) :
        d_object(ob),
        d_count((ob != 0) ? new unsigned int(1) : 0)
    {
    }

    /*!
    \brief
        Copy constructor
    */
    RefCounted(const RefCounted& other) :
        d_object(other.d_object),
        d_count(other.d_count)
    {
        if (d_count)
            addRef();
    }

    /*!
    \brief
        Destructor.  Only deletes the associated object if no further references
        exist.
    */
    ~RefCounted()
    {
        if (d_object)
            release();
    }

    /*!
    \brief
        Assignment operator.  Previously held object gets its reference count
        reduced, and is deleted if no further references exist.  The newly
        assigned object, taken from \a other, gets its count increased.
    */
    RefCounted& operator=(const RefCounted& other)
    {
        if (*this != other)
        {
            if (d_object)
                release();

            d_object = other.d_object;
            d_count = d_object ? other.d_count : 0;

            if (d_count)
                addRef();
        }

        return *this;
    }

    /*!
    \brief
        Return whether the two RefCounted ptrs are equal
        (point to the same object)
    */
    bool operator==(const RefCounted& other) const
    {
        return d_object == other.d_object;
    }

    /*!
    \brief
        Return whether the two RefCounted ptrs are not equal
        (point to different objects)
    */
    bool operator!=(const RefCounted& other) const
    {
        return d_object != other.d_object;
    }

    /*!
    \brief
        Return the object referred to by the wrapped pointer.
        (beware of null pointers when using this!)
    */
    const T& operator*() const
    {
        return *d_object;
    }

    T& operator*()
    {
        return *d_object;
    }

    /*!
    \brief
        Return the wrapped pointer.
    */
    const T* operator->() const
    {
        return d_object;
    }
    T* operator->()
    {
        return d_object;
    }

    /*!
    \brief
        Return whether the wrapped pointer is valid.  i.e. that it is not null.
    */
    bool isValid() const
    {
        return d_object != 0;
    }
    void display()
    {
        cout<<*this->d_count<    }
private:
    /*!
    \brief
        Increases the reference count for the wrapped object.
    */
    void addRef()
    {
        ++*d_count;
    }

    /*!
    \brief
        Decreases the reference count for the wrapped object, and if the count
        has reached zero, the object and the shared counter are deleted.
    */
    void release()
    {
        if (!--*d_count)
        {
            delete d_object;
            delete d_count;
            d_object = 0;
            d_count = 0;
        }
    }

    T* d_object;            //! pointer to the object.
    unsigned int* d_count;  //! pointer to the shared counter object.
};

} // End of  CEGUI namespace section

#endif  // end of guard _CEGUIRefCounted_h_

这个类RefCounted是一个引用的封装模板类，原意可能是一个处理函数可以被多个事件引用，但在Event的实现代码里直接调用了BoundSlot的cleanup函数，而不是RefCounted的release函数来清理。可见，并没有实现一个事件处理函数被多个事件引用，其实也没有必要。

加文 2012-04-09 00:20 发表评论

字体

加文 — Tue, 03 Apr 2012 14:04:00 GMT

在cegui里文本都是图像，文字的显示，就是由这些图像拼成的。文本的显示也是字体控制的，字体还计算文本的渲染长度，宽度等。同一种字体渲染同样的文本渲染尺寸是一致的。字体还需要支持通过鼠标位置获取文本的位置。这个特性被用在鼠标点击后设置光标的位置。这里说的字体，指的是cegui的字体类，而不是真正的字体文件。cegui里面有两种字体，一种是点阵字体，大小固定不变；另外一种是Truetype类型的字体，对应windows系统的提供的TTF字体文件，这种字体是矢量字体。

加文 2012-04-03 22:04 发表评论