application.cpp

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

// for Fatal constructor
#include <iostream>

#include <wt/application.h>
#include <wt/trace.h>
#include <wt/rootwindow.h>
#include <wt/color.h>
#include <wt/font.h>
#include <wt/audio.h>

#include "sdlevent.h"
#include "sdltimer.h"
#include "sdlinput.h"
#include "sdlmisc.h"

#include <wt/event.h>

namespace Wt {

Application::EventQueueItem::EventQueueItem(Object *receiver, Event *event)
        : receiver(receiver), event(event) {}

bool Application::EventQueueItem::operator==(const EventQueueItem& other) const {
    return (other.receiver == receiver && other.event->type() == event->type());
}

const char * Application::Exception::what() const throw() {
    return SDL_GetError();
}

Application::Application(int argc, char **argv)
        : 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);
}

std::list<std::string>& Application::argv() {
    return argv_;
}

void Application::parseArgs(int argc, char** argv) {
    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);
        }
    }
}

Application::~Application() {
    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();
}

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

void Application::sendPostedEvents() {
    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;
    }
}

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

class SingleShot : public Application::Condition {
public:
    SingleShot()
            : count_(0) {}

    virtual bool operator()() {
        if (count_)
            return true;

        count_++;

        return false;
    }

private:
    int count_;
};

void Application::processEvent() {
    SingleShot c;
    processEvents(&c);
}

class TimerBlock : public Application::Condition {
public:
    TimerBlock(int ms)
            : ms(ms) {
        time.start();
    }

    virtual bool operator()() {
        return (time.elapsed() > ms);
    }

private:
    Time time;
    int ms;
};

void Application::processEvents(int ms) {
    TimerBlock t(ms);
    processEvents(&t);
}

class VarBlock : public Application::Condition {
public:
    VarBlock(const bool& var)
            : var(var) {}

    virtual bool operator()() {
        return !var;
    }

private:
    const bool& var;
};

void Application::processEvents(const bool& var) {
    VarBlock v(var);
    processEvents(&v);
}

/// process all events so far until the end of the application
int Application::exec() {
    processEvents(running_);
    sendPostedEvents();
    return exitcode_;
}

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

void Application::quit() {
    Application::exit(0);
}

bool Application::event(Event *e) {
    return filterEvent(e);
}

bool Application::notify(Object *receiver, Event *event) {
    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);
}

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

void Application::postEvent(Object *receiver, Event *event) {
    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);
}

} // namespace Wt

---

Generated Fri Jul 28 19:22:59 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.