libyui
 
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
YUI Class Referenceabstract

#include <YUI.h>

Collaboration diagram for YUI:
Collaboration graph
[legend]

Public Member Functions

virtual ~YUI ()
 
void shutdownThreads ()
 
virtual void blockEvents (bool block=true)
 
void unblockEvents ()
 
virtual bool eventsBlocked () const
 
virtual void deleteNotify (YWidget *widget)
 
void topmostConstructorHasFinished ()
 
bool runningWithThreads () const
 
void uiThreadMainLoop ()
 
YBuiltinCaller * builtinCaller () const
 
void setBuiltinCaller (YBuiltinCaller *caller)
 
virtual YEvent * runPkgSelection (YWidget *packageSelector)=0
 
YWidget * sendWidgetID (const std::string &id)
 

Static Public Member Functions

static YUI * ui ()
 
static YWidgetFactory * widgetFactory ()
 
static YOptionalWidgetFactory * optionalWidgetFactory ()
 
static YApplication * app ()
 
static YApplication * application ()
 
static YApplication * yApp ()
 
static void ensureUICreated ()
 

Protected Member Functions

 YUI (bool withThreads)
 
virtual YWidgetFactory * createWidgetFactory ()=0
 
virtual YOptionalWidgetFactory * createOptionalWidgetFactory ()=0
 
virtual YApplication * createApplication ()=0
 
virtual void idleLoop (int fd_ycp)=0
 
void terminateUIThread ()
 
void createUIThread ()
 
virtual void uiThreadDestructor ()
 
void signalUIThread ()
 
bool waitForUIThread ()
 
void signalYCPThread ()
 
bool waitForYCPThread ()
 
void setButtonOrderFromEnvironment ()
 

Protected Attributes

bool _withThreads
 
pthread_t _uiThread
 
YBuiltinCaller * _builtinCaller
 
int pipe_to_ui [2]
 
int pipe_from_ui [2]
 
bool _terminate_ui_thread
 
bool _eventsBlocked
 

Friends

class YUIFunction
 
class YUILoader
 
void * start_ui_thread (void *ui_int)
 

Detailed Description

Abstract base class of a libYUI user interface.

Constructor & Destructor Documentation

◆ YUI()

YUI::YUI ( bool withThreads)
protected

Constructor.

◆ ~YUI()

YUI::~YUI ( )
virtual

Destructor.

Member Function Documentation

◆ app()

YApplication * YUI::app ( )
static

Return the global YApplication object.

This will create the YApplication upon the first call and return a pointer to the one and only (singleton) YApplication upon each subsequent call. This may throw exceptions if the YApplication cannot be created.

◆ application()

static YApplication * YUI::application ( )
inlinestatic

Aliases for YUI::app()

◆ blockEvents()

virtual void YUI::blockEvents ( bool block = true)
inlinevirtual

Block (or unblock) events. If events are blocked, any event sent should be ignored until events are unblocked again.

This default implementation keeps track of a simple internal flag that can be queried with eventsBlocked(), so if you reimplement blockEvents(), be sure to reimplement eventsBlocked() as well.

◆ builtinCaller()

YBuiltinCaller * YUI::builtinCaller ( ) const
inline

Return the transparent inter-thread communication. This will return 0 until set from the outside.

◆ createApplication()

virtual YApplication * YUI::createApplication ( )
protectedpure virtual

Create the YApplication object that provides global methods.

Derived classes are required to implement this.

◆ createOptionalWidgetFactory()

virtual YOptionalWidgetFactory * YUI::createOptionalWidgetFactory ( )
protectedpure virtual

Create the widget factory that provides all the createXY() methods for optional ("special") widgets and the corresponding hasXYWidget() methods.

Derived classes are required to implement this.

◆ createUIThread()

void YUI::createUIThread ( )
protected

Creates and launches the ui thread.

◆ createWidgetFactory()

virtual YWidgetFactory * YUI::createWidgetFactory ( )
protectedpure virtual

Create the widget factory that provides all the createXY() methods for standard (mandatory, i.e. non-optional) widgets.

Derived classes are required to implement this.

◆ deleteNotify()

virtual void YUI::deleteNotify ( YWidget * widget)
inlinevirtual

Notification that a widget is being deleted. This is called from the YWidget destructor.

Derived classes can implement this for any clean-up actions such as deleting any events that might be pending for that widget.

◆ ensureUICreated()

void YUI::ensureUICreated ( )
static

Make sure there is a UI (with a UI plug-in) created.

If there is none yet, this will use all-default parameters to load a UI plug-in and create a UI (without threads).

◆ eventsBlocked()

virtual bool YUI::eventsBlocked ( ) const
inlinevirtual

Returns 'true' if events are currently blocked.

Reimplement this if you reimplement blockEvents().

◆ idleLoop()

virtual void YUI::idleLoop ( int fd_ycp)
protectedpure virtual

This virtual method is called when threads are activated in case the execution control is currently on the side of the module. This means that no UserInput() or PollInput() is pending. The module just does some work. The UI <-> module protocol is in the "UI waits for the next command" state. The UI can override this method when it wants to react to user input or other external events such as repaint requests from the X server.

'fd_ycp' file descriptor that should be used to determine when to leave the idle loop. As soon as it is readable, the loop must be left. In order to avoid polling you can combine it with other ui-specific fds and do a common select() call.

◆ optionalWidgetFactory()

YOptionalWidgetFactory * YUI::optionalWidgetFactory ( )
static

Return the widget factory that provides all the createXY() methods for optional ("special") widgets and the corresponding hasXYWidget() methods.

This will create the factory upon the first call and return a pointer to the one and only (singleton) factory upon each subsequent call. This may throw exceptions if the factory cannot be created.

◆ runningWithThreads()

bool YUI::runningWithThreads ( ) const
inline

Running with threads?

◆ runPkgSelection()

virtual YEvent * YUI::runPkgSelection ( YWidget * packageSelector)
pure virtual

UI-specific runPkgSelection method.

Derived classes are required to implement this.

The packageSelector's dialog will take care of the event and delete it when appropriate. The returned pointer is valid until the next call to YDialog::userInput(), YDialog::pollInput(), or YUI::runPkgSelection() or until the dialog with the packageSelector is destroyed.

◆ sendWidgetID()

YWidget * YUI::sendWidgetID ( const std::string & id)

Send a widget ID. This implementation simply sets the keyboard focus to that widget. If there is no widget with that ID, this will throw a YUIWidgetNotFoundException. This function returns the widget that was found in case the caller wants to do more with it than just set the keyboard focus to it.

◆ setBuiltinCaller()

void YUI::setBuiltinCaller ( YBuiltinCaller * caller)
inline

Set the transparent inter-thread communication. Built-ins are only really called if there is a valid YBuiltinCaller set.

◆ setButtonOrderFromEnvironment()

void YUI::setButtonOrderFromEnvironment ( )
protected

Set the button order (in YButtonBox widgets) from environment variables: 

$Y2_BUTTON_ORDER="KDE"
$Y2_BUTTON_ORDER="Gnome"

(all case insensitive)

◆ shutdownThreads()

void YUI::shutdownThreads ( )

Shut down multithreading. This needs to be called before the destructor if the UI was created with threads. If the UI was created without threads, this does nothing.

◆ signalUIThread()

void YUI::signalUIThread ( )
protected

Signals the ui thread by sending one byte through the pipe to it.

◆ signalYCPThread()

void YUI::signalYCPThread ( )
protected

Signals the ycp thread by sending one byte through the pipe to it.

◆ terminateUIThread()

void YUI::terminateUIThread ( )
protected

Tells the ui thread that it should terminate and waits until it does so.

◆ topmostConstructorHasFinished()

void YUI::topmostConstructorHasFinished ( )

Must be called after the constructor of the Qt/NCurses ui is ready. Starts the ui thread.

◆ ui()

YUI * YUI::ui ( )
static

Access the global UI.

◆ uiThreadDestructor()

void YUI::uiThreadDestructor ( )
protectedvirtual

Destructor for the UI thread. This will be called as the last thing the UI thread does.

Derived classes can overwrite this. In most cases it makes sense to call this base class method in the new implementation.

◆ uiThreadMainLoop()

void YUI::uiThreadMainLoop ( )

This method implements the UI thread in case it is existing. The loop consists of calling idleLoop, getting the next command from the YCPUIComponent, evaluating it, which possibly invovles calling userInput() or pollInput() and writes the answer back to the other thread where the request came from.

◆ unblockEvents()

void YUI::unblockEvents ( )
inline

Unblock events previously blocked. This is just an alias for blockEvents( false) for better readability.

Note: This method is intentionally not virtual.

◆ waitForUIThread()

bool YUI::waitForUIThread ( )
protected

Waits for the ui thread to send one byte through the pipe to the ycp thread and reads this byte from the pipe.

◆ waitForYCPThread()

bool YUI::waitForYCPThread ( )
protected

Waits for the ycp thread to send one byte through the pipe to the ycp thread and reads this byte from the pipe.

◆ widgetFactory()

YWidgetFactory * YUI::widgetFactory ( )
static

Return the widget factory that provides all the createXY() methods for standard (mandatory, i.e. non-optional) widgets.

This will create the factory upon the first call and return a pointer to the one and only (singleton) factory upon each subsequent call. This may throw exceptions if the factory cannot be created.

Member Data Documentation

◆ _builtinCaller

YBuiltinCaller* YUI::_builtinCaller
protected

Inter-thread communication between the YCP thread and the UI thread: The YCP thread supplies data here and signals the UI thread, the UI thread picks up the data, executes the function, puts the result here and signals the YCP thread that waits until the result is available.

◆ _eventsBlocked

bool YUI::_eventsBlocked
protected

Flag that keeps track of blocked events. Never query this directly, use eventsBlocked() instead.

◆ _terminate_ui_thread

bool YUI::_terminate_ui_thread
protected

This is a flag that signals the ui thread that it should terminate. This is done by setting the flag to true. The ui thread replies by setting the flag back to false directly after terminating itself.

◆ _uiThread

pthread_t YUI::_uiThread
protected

Handle to the ui thread.

◆ _withThreads

bool YUI::_withThreads
protected

true if a seperate UI thread is created

◆ pipe_from_ui

int YUI::pipe_from_ui[2]
protected

Used to synchronize data transfer with the ui thread. It stores a pair of file descriptors of a pipe. For each YCP value we get from the ui thread, we read one aribrary byte from here.

◆ pipe_to_ui

int YUI::pipe_to_ui[2]
protected

Used to synchronize data transfer with the ui thread. It stores a pair of file descriptors of a pipe. For each YCP value we send to the ui thread, we write one aribrary byte here.

The documentation for this class was generated from the following files: