YEvent.h

/*
  Copyright (C) 2000-2012 Novell, Inc
  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) version 3.0 of the License. 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., 51 Franklin Street, Fifth
  Floor, Boston, MA 02110-1301 USA
*/
 
 
/*-/
 
  File:     YEvent.h
 
  Author:   Stefan Hundhammer <shundhammer@suse.de>
 
/-*/
 
#ifndef YEvent_h
#define YEvent_h
 
 
#include <string>
#include <iosfwd>
#include "YDialog.h"
#include "YSimpleEventHandler.h"
 
class YWidget;
class YItem;
class YDialog;
 

class YEvent
{
public:
 
    enum EventType
    {
    NoEvent = 0,
    UnknownEvent,
    WidgetEvent,
    MenuEvent,
    KeyEvent,
    CancelEvent,
    TimeoutEvent,
    DebugEvent,
    SpecialKeyEvent,
    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 std::string & keySymbol,
           YWidget *                focusWidget = 0 );

    std::string keySymbol() const { return _keySymbol; }

    YWidget * focusWidget() const { return _focusWidget; }
 
protected:

    virtual ~YKeyEvent() {}
 
 
    //
    // Data members
    //
 
    std::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 std::string & id )    : YEvent( MenuEvent ), _item(0), _id( id ) {}

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

    std::string id() const { return _id; }
 
protected:

    virtual ~YMenuEvent() {}
 
 
    //
    // Data members
    //
 
    YItem *    _item;
    std::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 YSpecialKeyEvent: public YEvent
{
public:
 
    YSpecialKeyEvent( const char *id )        : YEvent( SpecialKeyEvent ), _id( id ) {}
    YSpecialKeyEvent( const std::string &id ) : YEvent( SpecialKeyEvent ), _id( id ) {}

    std::string id() const { return _id; }
 
protected:
    virtual ~YSpecialKeyEvent() {}
 
    std::string _id;
};

class YTimeoutEvent: public YEvent
{
public:
 
    YTimeoutEvent() : YEvent( TimeoutEvent ) {}
 
protected:
    virtual ~YTimeoutEvent() {}
};
 
 
std::ostream & operator<<( std::ostream & stream, const YEvent * event );
 
 
#endif // YEvent_h