YUI.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:     YUI.h
 
  Author:   Stefan Hundhammer <shundhammer@suse.de>
 
/-*/
 
#ifndef YUI_h
#define YUI_h
 
#include <pthread.h>
#include <string>
 
#include "YTypes.h"
#include "YSettings.h"
 
 
class YApplication;
class YWidget;
class YWidgetFactory;
class YOptionalWidgetFactory;
class YEvent;
class YBuiltinCaller;
class YDialog;
class YMacroPlayer;
class YMacroRecorder;
 

class YUI
{
    friend class YUIFunction;
    friend class YUILoader;
 
protected:
    YUI( bool withThreads );
 
public:

    virtual ~YUI();

    void shutdownThreads();

    static YUI * ui();

    static YWidgetFactory * widgetFactory();

    static YOptionalWidgetFactory * optionalWidgetFactory();

    static YApplication * app();

    static YApplication * application() { return app(); }
    static YApplication * yApp()    { return app(); }

    static void ensureUICreated();
 
 
protected:

    virtual YWidgetFactory * createWidgetFactory() = 0;

    virtual YOptionalWidgetFactory * createOptionalWidgetFactory() = 0;

    virtual YApplication * createApplication() = 0;
 
 
public:

    virtual void blockEvents( bool block = true ) { _eventsBlocked = block; }

    void unblockEvents() { blockEvents( false ); }

    virtual bool eventsBlocked() const { return _eventsBlocked; }

    virtual void deleteNotify( YWidget * widget ) {}

    void topmostConstructorHasFinished();

    bool runningWithThreads() const { return _withThreads; }

    void uiThreadMainLoop();

    YBuiltinCaller * builtinCaller() const { return _builtinCaller; }

    void setBuiltinCaller( YBuiltinCaller * caller )
    { _builtinCaller = caller; }

    virtual YEvent * runPkgSelection( YWidget * packageSelector ) = 0;

    YWidget * sendWidgetID( const std::string & id );
 
 
protected:

    virtual void idleLoop( int fd_ycp ) = 0;

    void terminateUIThread();

    void createUIThread();
    friend void *start_ui_thread( void *ui_int );

    virtual void uiThreadDestructor();

    void signalUIThread();

    bool waitForUIThread();

    void signalYCPThread();

    bool waitForYCPThread();

    void setButtonOrderFromEnvironment();
 
 
    //
    // Data members
    //

    bool _withThreads;

    pthread_t _uiThread;

    YBuiltinCaller * _builtinCaller;

    int pipe_to_ui[2];

    int pipe_from_ui[2];

    bool _terminate_ui_thread;

    bool _eventsBlocked;
 
private:
 
    static YUI * _ui;
};
 
 
 
#endif // YUI_h