YQUI.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:     YQUI.h
 
  Author:   Stefan Hundhammer <shundhammer@suse.de>
 
/-*/
 
#ifndef YQUI_h
#define YQUI_h
 
#include <qapplication.h>
#include <QMap>
#include <QTimer>
#include <QIcon>
#include <vector>
#include <type_traits>
 
#include <yui/YUI.h>
#include <yui/YSimpleEventHandler.h>
#include <yui/YCommandLine.h>
 
#define YQWidgetMargin  4
#define YQWidgetSpacing 4
#define YQButtonBorder  3
 
// To be used in connect(foo, &pclass(foo)::mysignal, bar, &pclass(bar)::myslot);
// That checks types at compile time,
// unlike the string based SIGNAL and SLOT macros.
#define pclass(ptr) std::remove_reference<decltype(*ptr)>::type
 
 
class QCursor;
class QFrame;
class QStackedWidget;
class YEvent;
class YQOptionalWidgetFactory;
class YQWidgetFactory;
class YQApplication;
class YQUISignalReceiver;
 
using std::string;
using std::vector;
 
class YQUI: public YUI
{
    friend class YQUISignalReceiver;
 
public:
 
    YQUI( bool withThreads, bool topmostConstructor = true );
 
    virtual ~YQUI();
 
    static YQUI * ui() { return _ui; }
 
    virtual void initUI();
 
protected:
    virtual YWidgetFactory * createWidgetFactory();
 
    virtual YOptionalWidgetFactory * createOptionalWidgetFactory();
 
    /*
     * Create the YApplication object that provides global methods.
     *
     * Reimplemented from YUI.
     **/
    virtual YApplication * createApplication();
 
public:
 
    static YQApplication * yqApp();
 
    void sendEvent( YEvent * event );
 
    bool eventPendingFor( YWidget * widget ) const
    { return _eventHandler.eventPendingFor( widget ); }
 
    YEvent * pendingEvent() const { return _eventHandler.pendingEvent(); }
 
    YEvent * consumePendingEvent() { return _eventHandler.consumePendingEvent(); }
 
    virtual void deleteNotify( YWidget * widget );
 
    bool fullscreen() const { return _fullscreen; }
 
    bool noBorder() const { return _noborder; }
    bool fatalError() const { return _fatalError; }
 
    void raiseFatalError() { _fatalError = true; }
 
    int defaultSize( YUIDimension dim ) const;
 
    void makeScreenShot( std::string filename );
 
    virtual YEvent * runPkgSelection( YWidget * packageSelector );
 
    void toggleRecordMacro();
 
    void askPlayMacro();
 
    void askSendWidgetID();
 
    virtual void blockEvents( bool block = true );
 
    virtual bool eventsBlocked() const;
 
    void forceUnblockEvents();
 
    void busyCursor();
 
    void normalCursor();
 
    void timeoutBusyCursor();
 
    void askSaveLogs();
 
    void askConfigureLogging();
 
    static void setTextdomain( const char * domain );
 
    QString applicationTitle() { return _applicationTitle; }
 
    void setApplicationTitle(const QString & title) { _applicationTitle=title; }
 
    QIcon loadIcon( const string & iconName ) const;
 
protected:
 
    void processCommandLineArgs( int argc, char **argv );
 
    void probeX11Display( const YCommandLine & cmdLine );
 
    void calcDefaultSize();
 
    virtual void idleLoop( int fd_ycp );
 
    virtual void uiThreadDestructor();
 
    void receivedYCPCommand();
 
    bool close();
 
 
    //
    // Data members
    //
 
    static YQUI *   _ui;
 
    QMap<QString, int>  screenShotNo;
 
    bool        _fullscreen;
    bool        _noborder;
    QSize       _defaultSize;
 
    bool        _do_exit_loop;
    bool        _received_ycp_command;
    bool        _fatalError;
 
    QTimer *        _busyCursorTimer;
 
    YSimpleEventHandler _eventHandler;
    int         _blockedLevel;
 
    bool        _leftHandedMouse;
    bool        _askedForLeftHandedMouse;
 
    bool        _uiInitialized;
 
    YQUISignalReceiver * _signalReceiver;
    QString         _applicationTitle;
 
    // Qt copies the _reference_ to argc, so we need to store argc
    int _ui_argc;
};
 
 
class YQUISignalReceiver : public QObject
{
    Q_OBJECT
 
public:
    YQUISignalReceiver();
 
public slots:
 
    void slotBusyCursor();
    void slotReceivedYCPCommand();
};
 
 
YUI * createUI( bool withThreads );
 
 
#endif // YQUI_h