/data/gitorious.org/libyui/libyui-master/src/YEvent.h

/**************************************************************************
Copyright (C) 2000 - 2010 Novell, Inc.
All Rights Reserved.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

**************************************************************************/


/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

  File:         YEvent.h

  Author:       Stefan Hundhammer <sh@suse.de>

/-*/

#ifndef YEvent_h
#define YEvent_h


#include <string>
#include <iosfwd>
#include "YDialog.h"
#include "YSimpleEventHandler.h"

using std::string;
class YWidget;
class YItem;
class YDialog;


class YEvent
{
public:

    enum EventType
    {
        NoEvent = 0,
        UnknownEvent,
        WidgetEvent,
        MenuEvent,
        KeyEvent,
        CancelEvent,
        TimeoutEvent,
        DebugEvent,
        InvalidEvent = 0x4242
    };


    enum EventReason
    {
        UnknownReason = 0,
        Activated,
        SelectionChanged,
        ValueChanged,
        ContextMenuActivated
    };


    YEvent( EventType eventType = UnknownEvent );

    EventType eventType() const { return _eventType; }

    unsigned long serial() const { return _serial; }

    virtual YWidget * widget() const { return 0; }

    virtual YItem * item() const { return 0; }

    YDialog * dialog() const { return _dialog; }

    bool isValid() const;

    static const char * toString( EventType eventType );

    static const char * toString( EventReason reason );


protected:
    
    void setDialog( YDialog * dia ) { _dialog = dia; }

    virtual ~YEvent();

    void invalidate();

private:
    
    friend void YDialog::deleteEvent( YEvent * event );
    friend void YSimpleEventHandler::deleteEvent( YEvent * event );


    //
    // Data members
    //

    EventType                   _eventType;
    unsigned long               _serial;
    YDialog *                   _dialog;

    static unsigned long        _nextSerial;
};



class YWidgetEvent: public YEvent
{
public:

    YWidgetEvent( YWidget *     widget          = 0,
                  EventReason   reason          = Activated,
                  EventType     eventType       = WidgetEvent );

    virtual YWidget * widget() const { return _widget; }

    EventReason reason() const { return _reason; }

protected:

    virtual ~YWidgetEvent() {}

    
    //
    // Data members
    //
    
    YWidget *   _widget;
    EventReason _reason;
};


class YKeyEvent: public YEvent
{
public:

    YKeyEvent( const string &   keySymbol,
               YWidget *        focusWidget = 0 );

    string keySymbol() const { return _keySymbol; }

    YWidget * focusWidget() const { return _focusWidget; }

protected:
    
    virtual ~YKeyEvent() {}

    
    //
    // Data members
    //

    string      _keySymbol;
    YWidget *   _focusWidget;
};


class YMenuEvent: public YEvent
{
public:

    YMenuEvent( YItem * item )
        : YEvent( MenuEvent )
        , _item( item )
        {}

    YMenuEvent( const char *     id )   : YEvent( MenuEvent ), _item(0), _id( id ) {}
    YMenuEvent( const string &   id )   : YEvent( MenuEvent ), _item(0), _id( id ) {}

    virtual YItem * item() const { return _item; }

    string id() const { return _id; }

protected:
    
    virtual ~YMenuEvent() {}

    
    //
    // Data members
    //

    YItem * _item;
    string  _id;
};


class YCancelEvent: public YEvent
{
public:

    YCancelEvent() : YEvent( CancelEvent ) {}

    
protected:
    virtual ~YCancelEvent() {}
};


class YDebugEvent: public YEvent
{
public:

    YDebugEvent() : YEvent( DebugEvent ) {}
    
protected:
    virtual ~YDebugEvent() {}
};


class YTimeoutEvent: public YEvent
{
public:

    YTimeoutEvent() : YEvent( TimeoutEvent ) {}
    
protected:
    virtual ~YTimeoutEvent() {}
};


std::ostream & operator<<( std::ostream & stream, const YEvent * event );


#endif // YEvent_h