YUI.h

Go to the documentation of this file.

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

  File:         YUI.h

  Authors:      Mathias Kettner <kettner@suse.de>
                Stefan Hundhammer <sh@suse.de>
                
  Maintainer:   Stefan Hundhammer <sh@suse.de>

/-*/

#ifndef YUI_h
#define YUI_h

#include <pthread.h>
#include <deque>
#include <ycp/YCPString.h>
#include <ycp/YCPVoid.h>
#include <ycp/YCPTerm.h>
#include <ycp/YCPInteger.h>
#include <ycp/YCPMap.h>
#include <ycp/YCPBoolean.h>
#include <ycp/YCPByteblock.h>

#include "YWidget.h"
#include "YAlignment.h"


using std::deque;
using std::string;

class YContainerWidget;
class YEvent;
class YDialog;
class YMacroPlayer;
class YMacroRecorder;
class YMenu;
class YMenuButton;
class YMultiSelectionBox;
class YRadioButtonGroup;
class YTree;
class YTreeItem;
class Y2Component;
class Y2UIFunction;

typedef struct
{
    int red;
    int green;
    int blue;
} YColor;

struct  YUIBuiltinCallData
{
    Y2UIFunction *      function;
    YCPValue    result;

    YUIBuiltinCallData()
        : result( YCPVoid() )
    {
        function        = 0;
    }
};


class YUI
{
protected:
    YUI( bool with_threads );

    friend class Y2UIFunction;

public:

    virtual ~YUI();


    static YUI * ui() { return _yui; }


    bool threads() { return with_threads; }

    YDialog *currentDialog() const;


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

    void unblockEvents() { blockEvents( false ); }

    virtual bool eventsBlocked() const { return _events_blocked; }

    void topmostConstructorHasFinished();

    virtual void internalError( const char *msg );

    static int Recode( const string & str,
                       const string & from,
                       const string & to,
                       string & outstr );

    int parseMenuItemList( const YCPList & itemList, YMenuButton *menu_button, YMenu *parentMenu = 0 );

    bool parseRgb( const YCPValue & val, YColor *color, bool complain );

    YWidget *createWidgetTree( YWidget *parent, YWidgetOpt & opt, YRadioButtonGroup *rbg, const YCPTerm & term );

    YWidget *createWidgetTree( YWidget *parent, YRadioButtonGroup *rbg, const YCPTerm & term );

    YWidget *widgetWithId( const YCPValue & id, bool log_error=false );

    YWidget *widgetWithId( YContainerWidget *widgetRoot, const YCPValue & id, bool log_error=false );

    int defaultFunctionKey( YCPString label );

    string productName() const { return _productName; }

    virtual long deviceUnits( YUIDimension dim, float layout_units );

    virtual float layoutUnits( YUIDimension dim, long device_units );

    static bool reverseLayout() { return _reverseLayout; }

    static void setReverseLayout( bool rev ) { _reverseLayout = rev; }

    YCPValue callBuiltin( void * /*function*/, int /*argc*/, YCPValue /*argv*/[] ) {
        // FIXME dummy UI?
        return YCPNull();
    }

    static YCPValue callFunction( void * function, int argc, YCPValue argv[] );

    void setCallback( Y2Component * callback ) { _callback = callback; }

    Y2Component * getCallback() const { return _callback; }

    YCPValue evaluateAskForExistingDirectory            ( const YCPString& startDir, const YCPString& headline );
    YCPValue evaluateAskForExistingFile                 ( const YCPString& startDir, const YCPString& filter, const YCPString& headline );
    YCPValue evaluateAskForSaveFileName                 ( const YCPString& startDir, const YCPString& filter, const YCPString& headline );
    void evaluateBusyCursor                             ();
    void evaluateBeep                                   ();
    YCPValue evaluateChangeWidget                       ( const YCPValue & value_id, const YCPValue & property, const YCPValue & new_value );
    void evaluateCheckShortcuts                         ();
    YCPValue evaluateCollectUserInput                   ();
    YCPValue evaluateCollectUserInput                   ( const YCPTerm & widgetId );
    YCPValue evaluateCloseDialog                        ();
    void evaluateDumpWidgetTree                         ();
    void evaluateFakeUserInput                          ( const YCPValue & next_input );
    YCPMap evaluateGetDisplayInfo                       ();
    YCPString evaluateGetLanguage                       ( const YCPBoolean & strip_encoding );
    YCPValue evaluateGetModulename                      ( const YCPTerm & term );
    YCPString evaluateGetProductName                    ();
    YCPString evaluateGlyph                             ( const YCPSymbol & symbol );
    YCPValue evaluateHasSpecialWidget                   ( const YCPSymbol & widget );
    void evaluateMakeScreenShot                         ( const YCPString & filename );
    void evaluateNormalCursor                           ();
    YCPBoolean evaluateOpenDialog                       ( const YCPTerm & term, const YCPTerm & opts = YCPNull() );
    void evaluatePlayMacro                              ( const YCPString & filename );
    void evaluatePostponeShortcutCheck                  ();
    YCPValue evaluateQueryWidget                        ( const YCPValue& value_id, const YCPValue& property );
    void evaluateRecalcLayout                           ();
    YCPValue evaluateRecode                             ( const YCPString & from, const YCPString & to, const YCPString & text );
    void evaluateRecordMacro                            ( const YCPString & filename );
    void evaluateRedrawScreen                           ();
    YCPBoolean evaluateReplaceWidget                    ( const YCPValue & value_id, const YCPTerm & term );
    YCPValue evaluateRunPkgSelection                    ( const YCPValue & value_id );
    void evaluateSetConsoleFont                         ( const YCPString& magic,
                                                          const YCPString& font,
                                                          const YCPString& screen_map,
                                                          const YCPString& unicode_map,
                                                          const YCPString& encoding );
    void evaluateSetKeyboard                            ();
    YCPInteger evaluateRunInTerminal                    ( const YCPString& module);
    YCPBoolean evaluateSetFocus                         ( const YCPValue & value_id );
    void evaluateSetFunctionKeys                        ( const YCPMap & new_keys );
    void evaluateSetLanguage                            ( const YCPString& lang, const YCPString& encoding = YCPNull() );
    void evaluateSetModulename                          ( const YCPString & name );
    void evaluateSetProductName                         ( const YCPString & name );
    void evaluateStopRecordMacro                        ();
    YCPBoolean evaluateWidgetExists                     ( const YCPValue & value_id );

    YCPValue evaluateUserInput                          ();
    YCPValue evaluateTimeoutUserInput                   ( const YCPInteger & timeout );
    YCPValue evaluateWaitForEvent                       ( const YCPInteger & timeout = YCPNull() );
    YCPValue evaluateWizardCommand                      ( const YCPTerm & command );
    YCPValue evaluatePollInput                          ();

    void uiThreadMainLoop();

    static bool checkId( const YCPValue & val, bool complain = true );

    static YCPValue getId( const YCPValue & v );


protected:




    const char *moduleName();

    // Event handling, execution flow

    virtual void idleLoop( int fd_ycp );

    virtual YEvent * userInput( unsigned long timeout_millisec = 0 ) = 0;

    virtual YEvent * pollInput() = 0;

    virtual void showDialog( YDialog *dialog );

    virtual void closeDialog( YDialog *dialog );


    virtual YCPString glyph( const YCPSymbol & /*glyphSymbol*/ ) { return YCPString( "" ); }


    //
    // Widget creation functions - container widgets
    //

    virtual YDialog *createDialog( YWidgetOpt & opt ) = 0;

    virtual YContainerWidget *createSplit( YWidget *parent, YWidgetOpt & opt, YUIDimension dimension ) = 0;

    virtual YContainerWidget *createReplacePoint( YWidget *parent, YWidgetOpt & opt ) = 0;

    virtual YContainerWidget *createAlignment( YWidget *parent, YWidgetOpt & opt,
                                               YAlignmentType halign,
                                               YAlignmentType valign ) = 0;

    virtual YContainerWidget *createSquash( YWidget *parent, YWidgetOpt & opt, bool hsquash, bool vsquash ) = 0;


    virtual YContainerWidget *createRadioButtonGroup( YWidget *parent, YWidgetOpt & opt ) = 0;

    virtual YContainerWidget *createFrame( YWidget *parent, YWidgetOpt & opt, const YCPString & label ) = 0;

    virtual YContainerWidget *createCheckBoxFrame( YWidget *parent, YWidgetOpt & opt, const YCPString & label, bool checked ) = 0;


    //
    // Widget creation functions - leaf widgets
    //

    virtual YWidget *createEmpty( YWidget *parent, YWidgetOpt & opt ) = 0;

    virtual YWidget *createSpacing( YWidget *parent, YWidgetOpt & opt, float size, bool horizontal, bool vertical ) = 0;

    virtual YWidget *createLabel( YWidget *parent, YWidgetOpt & opt, const YCPString & text ) = 0;


    virtual YWidget *createRichText( YWidget *parent, YWidgetOpt & opt, const YCPString & text ) = 0;


    virtual YWidget *createLogView( YWidget *parent, YWidgetOpt & opt,
                                    const YCPString & label, int visibleLines, int maxLines ) = 0;

    virtual YWidget *createPushButton( YWidget *parent, YWidgetOpt & opt, const YCPString & label ) = 0;

    virtual YWidget *createMenuButton( YWidget *parent, YWidgetOpt & opt, const YCPString & label ) = 0;

    virtual YWidget *createRadioButton( YWidget *parent, YWidgetOpt & opt, YRadioButtonGroup *rbg,
                                        const YCPString & label, bool checked ) = 0;

    virtual YWidget *createCheckBox( YWidget *parent, YWidgetOpt & opt, const YCPString & label, bool checked ) = 0;

    virtual YWidget *createTextEntry( YWidget *parent, YWidgetOpt & opt, const YCPString & label, const YCPString & text ) = 0;

    virtual YWidget *createMultiLineEdit( YWidget *parent, YWidgetOpt & opt, const YCPString & label, const YCPString & text ) = 0;

    virtual YWidget *createSelectionBox( YWidget *parent, YWidgetOpt & opt, const YCPString & label ) = 0;

    virtual YWidget *createMultiSelectionBox( YWidget *parent, YWidgetOpt & opt, const YCPString & label ) = 0;

    virtual YWidget *createComboBox( YWidget *parent, YWidgetOpt & opt, const YCPString & label ) = 0;

    virtual YWidget *createTree( YWidget *parent, YWidgetOpt & opt, const YCPString & label ) = 0;

    virtual YWidget *createTable( YWidget *parent, YWidgetOpt & opt, vector<string> header ) = 0;

    virtual YWidget *createProgressBar( YWidget *parent, YWidgetOpt & opt, const YCPString & label,
                                        const YCPInteger & maxprogress, const YCPInteger & progress ) = 0;

    virtual YWidget *createImage( YWidget *parent, YWidgetOpt & opt, YCPByteblock imagedata, YCPString defaulttext ) = 0;

    virtual YWidget *createImage( YWidget *parent, YWidgetOpt & opt, YCPString file_name, YCPString defaulttext ) = 0;

    virtual YWidget *createIntField( YWidget *parent, YWidgetOpt & opt,
                                     const YCPString & label, int minValue, int maxValue, int initialValue ) = 0;

    virtual YWidget *createPackageSelector( YWidget *parent, YWidgetOpt & opt, const YCPString & floppyDevice ) = 0;

    virtual YWidget *createPkgSpecial( YWidget *parent, YWidgetOpt & opt, const YCPString & subwidget ) = 0;


    virtual YWidget *createDummySpecialWidget( YWidget *parent, YWidgetOpt & opt );
    virtual bool     hasDummySpecialWidget() { return true; }

    virtual YWidget *   createDownloadProgress( YWidget *parent, YWidgetOpt & opt,
                                                const YCPString & label,
                                                const YCPString & filename,
                                                int expectedSize );

    virtual bool        hasDownloadProgress() { return false; }

    virtual YWidget *   createBarGraph( YWidget *parent, YWidgetOpt & opt );
    virtual bool        hasBarGraph()  { return false; }

    virtual YWidget *   createColoredLabel( YWidget *parent, YWidgetOpt & opt,
                                            YCPString label,
                                            YColor foreground, YColor background,
                                            int margin );
    virtual bool        hasColoredLabel() { return false; }


    virtual YWidget *   createDate( YWidget *parent,
                                    YWidgetOpt & opt,
                                    const YCPString & label,
                                    const YCPString & date );
    virtual bool        hasDate() { return false; }


    virtual YWidget *   createTime( YWidget *parent,
                                    YWidgetOpt & opt,
                                    const YCPString & label,
                                    const YCPString & time );
    virtual bool        hasTime() { return false; }


    virtual YWidget *   createDumbTab( YWidget *parent, YWidgetOpt & opt );
    virtual bool        hasDumbTab() { return false; }


    virtual YWidget *   createMultiProgressMeter( YWidget *parent, YWidgetOpt & opt,
                                                  bool horizontal, const YCPList & maxValues );
    virtual bool        hasMultiProgressMeter() { return false; }


    virtual YWidget *   createSlider( YWidget *         parent,
                                      YWidgetOpt &      opt,
                                      const YCPString & label,
                                      int               minValue,
                                      int               maxValue,
                                      int               initialValue );
    virtual bool        hasSlider() { return false; }

    virtual YWidget *createPartitionSplitter( YWidget *         parent,
                                              YWidgetOpt &      opt,
                                              int               usedSize,
                                              int               totalFreeSize,
                                              int               newPartSize,
                                              int               minNewPartSize,
                                              int               minFreeSize,
                                              const YCPString & usedLabel,
                                              const YCPString & freeLabel,
                                              const YCPString & newPartLabel,
                                              const YCPString & freeFieldLabel,
                                              const YCPString & newPartFieldLabel );

    virtual bool        hasPartitionSplitter()  { return false; }

    virtual YWidget *createPatternSelector( YWidget *parent, YWidgetOpt & opt );

    virtual bool        hasPatternSelector() { return false; }


    virtual YWidget *createSimplePatchSelector( YWidget *parent, YWidgetOpt & opt );

    virtual bool        hasSimplePatchSelector() { return false; }


    virtual YWidget *createWizard( YWidget *parent, YWidgetOpt & opt,
                                   const YCPValue & backButtonId,       const YCPString & backButtonLabel,
                                   const YCPValue & abortButtonId,      const YCPString & abortButtonLabel,
                                   const YCPValue & nextButtonId,       const YCPString & nextButtonLabel  );

    virtual bool        hasWizard() { return false; }


    virtual YCPValue setLanguage( const YCPTerm & term );


    virtual YCPValue setConsoleFont( const YCPString & console_magic,
                                     const YCPString & font,
                                     const YCPString & screen_map,
                                     const YCPString & unicode_map,
                                     const YCPString & encoding );

    virtual YCPValue setKeyboard();


    virtual int runInTerminal( const YCPString & module );      

    virtual int  getDisplayWidth()              { return -1; }
    virtual int  getDisplayHeight()             { return -1; }
    virtual int  getDisplayDepth()              { return -1; }
    virtual long getDisplayColors()             { return -1; }
    virtual int  getDefaultWidth()              { return -1; }
    virtual int  getDefaultHeight()             { return -1; }
    virtual bool textMode()                     { return true; }
    virtual bool hasImageSupport()              { return false; }
    virtual bool hasLocalImageSupport()         { return true;  }
    virtual bool hasAnimationSupport()          { return false; }
    virtual bool hasIconSupport()               { return false; }
    virtual bool hasFullUtf8Support()           { return false; }
    virtual bool richTextSupportsTable()        { return false; }
    virtual bool leftHandedMouse()              { return false; }

    virtual void busyCursor();

    virtual void normalCursor();

    virtual void redrawScreen();

    virtual void makeScreenShot( string filename );

    virtual void beep();

    virtual YCPValue runPkgSelection( YWidget * /*packageSelector*/ ) { return YCPVoid(); }


    virtual YCPValue askForExistingDirectory( const YCPString & startDir,
                                              const YCPString & headline ) = 0;

    virtual YCPValue askForExistingFile( const YCPString & startWith,
                                         const YCPString & filter,
                                         const YCPString & headline ) = 0;

    virtual YCPValue askForSaveFileName( const YCPString & startWith,
                                         const YCPString & filter,
                                         const YCPString & headline ) = 0;



    YCPValue callback           ( const YCPValue & value );

    YCPValue evaluateLocale( const YCPLocale & );

    void recordMacro( string filename );

    void stopRecordMacro();

    void playMacro( string filename );

    bool recordingMacro()       { return macroRecorder != 0;    }

    bool playingMacro()         { return macroPlayer != 0;      }


protected:
    void terminateUIThread();


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

    void signalUIThread();

    bool waitForUIThread();

    void signalYCPThread();

    bool waitForYCPThread();

    YEvent * filterInvalidEvents( YEvent * event );

    YCPValue doUserInput( const char *  builtin_name,
                          long          timeout_millisec,
                          bool          wait,
                          bool          detailed );


    YCPValue evaluateCallback( const YCPTerm & term, bool to_wfm );


    YRadioButtonGroup *findRadioButtonGroup( YContainerWidget *root, YWidget *w, bool *contains );


    YWidget *createReplacePoint( YWidget *parent, YWidgetOpt & opt,
                                 const YCPTerm & term, const YCPList & optList, int argnr,
                                 YRadioButtonGroup *rbg );


    YWidget *createEmpty( YWidget *parent, YWidgetOpt & opt,
                          const YCPTerm & term, const YCPList & optList, int argnr,
                          bool hstretchable, bool vstretchable );

    YWidget *createSpacing( YWidget *parent, YWidgetOpt & opt,
                            const YCPTerm & term, const YCPList & optList, int argnr,
                            bool horizontal, bool vertical );

    YWidget *createFrame( YWidget *parent, YWidgetOpt & opt,
                          const YCPTerm & term, const YCPList & optList, int argnr,
                          YRadioButtonGroup *rbg );
    YWidget *createCheckBoxFrame( YWidget *parent, YWidgetOpt & opt,
                                  const YCPTerm & term, const YCPList & optList, int argnr,
                                  YRadioButtonGroup *rbg );


    YWidget *createWeight( YWidget *parent, YWidgetOpt & opt,
                           const YCPTerm & term, const YCPList & optList, int argnr,
                           YRadioButtonGroup *rbg, YUIDimension dim );

    YWidget *createAlignment( YWidget *parent, YWidgetOpt & opt,
                              const YCPTerm & term, const YCPList & optList, int argnr,
                              YRadioButtonGroup *rbg,
                              YAlignmentType halign, YAlignmentType valign );

    YWidget *createMarginBox( YWidget * parent, YWidgetOpt & opt,
                              const YCPTerm & term, const YCPList & optList,
                              int argnr, YRadioButtonGroup * rbg );

    YWidget *createMinSize( YWidget * parent, YWidgetOpt & opt,
                            const YCPTerm & term, const YCPList & optList, int argnr,
                            YRadioButtonGroup * rbg,
                            bool hor, bool vert );

    YWidget *createSquash( YWidget *parent, YWidgetOpt & opt,
                           const YCPTerm & term, const YCPList & optList, int argnr,
                           YRadioButtonGroup *rbg, bool hsquash, bool vsquash );

    YWidget *createLBox( YWidget *parent, YWidgetOpt & opt,
                         const YCPTerm & term, const YCPList & optList, int argnr,
                         YRadioButtonGroup *rbg, YUIDimension dim );

    YWidget *createLabel( YWidget *parent, YWidgetOpt & opt,
                          const YCPTerm & term, const YCPList & optList, int argnr,
                          bool heading );

    YWidget *createDate( YWidget *parent, YWidgetOpt & opt,
                          const YCPTerm & term, const YCPList & optList, int argnr);

    YWidget *createTime( YWidget *parent, YWidgetOpt & opt,
                          const YCPTerm & term, const YCPList & optList, int argnr);

    YWidget *createRichText( YWidget *parent, YWidgetOpt & opt,
                             const YCPTerm & term, const YCPList & optList, int argnr );


    YWidget *createLogView( YWidget *parent, YWidgetOpt & opt,
                            const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createPushButton( YWidget *parent, YWidgetOpt & opt,
                               const YCPTerm & term, const YCPList & optList, int argnr,
                               bool isIconButton );

    YWidget *createMenuButton( YWidget *parent, YWidgetOpt & opt,
                               const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createCheckBox( YWidget *parent, YWidgetOpt & opt,
                             const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createRadioButton( YWidget *parent, YWidgetOpt & opt,
                                const YCPTerm & term, const YCPList & optList, int argnr,
                                YRadioButtonGroup *rbg );

    YWidget *createRadioButtonGroup( YWidget *parent, YWidgetOpt & opt,
                                     const YCPTerm & term, const YCPList & optList, int argnr,
                                     YRadioButtonGroup *rbg );

    YWidget *createTextEntry( YWidget *parent, YWidgetOpt & opt,
                              const YCPTerm & term, const YCPList & optList, int argnr,
                              bool password );

    YWidget *createMultiLineEdit( YWidget *parent, YWidgetOpt & opt,
                                  const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createSelectionBox( YWidget *parent, YWidgetOpt & opt,
                                 const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createMultiSelectionBox( YWidget *parent, YWidgetOpt & opt,
                                      const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createComboBox( YWidget *parent, YWidgetOpt & opt,
                             const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createTree( YWidget *parent, YWidgetOpt & opt,
                         const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createTable( YWidget *parent, YWidgetOpt & opt,
                          const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createProgressBar( YWidget *parent, YWidgetOpt & opt,
                                const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createImage( YWidget *parent, YWidgetOpt & opt,
                          const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createIntField( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                             const YCPList & optList, int argnr );

    YWidget *createPackageSelector( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                                    const YCPList & optList, int argnr );

    YWidget *createPkgSpecial( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                               const YCPList & optList, int argnr );

    YWidget *createWizard( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                           const YCPList & optList, int argnr );

    YWidget *createDummySpecialWidget( YWidget *parent, YWidgetOpt & opt,
                                       const YCPTerm & term, const YCPList & optList, int argnr );

    YWidget *createDownloadProgress( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                                     const YCPList & optList, int argnr );

    YWidget *createBarGraph( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                             const YCPList & optList, int argnr );

    YWidget *createColoredLabel( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                                 const YCPList & optList, int argnr );

    YWidget *createDumbTab( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                            const YCPList & optList, int argnr, YRadioButtonGroup * rbg );

    YWidget * createMultiProgressMeter( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                                        const YCPList & optList, int argnr, bool horizontal );
    YWidget *createSlider( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                           const YCPList & optList, int argnr );

    YWidget *createPartitionSplitter( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                                      const YCPList & optList, int argnr );

    YWidget *createPatternSelector( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                                    const YCPList & optList, int argnr );

    YWidget *createSimplePatchSelector( YWidget *parent, YWidgetOpt & opt, const YCPTerm & term,
                                        const YCPList & optList, int argnr );


    YCPValue getWidgetId( const YCPTerm & term, int *argnr );

    YCPList getWidgetOptions( const YCPTerm & term, int *argnr );

    void logUnknownOption( const YCPTerm & term, const YCPValue & option );

    void rejectAllOptions( const YCPTerm & term, const YCPList & optList );

    void registerDialog( YDialog * );

    void removeDialog();

    bool isSymbolOrId( const YCPValue & val ) const;


    void deleteMacroRecorder();

    void deleteMacroPlayer();

    void playNextMacroBlock();

    typedef vector<YDialog *> dialogstack_type;

    dialogstack_type dialogstack;

    long long id_counter;

    bool with_threads;

    pthread_t ui_thread;

    YUIBuiltinCallData _builtinCallData;

    int pipe_to_ui[2];

    int pipe_from_ui[2];

    bool terminate_ui_thread;

    string _moduleName;

    string _productName;

    YMacroRecorder *macroRecorder;

    YMacroPlayer *macroPlayer;

    deque<YCPValue> fakeUserInputQueue;

    YCPMap default_fkeys;

    bool _events_blocked;

    static bool _reverseLayout;

    Y2Component * _callback;


    static YUI * _yui;

};

#endif // YUI_h

---