Wt::Application Class Reference

Toplevel application class. More...

#include <application.h>

Inheritance diagram for Wt::Application:

[legend]Collaboration diagram for Wt::Application:

[legend]List of all members.

Public Types
typedef std::list< Object * >	List
Public Member Functions
	Application (int argc=0, char **argv=0)
	Constructor.
virtual	~Application ()
	Default destructor.
void	processEvents (Condition *cond)
	process all events until the condition is met
void	processEvent ()
	process on event event if we have to wait for it
void	processEvents (int ms=3000)
	process all the events in the queue for a maximum period of time
void	processEvents (const bool &var)
	process all events while the var is true
int	exec ()
	process all events so far until the end of the application
void	quit ()
	Halt execution and close window.
virtual bool	event (Event *e)
	event handling
virtual bool	notify (Object *receiver, Event *event)
std::list< std::string > &	argv ()
Object *	parent () const
const List &	children () const
List &	children ()
bool	isDescendant (const Object *p) const
virtual void	insertChild (Object *obj)
virtual void	removeChild (Object *obj)
void	reparent (Object *new_parent)
template<typename T>
void	deleteFirstChild ()
template<typename T>
void	deleteLastChild ()
template<typename T>
void	deleteAllChildren ()
Object *	topParent () const
	returns top level parent: it may return itself
const std::string &	name () const
void	installEventFilter (const Object *filterObj)
void	removeEventFilter (const Object *obj)
virtual bool	eventFilter (Object *, Event *)
int	startTimer (int interval)
void	killTimer (int id)
void	killTimers ()
Static Public Member Functions
static void	sendPostedEvents ()
	process the already posted events -- empties the queue
static void	exit (int exitcode=0)
	Halt execution and close window with a return code.
static bool	sendEvent (Object *receiver, Event &event)
static void	postEvent (Object *receiver, Event *event)
static Widget *	mainWidget ()
static DERIVED *	instance ()
template<class GRANDCHILD>
static DERIVED *	instance ()
	instantiates the pointer compatible child of DERIVED aka grandchild
static DERIVED *	existingInstance ()
Public Attributes
sigc::signal< void >	aboutToQuit
Signal01< void, const Object * >	destroyed
	signals
Protected Member Functions
void	parseArgs (int argc, char **argv)
virtual void	childEvent (ChildEvent *)
	event handling specialization
virtual void	customEvent (CustomEvent *)
virtual void	timerEvent (TimerEvent *)
bool	filterEvent (Event *)
Static Protected Member Functions
static DERIVED *	load ()
	try to load the instance
Static Protected Attributes
static DERIVED *	instance_ = 0
Private Types
typedef std::list< EventQueueItem >	EventQueueList
typedef std::stack< Condition * >	ConditionStack
Private Member Functions
void	init ()
Private Attributes
EventQueueList	queue
ConditionStack	condition_stack
std::list< std::string >	argv_
int	exitcode_
bool	running_
int	width_
int	height_
int	depth_
Friends
class	Singleton< Application >
Classes
class	Condition
class	EventQueueItem
class	Exception

---

Detailed Description

Toplevel application class.

Extend this class to create your application.

Definition at line 41 of file application.h.

---

Member Typedef Documentation

typedef std::stack<Condition *> Wt::Application::ConditionStack [private]

Definition at line 112 of file application.h.

typedef std::list<EventQueueItem> Wt::Application::EventQueueList [private]

Definition at line 110 of file application.h.

typedef std::list<Object*> Wt::Object::List [inherited]

Definition at line 47 of file object.h.

---

Constructor & Destructor Documentation

Wt::Application::Application	(	int	argc = 0,
		char **	argv = 0
	)

Constructor.

Definition at line 51 of file application.cpp.

References depth_, Error, height_, Wt::Font::init(), Wt::SDLTimer::init(), Wt::Singleton< DERIVED >::init(), parseArgs(), trace, and width_.

        : Object(0, "Application::anon"),
        Singleton<Application>(this),
        exitcode_(0),
        running_(true),
        width_(Display::defaultWidth),
        height_(Display::defaultHeight),
depth_(Display::defaultDepth) {
    parseArgs(argc, argv);
    Uint32 sdl_flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE | SDL_INIT_TIMER;

#if !defined( __WIN32__ ) && !defined( __CYGWIN32__ )

    sdl_flags |= SDL_INIT_EVENTTHREAD;
#endif

    /* Initialize SDL step by step*/
    trace("app") << "trying to initialize SDLvideo ... " << std::endl;
    if ( SDL_Init(sdl_flags) < 0 ) {
        Error("Cannot initialize SDL\n");
        throw Exception();
    }

    //init SDLEventHandler
    SDLEvent::init();
    //init SDLInput
    SDLInput::init();
    //init SDLTimers
    SDLTimer::init();
    // initialize audio handling
    Audio::init();
    // initialize font handling
    Font::init();
    // initialize rootwindow
    new RootWindow(width_, height_, depth_);

    //parseArgs(argc, argv, other_flags);

    trace("app", "Enabling SDL Unicode support\n");
    SDL_EnableUNICODE(1);

    SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
}

Here is the call graph for this function:

Wt::Application::~Application

(

)

[virtual]

Default destructor.

Definition at line 169 of file application.cpp.

References aboutToQuit, Wt::RootWindow::instance(), Wt::SDLTimer::quit(), Wt::Singleton< DERIVED >::quit(), Wt::Font::quit(), and trace.

                          {
    trace("app") << "In application destructor" << std::endl;

    aboutToQuit.emit();

    trace("app") << "Doing video shutdown" << std::endl;

    delete RootWindow::instance();

    trace("app") << "Quitting SDL" << std::endl;

    Font::quit();
    Audio::quit();
    SDLTimer::quit();
    SDLInput::quit();
    SDLEvent::quit();
    // shut down video (to kill the window) before shutting down
    // audio, since audio shutdown takes _so_ long
    SDL_QuitSubSystem(SDL_INIT_VIDEO);
    SDL_Quit();
}

Here is the call graph for this function:

---

Member Function Documentation

std::list< std::string > & Wt::Application::argv

(

)

Definition at line 95 of file application.cpp.

References argv_.

                                      {
    return argv_;
}

virtual void Wt::Object::childEvent

(

ChildEvent *

)

[inline, protected, virtual, inherited]

event handling specialization

Reimplemented in Wt::Window::Frame.

Definition at line 146 of file object.h.

Referenced by Wt::Object::event().

{}

List& Wt::Object::children

(

)

[inline, inherited]

Definition at line 61 of file object.h.

References Wt::Object::children_.

                     {
        return children_;
    }

const List& Wt::Object::children

(

)

const [inline, inherited]

Definition at line 57 of file object.h.

References Wt::Object::children_.

Referenced by Wt::RootWindow::blit_region_ex(), Wt::Widget::childAt(), Wt::Object::deleteAllChildren(), Wt::Object::deleteFirstChild(), Wt::Object::deleteLastChild(), Wt::Widget::focusNextPrevChild(), Wt::Widget::fontChange(), Wt::Widget::lower(), Wt::postLayoutHintEventRecursively(), and Wt::Widget::raise().

                                 {
        return children_;
    }

virtual void Wt::Object::customEvent

(

CustomEvent *

)

[inline, protected, virtual, inherited]

Definition at line 147 of file object.h.

Referenced by Wt::Object::event().

{}

template<typename T>

void Wt::Object::deleteAllChildren

(

)

[inline, inherited]

Definition at line 106 of file object.h.

References Wt::Object::children().

                             {
        List::iterator it(children().begin());
        List::iterator end(children().end());

        while (it != end) {
            T *t = dynamic_cast<T *>(*it);
            // before iteration invalidation
            ++it;
            // this will invalidate the iterator
            if (t) {
                delete t;
            }
        }
    }

Here is the call graph for this function:

template<typename T>

void Wt::Object::deleteFirstChild

(

)

[inline, inherited]

Definition at line 72 of file object.h.

References Wt::Object::children().

                            {
        List::iterator it(children().begin());
        List::iterator end(children().end());

        while (it != end) {
            T *t = dynamic_cast<T *>(*it);
            // before iteration invalidation
            ++it;
            // this will invalidate the iterator
            if (t) {
                delete t;
                break;
            }
        }
    }

Here is the call graph for this function:

template<typename T>

void Wt::Object::deleteLastChild

(

)

[inline, inherited]

Definition at line 89 of file object.h.

References Wt::Object::children().

                           {
        List::reverse_iterator it(children().rbegin());
        List::reverse_iterator end(children().rend());

        while (it != end) {
            T *t = dynamic_cast<T *>(*it);
            // before iteration invalidation
            ++it;
            // this will invalidate the iterator
            if (t) {
                delete t;
                break;
            }
        }
    }

Here is the call graph for this function:

bool Wt::Application::event

(

Event *

e

)

[virtual]

event handling

Reimplemented from Wt::Object.

Definition at line 303 of file application.cpp.

References Wt::Object::filterEvent().

Referenced by notify(), postEvent(), and sendEvent().

                                {
    return filterEvent(e);
}

Here is the call graph for this function:

virtual bool Wt::Object::eventFilter	(	Object *	,
		Event *
	)			[inline, virtual, inherited]

Reimplemented in Wt::Layout.

Definition at line 130 of file object.h.

Referenced by Wt::Layout::eventFilter().

                                                {
        return false;
    }

int Wt::Application::exec

(

)

process all events so far until the end of the application

Definition at line 284 of file application.cpp.

References exitcode_, processEvents(), running_, and sendPostedEvents().

                      {
    processEvents(running_);
    sendPostedEvents();
    return exitcode_;
}

Here is the call graph for this function:

template<class DERIVED>

static DERIVED* Wt::Singleton< DERIVED >::existingInstance

(

)

[inline, static, inherited]

Definition at line 36 of file singleton.h.

Referenced by exit(), postEvent(), sendEvent(), and sendPostedEvents().

                                       {
        return instance_;
    }

void Wt::Application::exit

(

int

exitcode = 0

)

[static]

Halt execution and close window with a return code.

Definition at line 290 of file application.cpp.

References Wt::Singleton< DERIVED >::existingInstance(), exitcode_, running_, and trace.

Referenced by Wt::SDLInput::handleQuitEvent(), and quit().

                                   {
    Application *app = existingInstance();
    if (!app)
        return;
    trace("app") << "Application: was requested to exit." << std::endl;
    app->running_ = false;
    app->exitcode_ = exitcode;
}

Here is the call graph for this function:

bool Wt::Object::filterEvent

(

Event *

)

[protected, inherited]

Definition at line 164 of file object.cpp.

References Wt::Object::eventFilters_.

Referenced by Wt::Object::event(), and event().

                                 {
    for (List::iterator filter(eventFilters_.begin()),
            end(eventFilters_.end()); filter != end; ++filter) {
        if ((*filter)->eventFilter(this, e))
            return true;
    }
    return false;
}

void Wt::Application::init

(

)

[private]

Note:

cannot fail

Reimplemented from Wt::Singleton< DERIVED >.

void Wt::Object::insertChild

(

Object *

obj

)

[virtual, inherited]

Definition at line 81 of file object.cpp.

References Wt::Event::ChildInserted, Wt::Object::children_, Wt::Object::parent_, and postEvent().

Referenced by Wt::Object::Object(), and Wt::Object::reparent().

                                    {
    children_.push_back(obj);
    obj->parent_ = this;
    Event *child_event = new ChildEvent(Event::ChildInserted, obj);
    Application::postEvent(this, child_event);
}

Here is the call graph for this function:

void Wt::Object::installEventFilter

(

const Object *

filterObj

)

[inherited]

Definition at line 124 of file object.cpp.

References Wt::Object::destroyed, Wt::Object::eventFilters_, and Wt::Object::removeEventFilter().

Referenced by Wt::Widget::setLayout().

                                                       {
    // we have to deconstify here. We cannot deliver event to const objects
    Object *obj = const_cast<Object *>(filterObj);
    eventFilters_.push_back(obj);
    obj->destroyed.connect(sigc::slot1<void, const Object *>(
                               sigc::mem_fun(*this, &Object::removeEventFilter)));
}

Here is the call graph for this function:

template<class DERIVED>

template<class GRANDCHILD>

static DERIVED* Wt::Singleton< DERIVED >::instance

(

)

[inline, static, inherited]

instantiates the pointer compatible child of DERIVED aka grandchild

it is handy in driver like situations

Definition at line 43 of file singleton.h.

                               {
        return (instance_) ? instance_ : GRANDCHILD::load();
    }

template<class DERIVED>

static DERIVED* Wt::Singleton< DERIVED >::instance

(

)

[inline, static, inherited]

Definition at line 32 of file singleton.h.

Referenced by Wt::Audio::Audio(), Wt::Sound::available(), Wt::SDLMixer::Chunk::channel(), Wt::NullAudio::Chunk::channel(), Wt::SDLSurface::defaultDepth(), Wt::SDLInput::EventInfo::EventInfo(), Wt::Dialog::exec(), Wt::Widget::grabKeyboard(), Wt::Widget::grabMouse(), Wt::Audio::handleAudioEvent(), Wt::SDLInput::handleKeyEvent(), Wt::Singleton< Wt::Audio >::init(), Wt::SDLTimer::init(), Wt::Sound::isAvailable(), Wt::Widget::keyboardGrabber(), Wt::Audio::load(), Wt::Widget::mouseGrabber(), Wt::SDLMixer::onChannelFinish(), Wt::Audio::onChannelFinish(), Wt::Sound::play(), Wt::Singleton< Wt::Audio >::quit(), Wt::Widget::releaseKeyboard(), Wt::Widget::releaseMouse(), Wt::SDLInput::SDLInput(), Wt::SDLMixer::setMusicVolume(), Wt::SDLMixer::Channel::setVolume(), and Wt::SDLMixer::Chunk::setVolume().

                               {
        return (instance_) ? instance_ : DERIVED::load();
    }

bool Wt::Object::isDescendant

(

const Object *

p

)

const [inherited]

Definition at line 67 of file object.cpp.

References Wt::Object::parent().

Referenced by Wt::SDLInput::EventInfo::EventInfo(), and Wt::SDLInput::handleKeyEvent().

                                               {
    if (!p)
        return false;

    const Object *q = this;

    do {
        if (p == q)
            return true;
    } while ((q = q->parent()));

    return false;
}

Here is the call graph for this function:

void Wt::Object::killTimer

(

int

id

)

[inherited]

Definition at line 145 of file object.cpp.

References Wt::Object::timers_.

Referenced by Wt::Timer::stop().

                             {
    delete timers_[id];
    timers_.erase(id);
}

void Wt::Object::killTimers

(

)

[inherited]

Definition at line 150 of file object.cpp.

References Wt::Object::timers_.

Referenced by Wt::Object::~Object().

                        {
    uint n = timers_.size() + 1;
    for (uint i = 1; i < n; i++) {
        delete timers_[i];
    }
    timers_.clear();
}

template<class DERIVED>

static DERIVED* Wt::Singleton< DERIVED >::load

(

)

[inline, static, protected, inherited]

try to load the instance

if it fails return NULL if it succeeds must return the newly created object

Reimplemented in Wt::Audio, Wt::NullAudio, and Wt::SDLMixer.

Definition at line 86 of file singleton.h.

                           {
        instance_ = new DERIVED;
        return  instance_;
    }

Widget * Wt::Application::mainWidget

(

)

[static]

Definition at line 191 of file application.cpp.

References Wt::RootWindow::instance().

                                {
    return static_cast<Widget *>(RootWindow::instance());
}

Here is the call graph for this function:

const std::string& Wt::Object::name

(

)

const [inline, inherited]

Definition at line 124 of file object.h.

References Wt::Object::name_.

Referenced by Wt::operator<<(), parseArgs(), and Wt::PushButton::setButtonSize().

                                  {
        return name_;
    }

bool Wt::Application::notify	(	Object *	receiver,
		Event *	event
	)			[virtual]

Definition at line 307 of file application.cpp.

References Wt::Widget::enabled, Wt::Object::event(), event(), Wt::Event::KeyPress, Wt::Event::KeyRelease, Wt::Event::MouseButtonDblClick, Wt::Event::MouseButtonPress, Wt::Event::MouseButtonRelease, Wt::Event::MouseMove, and Wt::Event::Wheel.

Referenced by sendEvent().

                                                       {
    if (this->event(event))
        return true;
    const int type = event->type();
    Widget *w = dynamic_cast<Widget *>(receiver);
    if (w) {
        const bool input_event = (type == Event::MouseButtonPress) ||
                                 (type == Event::MouseButtonRelease) ||
                                 (type == Event::MouseButtonDblClick) ||
                                 (type == Event::MouseMove) ||
                                 (type == Event::KeyPress) ||
                                 (type == Event::KeyRelease) ||
                                 (type == Event::Wheel);

        if (input_event && !w->enabled) {
            return false;
        }
        return receiver->event(event);
    }

    return receiver->event(event);
}

Here is the call graph for this function:

Object* Wt::Object::parent

(

)

const [inline, inherited]

Definition at line 53 of file object.h.

References Wt::Object::parent_.

Referenced by Wt::Widget::event(), Wt::Widget::focusNextPrevChild(), Wt::Window::Frame::Frame(), Wt::Widget::is_hidden(), Wt::Object::isDescendant(), Wt::Layout::isTopLevel(), Wt::Layout::Layout(), Wt::Widget::lower(), Wt::Layout::mainWidget(), Wt::operator<<(), Wt::Widget::paintEvent(), Wt::Widget::parentWidget(), postEvent(), Wt::Widget::raise(), Wt::Widget::updateGeometry(), Wt::Widget::Widget(), Wt::Window::Window(), Wt::Layout::~Layout(), and Wt::Widget::~Widget().

                           {
        return parent_;
    };

void Wt::Application::parseArgs	(	int	argc,
		char **	argv
	)			[protected]

Definition at line 99 of file application.cpp.

References argv_, depth_, Wt::SDL::enableDebug(), enableTrace, height_, Wt::Object::name(), quit(), trace, and width_.

Referenced by Application().

                                                 {
    enum {
        TRACE, XSYNC, WT_WIDTH, WT_HEIGHT, WT_DEPTH, WT_HELP, HELP
    };

    class Option {
    public:
        Option(const std::string& name, const std::string& help)
                : name(name),
        help(help) {}
        std::string name;
        std::string help;
    };

    Option options[] = {
                           Option("--wt-trace=", "enables tracing for a comma separated list of subsystems"),
                           Option("--wt-xsync", "enables X sync to help debugging"),
                           Option("--wt-width=", "the preffered width of the application"),
                           Option("--wt-height=", "the preffered height of the application"),
                           Option("--wt-depth=", "the preffered color depth of the application"),
                           Option("--wt-help", "display this help and quits"),
                           Option("--help", "display this help and quits")
                       };

    const int numopts = sizeof(options) / sizeof(options[0]);

    for (int i = 0; i < argc; i++) {
        std::string s = argv[i];
        if (s.find(options[TRACE].name) == 0) {
            std::string rest = std::string(s, options[TRACE].name.length());
            do {
                //look for comma
                std::string channel;
                int comma_index = rest.find(",");
                if (comma_index > 0) {
                    channel = std::string(rest, 0, comma_index);
                    rest = std::string(rest, comma_index + 1);
                    enableTrace(channel);
                } else if (comma_index < 0) {
                    channel = std::string(rest, 0);
                    rest = "";
                    enableTrace(channel);
                } else {
                    // == 0
                    rest = std::string(rest, comma_index + 1);
                }
            } while(rest.length());
        } else if (s.find(options[XSYNC].name) == 0) {
            trace("app", "Enabling X-sync for debugging\n");
            SDL::enableDebug();
        } else if (s.find(options[WT_WIDTH].name) == 0) {
            width_ = boost::lexical_cast<int>(std::string(s, options[WT_WIDTH].name.length()));
        } else if (s.find(options[WT_HEIGHT].name) == 0) {
            height_ = boost::lexical_cast<int>(std::string(s, options[WT_HEIGHT].name.length()));
        } else if (s.find(options[WT_DEPTH].name) == 0) {
            depth_ = boost::lexical_cast<int>(std::string(s, options[WT_DEPTH].name.length()));
        } else if (s.find(options[WT_HELP].name) == 0 ||
                   s.find(options[HELP].name) == 0) {
            std::cout << "Standard wt options are:\n";
            for (int j = 0; j < numopts; j++) {
                std::cout << "\t" << options[j].name <<
                "\t" << options[j].help << std::endl;
            }
            quit();
        } else {
            argv_.push_back(s);
        }
    }
}

Here is the call graph for this function:

void Wt::Application::postEvent	(	Object *	receiver,
		Event *	event
	)			[static]

Definition at line 339 of file application.cpp.

References Wt::Event::ChildInserted, Wt::Event::ChildRemoved, Wt::Application::EventQueueItem::event, Wt::Object::event(), event(), Wt::Singleton< DERIVED >::existingInstance(), Wt::Region::isEmpty(), Wt::Event::LayoutHint, Wt::Widget::mapToParent(), Wt::Event::Move, Wt::Event::Paint, Wt::Object::parent(), queue, Wt::Application::EventQueueItem::receiver, Wt::PaintEvent::region(), Wt::Event::Resize, sendEvent(), trace, and Wt::Widget::update().

Referenced by Wt::SDLInput::handleActiveEvent(), Wt::SDLInput::handleKeyEvent(), Wt::SDLInput::handleMouseEvent(), Wt::SDLTimer::handleTimerEvent(), Wt::Widget::hiddenChanged(), Wt::Object::insertChild(), Wt::Widget::move(), Wt::Layout::postLayoutHintEvent(), Wt::postLayoutHintEventRecursively(), Wt::Object::removeChild(), Wt::Widget::resize(), Wt::Widget::setFocus(), Wt::Widget::setLayout(), Wt::Widget::update(), Wt::Widget::updateGeometry(), and Wt::Object::~Object().

                                                          {
    Application *app = existingInstance();
    if (!app) {
        sendEvent(receiver, *event);
        delete event;
        return;
    }
    EventQueueList& queue = app->queue;
    EventQueueItem new_item(receiver, event);
    int type = event->type();

    trace("event") << "Posting " << event
    << " for " << receiver << std::endl;

    // obvious optimization: eliminate unnedded/unprocessed/overwritten events
    // let only the last one suvive for move, size, layouthint
    // aggregate paint
    // also eliminate child events when they are followed by destruction
    switch (type) {
    case Event::ChildRemoved: {
            Object *dead_obj = (static_cast<ChildEvent *>(event))->child();
            for (EventQueueList::iterator I(queue.begin()),
                    E(queue.end()); I != E;) {
                const EventQueueItem& item = *I;
                if ((item.receiver == new_item.receiver &&
                        item.event->type() == Event::ChildInserted) ||
                        item.receiver == dead_obj) {
                    trace("event") << "Eliminating " << item.event <<
                    " for " << static_cast<void *>(item.receiver) << std::endl;
                    delete item.event;
                    I = queue.erase(I);
                } else {
                    ++I;
                }
            }
            // we are not going to deliver this sucker
            if (!receiver) {
                delete event;
                return;
            }
        }
        break;
    case Event::Paint: {
            Region region;

            for (EventQueueList::iterator I(queue.begin()),
                    E(queue.end()); I != E;) {
                const EventQueueItem& item = *I;
                if(item == new_item) {
                    PaintEvent *paint_e;
                    if (region.isEmpty()) {
                        paint_e = static_cast<PaintEvent *>(new_item.event);
                        region = paint_e->region();
                    }
                    // aggregate paint events
                    paint_e = static_cast<PaintEvent *>(item.event);
                    trace("event") << "Before Aggregation: " << region;
                    region |= paint_e->region();
                    trace("event") << "Aggregate: " << paint_e->region();
                    trace("event") << "After Aggregation: " << region;
                    trace("event") << "Eliminating "
                    << item.event << " " << static_cast<void *>(item.event)
                    << " for " << receiver << std::endl;
                    delete item.event;
                    I = queue.erase(I);
                } else {
                    ++I;
                }
            }

            if (!region.isEmpty()) {
                bool erased = static_cast<PaintEvent *>(new_item.event)->erased();
                delete new_item.event;
                // clip to parent if exists
                Widget *w = static_cast<Widget *>(new_item.receiver);
                Widget *wp = static_cast<Widget *>(w->parent());
                if (wp) {
                    Widget::update(wp, w->mapToParent(region));
                }
                new_item.event = new PaintEvent(region, erased);
            }

        }
        break;
    case Event::Resize:
    case Event::Move:
    case Event::LayoutHint:
        for (EventQueueList::iterator I(queue.begin()),
                E(queue.end()); I != E;) {
            const EventQueueItem& item = *I;
            if(item == new_item) {
                trace("event") << "Eliminating " << item.event << " for " << receiver << std::endl;
                delete item.event;
                I = queue.erase(I);
            } else {
                ++I;
            }
        }
        break;
    default:
        break;
    }

    queue.push_back(new_item);
}

Here is the call graph for this function:

void Wt::Application::processEvent

(

)

process on event event if we have to wait for it

Definition at line 239 of file application.cpp.

References processEvents().

                               {
    SingleShot c;
    processEvents(&c);
}

Here is the call graph for this function:

void Wt::Application::processEvents

(

const bool &

var

)

process all events while the var is true

Definition at line 278 of file application.cpp.

References processEvents().

                                               {
    VarBlock v(var);
    processEvents(&v);
}

Here is the call graph for this function:

void Wt::Application::processEvents

(

int

ms = 3000

)

process all the events in the queue for a maximum period of time

Definition at line 260 of file application.cpp.

References processEvents().

                                      {
    TimerBlock t(ms);
    processEvents(&t);
}

Here is the call graph for this function:

void Wt::Application::processEvents

(

Condition *

cond

)

process all events until the condition is met

Definition at line 211 of file application.cpp.

References condition_stack, queue, sendPostedEvents(), and Wt::SDLEvent::wait().

Referenced by exec(), processEvent(), and processEvents().

                                               {
    condition_stack.push(cond);
    while (!(*cond)()) {
        if (queue.empty())
            SDLEvent::wait();
        sendPostedEvents();
    }
    condition_stack.pop();
}

Here is the call graph for this function:

void Wt::Application::quit

(

)

Halt execution and close window.

Reimplemented from Wt::Singleton< DERIVED >.

Definition at line 299 of file application.cpp.

References exit().

Referenced by parseArgs().

                       {
    Application::exit(0);
}

Here is the call graph for this function:

void Wt::Object::removeChild

(

Object *

obj

)

[virtual, inherited]

Definition at line 88 of file object.cpp.

References Wt::Event::ChildRemoved, Wt::Object::children_, Wt::Object::parent_, and postEvent().

Referenced by Wt::Object::reparent(), and Wt::Object::~Object().

                                    {
    List::iterator end = children_.end();
    List::iterator p = find(children_.begin(), end, obj);

    if (p != end) {
        children_.erase(p);
        obj->parent_ = 0;
        Event *child_event = new ChildEvent(Event::ChildRemoved, obj);
        Application::postEvent(this, child_event);
    }
}

Here is the call graph for this function:

void Wt::Object::removeEventFilter

(

const Object *

obj

)

[inherited]

Definition at line 132 of file object.cpp.

References Wt::Object::eventFilters_.

Referenced by Wt::Object::installEventFilter().

                                                {
    List::iterator p, end(eventFilters_.end());
    p = find(eventFilters_.begin(), end, obj);
    if (p != end)
        eventFilters_.erase(p);
}

void Wt::Object::reparent

(

Object *

new_parent

)

[inherited]

Definition at line 100 of file object.cpp.

References Wt::Object::insertChild(), Wt::Object::parent_, Wt::Object::removeChild(), and trace.

Referenced by Wt::Layout::addItem(), Wt::Widget::reparent(), and Wt::Widget::setLayout().

                                        {
    if (parent_ == new_parent)
        return;
    trace("obj") << "Reparenting " <<  this << std::endl;

    if (parent_) {
        trace("obj") << "   Leaving parent " <<  parent_ << std::endl;
        parent_->removeChild(this);
    }
    if (new_parent) {
        trace("obj") << "   Going to new parent " <<  new_parent << std::endl;
        new_parent->insertChild(this);
    }
    parent_ = new_parent;
}

Here is the call graph for this function:

bool Wt::Application::sendEvent	(	Object *	receiver,
		Event &	event
	)			[static]

Definition at line 330 of file application.cpp.

References event(), Wt::Singleton< DERIVED >::existingInstance(), and notify().

Referenced by Wt::Widget::close(), Wt::Widget::event(), postEvent(), Wt::Widget::repaint(), and sendPostedEvents().

                                                          {
    Application *app = existingInstance();
    if (app)
        return app->notify(receiver, &event);
    else if (receiver)
        return receiver->event(&event);
    return 0;
}

Here is the call graph for this function:

void Wt::Application::sendPostedEvents

(

)

[static]

process the already posted events -- empties the queue

Definition at line 195 of file application.cpp.

References Wt::Singleton< DERIVED >::existingInstance(), queue, sendEvent(), and trace.

Referenced by exec(), Wt::Layout::Layout(), processEvents(), Wt::Widget::Widget(), Wt::Window::Window(), and Wt::Object::~Object().

                                   {
    Application *app = existingInstance();
    if (!app)
        return;
    EventQueueList& queue = app->queue;
    while (!queue.empty()) {
        const EventQueueItem item = queue.front();
        Object *receiver = item.receiver;
        Event *e = item.event;
        queue.pop_front();
        trace("event") << "Handling " << e << std::endl;
        sendEvent(receiver, *e);
        delete e;
    }
}

Here is the call graph for this function:

int Wt::Object::startTimer

(

int

interval

)

[inherited]

Definition at line 139 of file object.cpp.

References Wt::Object::timers_.

Referenced by Wt::Timer::start().

                                   {
    int id = timers_.size() + 1;
    timers_[id] = new SDLTimer(this, id, interval);
    return id;
}

virtual void Wt::Object::timerEvent

(

TimerEvent *

)

[inline, protected, virtual, inherited]

Reimplemented in Wt::Timer.

Definition at line 148 of file object.h.

Referenced by Wt::Object::event(), and Wt::Timer::timerEvent().

{}

Object * Wt::Object::topParent

(

)

const [inherited]

returns top level parent: it may return itself

Definition at line 116 of file object.cpp.

References Wt::Object::parent_.

Referenced by Wt::Widget::topParentWidget().

                                {
    const Object *p = this;
    while (p->parent_) {
        p = p->parent_;
    }
    return const_cast<Object *>(p);
}

---

Friends And Related Function Documentation

friend class Singleton< Application > [friend]

Definition at line 42 of file application.h.

---

Member Data Documentation

sigc::signal<void> Wt::Application::aboutToQuit

Definition at line 86 of file application.h.

Referenced by ~Application().

std::list<std::string> Wt::Application::argv_ [private]

Definition at line 118 of file application.h.

Referenced by argv(), and parseArgs().

ConditionStack Wt::Application::condition_stack [private]

Definition at line 113 of file application.h.

Referenced by processEvents().

int Wt::Application::depth_ [private]

Definition at line 127 of file application.h.

Referenced by Application(), and parseArgs().

Signal01<void, const Object *> Wt::Object::destroyed [inherited]

signals

Definition at line 139 of file object.h.

Referenced by Wt::Layout::addItem(), Wt::Object::installEventFilter(), and Wt::Object::~Object().

int Wt::Application::exitcode_ [private]

Definition at line 121 of file application.h.

Referenced by exec(), and exit().

int Wt::Application::height_ [private]

Definition at line 126 of file application.h.

Referenced by Application(), and parseArgs().

template<class DERIVED>

DERIVED * Wt::Singleton< DERIVED >::instance_ = 0 [static, protected, inherited]

Definition at line 91 of file singleton.h.

Referenced by Wt::Singleton< Wt::Audio >::existingInstance(), Wt::Singleton< Wt::Audio >::instance(), Wt::Singleton< Wt::Audio >::load(), Wt::SDLDisplay::load(), Wt::Audio::load(), Wt::Singleton< Wt::Audio >::Singleton(), and Wt::Singleton< Wt::Audio >::~Singleton().

EventQueueList Wt::Application::queue [private]

Definition at line 111 of file application.h.

Referenced by postEvent(), processEvents(), and sendPostedEvents().

bool Wt::Application::running_ [private]

Definition at line 123 of file application.h.

Referenced by exec(), and exit().

int Wt::Application::width_ [private]

Definition at line 125 of file application.h.

Referenced by Application(), and parseArgs().

---

The documentation for this class was generated from the following files:

• application.h
• application.cpp

---

Generated Fri Jul 28 19:25:33 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.