The QLinuxFbScreen class implements a screen driver for the Linux framebuffer. More...

#include <qscreenlinuxfb_qws.h>

Inheritance diagram for QLinuxFbScreen:

Public Types
enum	DriverTypes { GenericDriver, EInk8Track }
	This enum describes the driver type. More...

Public Types inherited from QScreen
enum	ClassId { LinuxFBClass, TransformedClass, VNCClass, MultiClass, VFbClass, DirectFBClass, SvgalibClass, ProxyClass, GLClass, IntfbClass, CustomClass = 1024 }
	This enum defines the class identifiers for the known screen subclasses. More...

enum	PixelType { NormalPixel, BGRPixel }
	This enum describes the pixel storage format of the screen, i. More...

Public Slots
QRegion	doRedraw ()

Public Slots inherited from QObject
void	deleteLater ()
	Schedules this object for deletion. More...

Public Functions
virtual void	blank (bool on)
	Reimplemented Function More...

virtual uchar *	cache (int)
	Requests the specified amount of offscreen graphics card memory from the memory manager, and returns a pointer to the data within the framebuffer (or 0 if there is no free memory). More...

virtual bool	connect (const QString &displaySpec)
	This is called by Qt for Embedded Linux clients to map in the framebuffer. More...

virtual void	disconnect ()
	This unmaps the framebuffer. More...

virtual bool	initDevice ()
	This is called by the Qt for Embedded Linux server at startup time. More...

	QLinuxFbScreen (uchar *d, int w, int h, int lstep, QImage::Format screenFormat)

	QLinuxFbScreen (int display_id)
	Constructs a QLinuxFbScreen object. More...

virtual void	restore ()
	This is called when the virtual console is switched back to Qt for Embedded Linux and restores the palette. More...

virtual void	save ()
	This doesn't do anything; accelerated drivers may wish to reimplement it to save graphics cards registers. More...

virtual void	set (unsigned int, unsigned int, unsigned int, unsigned int)
	Sets the specified color index to the specified RGB value, (red, green, blue), when in paletted graphics modes. More...

virtual void	setDirty (const QRect &)
	Reimplemented Function More...

void	setFormat (QImage::Format format)

void	setGeometry (QRect rect)

virtual void	setMode (int, int, int)
	Sets the framebuffer to a new resolution and bit depth. More...

virtual int	sharedRamSize (void *)

virtual void	shutdownDevice ()
	This is called by the Qt for Embedded Linux server when it shuts down, and should be inherited if you need to do any card-specific cleanup. More...

virtual void	uncache (uchar *)
	Deletes the specified memoryBlock allocated from the graphics card memory. More...

virtual bool	useOffscreen ()

virtual	~QLinuxFbScreen ()
	Destroys this QLinuxFbScreen object. More...

Public Functions inherited from QFbScreen
virtual void	addWindow (QFbWindow *surface)

virtual int	depth () const
	Reimplement in subclass to return current depth of the screen. More...

virtual QImage::Format	format () const
	Reimplement in subclass to return the image format which corresponds to the screen format. More...

virtual QRect	geometry () const
	Reimplement in subclass to return the pixel geometry of the screen. More...

QImage *	image () const

virtual void	lower (QPlatformWindow *surface)

QPaintDevice *	paintDevice () const

virtual QSize	physicalSize () const
	Reimplement this function in subclass to return the physical size of the screen. More...

	QFbScreen ()

virtual void	raise (QPlatformWindow *surface)

virtual void	removeWindow (QFbWindow *surface)

virtual void	setDepth (int depth)

virtual void	setPhysicalSize (QSize size)

virtual QWidget *	topLevelAt (const QPoint &p) const
	Return the given top level widget for a given position. More...

	~QFbScreen ()

Public Functions inherited from QPlatformScreen
virtual QRect	availableGeometry () const
	Reimplement in subclass to return the pixel geometry of the available space This normally is the desktop screen minus the task manager, global menubar etc. More...

virtual	~QPlatformScreen ()

Public Functions inherited from QObject
bool	blockSignals (bool b)
	If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...

const QObjectList &	children () const
	Returns a list of child objects. More...

bool	connect (const QObject sender, const char signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const

bool	disconnect (const char signal=0, const QObject receiver=0, const char *member=0)

bool	disconnect (const QObject receiver, const char member=0)

void	dumpObjectInfo ()
	Dumps information about signal connections, etc. More...

void	dumpObjectTree ()
	Dumps a tree of children to the debug output. More...

QList< QByteArray >	dynamicPropertyNames () const
	Returns the names of all properties that were dynamically added to the object using setProperty(). More...

virtual bool	event (QEvent *)
	This virtual function receives events to an object and should return true if the event e was recognized and processed. More...

virtual bool	eventFilter (QObject , QEvent )
	Filters events if this object has been installed as an event filter for the watched object. More...

template<typename T >
T	findChild (const QString &aName=QString()) const
	Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...

template<typename T >
QList< T >	findChildren (const QString &aName=QString()) const
	Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...

template<typename T >
QList< T >	findChildren (const QRegExp &re) const

bool	inherits (const char *classname) const
	Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...

void	installEventFilter (QObject *)
	Installs an event filter filterObj on this object. More...

bool	isWidgetType () const
	Returns true if the object is a widget; otherwise returns false. More...

void	killTimer (int id)
	Kills the timer with timer identifier, id. More...

virtual const QMetaObject *	metaObject () const
	Returns a pointer to the meta-object of this object. More...

void	moveToThread (QThread *thread)
	Changes the thread affinity for this object and its children. More...

QString	objectName () const

QObject *	parent () const
	Returns a pointer to the parent object. More...

QVariant	property (const char *name) const
	Returns the value of the object's name property. More...

Q_INVOKABLE	QObject (QObject *parent=0)
	Constructs an object with parent object parent. More...

void	removeEventFilter (QObject *)
	Removes an event filter object obj from this object. More...

void	setObjectName (const QString &name)

void	setParent (QObject *)
	Makes the object a child of parent. More...

bool	setProperty (const char *name, const QVariant &value)
	Sets the value of the object's name property to value. More...

void	setUserData (uint id, QObjectUserData *data)

bool	signalsBlocked () const
	Returns true if signals are blocked; otherwise returns false. More...

int	startTimer (int interval)
	Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...

QThread *	thread () const
	Returns the thread in which the object lives. More...

QObjectUserData *	userData (uint id) const

virtual	~QObject ()
	Destroys the object, deleting all its child objects. More...

Public Functions inherited from QScreen
virtual int	alloc (unsigned int, unsigned int, unsigned int)
	Returns the index in the screen's palette which is the closest match to the given RGB value (red, green, blue). More...

uchar *	base () const
	Returns a pointer to the beginning of the framebuffer. More...

virtual void	blit (const QImage &img, const QPoint &topLeft, const QRegion &region)
	Copies the given region in the given image to the point specified by topLeft using device coordinates. More...

void	blit (QWSWindow *bs, const QRegion &clip)

ClassId	classId () const
	Returns the class identifier for the screen object. More...

QRgb *	clut ()
	Returns a pointer to the screen's color lookup table (i. More...

int	colorCount ()
	Returns the number of entries in the screen's color lookup table (i. More...

virtual QWSWindowSurface *	createSurface (QWidget *widget) const
	Creates and returns a new window surface for the given widget. More...

virtual QWSWindowSurface *	createSurface (const QString &key) const
	Creates and returns a new window surface matching the given key. More...

int	depth () const
	Returns the depth of the framebuffer, in bits per pixel. More...

int	deviceHeight () const
	Returns the full height of the framebuffer device in pixels. More...

int	deviceWidth () const
	Returns the physical width of the framebuffer device in pixels. More...

virtual void	exposeRegion (QRegion r, int changing)
	This function is called by the Qt for Embedded Linux server whenever a screen update is required. More...

QGraphicsSystem *	graphicsSystem () const

virtual void	haltUpdates ()

int	height () const
	Returns the logical height of the framebuffer in pixels. More...

virtual bool	isInterlaced () const
	Returns true if the display is interlaced (i. More...

virtual bool	isTransformed () const
	Returns true if the screen is transformed (for instance, rotated 90 degrees); otherwise returns false. More...

int	linestep () const
	Returns the length of each scanline of the framebuffer in bytes. More...

virtual QSize	mapFromDevice (const QSize &) const
	Maps the given size from the framebuffer coordinate system to the coordinate space used by the application. More...

virtual QPoint	mapFromDevice (const QPoint &, const QSize &) const
	Maps the given point from the framebuffer coordinate system to the coordinate space used by the application, passing the device's screenSize as argument. More...

virtual QRect	mapFromDevice (const QRect &, const QSize &) const
	Maps the given rectangle from the framebuffer coordinate system to the coordinate space used by the application, passing the device's screenSize as argument. More...

virtual QImage	mapFromDevice (const QImage &) const
	Maps the given image from the framebuffer coordinate system to the coordinate space used by the application. More...

virtual QRegion	mapFromDevice (const QRegion &, const QSize &) const
	Maps the given region from the framebuffer coordinate system to the coordinate space used by the application, passing the device's screenSize as argument. More...

virtual QSize	mapToDevice (const QSize &) const
	Maps the given size from the coordinate space used by the application to the framebuffer coordinate system. More...

virtual QPoint	mapToDevice (const QPoint &, const QSize &) const
	Maps the given point from the coordinate space used by the application to the framebuffer coordinate system, passing the device's screenSize as argument. More...

virtual QRect	mapToDevice (const QRect &, const QSize &) const
	Maps the given rectangle from the coordinate space used by the application to the framebuffer coordinate system, passing the device's screenSize as argument. More...

virtual QImage	mapToDevice (const QImage &) const
	Maps the given image from the coordinate space used by the application to the framebuffer coordinate system. More...

virtual QRegion	mapToDevice (const QRegion &, const QSize &) const
	Maps the given region from the coordinate space used by the application to the framebuffer coordinate system, passing the device's screenSize as argument. More...

virtual int	memoryNeeded (const QString &)

QT_DEPRECATED int	numCols ()

QPoint	offset () const
	Returns the logical offset of the screen, i. More...

virtual bool	onCard (const unsigned char *) const
	Returns true if the specified buffer is within the graphics card's memory; otherwise returns false (i.e. More...

virtual bool	onCard (const unsigned char *, ulong &out_offset) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.If the specified buffer is within the graphics card's memory, this function stores the offset from the start of graphics card memory (in bytes), in the location specified by the offset parameter. More...

int	physicalHeight () const
	Returns the physical height of the screen in millimeters. More...

int	physicalWidth () const
	Returns the physical width of the screen in millimeters. More...

QImage::Format	pixelFormat () const
	Returns the pixel format of the screen, or `QImage::Format_Invalid` if the pixel format is not a supported image format. More...

PixelType	pixelType () const
	Returns the pixel storage format of the screen. More...

QPixmapDataFactory *	pixmapDataFactory () const

virtual int	pixmapDepth () const
	Returns the preferred depth for pixmaps, in bits per pixel. More...

virtual int	pixmapLinestepAlignment ()
	Returns the value (in bits) to which individual scanlines of pixmaps held in the graphics card's memory, should be aligned. More...

virtual int	pixmapOffsetAlignment ()
	Returns the value (in bits) to which the start address of pixmaps held in the graphics card's memory, should be aligned. More...

	QScreen (int display_id, ClassId classId)
	Constructs a new screen driver. More...

	QScreen (int display_id)
	Constructs a new screen driver. More...

virtual QRegion	region () const
	Returns the region covered by this screen driver. More...

virtual void	resumeUpdates ()

int	screenSize () const
	Returns the size of the screen in bytes. More...

void	setOffset (const QPoint &p)

virtual void	solidFill (const QColor &color, const QRegion &region)
	Fills the given region of the screen with the specified color. More...

int	subScreenIndexAt (const QPoint &p) const
	Returns the index of the subscreen at the given position; returns -1 if no screen is found. More...

virtual QList< QScreen * >	subScreens () const

virtual bool	supportsDepth (int) const
	Returns true if the screen supports the specified color depth; otherwise returns false. More...

int	totalSize () const
	Returns the size of the available graphics card memory (including the screen) in bytes. More...

virtual int	transformOrientation () const
	Returns the current rotation as an integer value. More...

int	width () const
	Returns the logical width of the framebuffer in pixels. More...

virtual	~QScreen ()
	Destroys this screen driver. More...

Public Variables
QLinuxFb_Shared *	shared

Protected Functions
void	deleteEntry (uchar *)
	Deletes the specified memoryBlock allocated from the graphics card memory. More...

virtual void	fixupScreenInfo (fb_fix_screeninfo &finfo, fb_var_screeninfo &vinfo)
	Adjust the values returned by the framebuffer driver, to work around driver bugs or nonstandard behavior in certain drivers. More...

Protected Functions inherited from QObject
virtual void	childEvent (QChildEvent *)
	This event handler can be reimplemented in a subclass to receive child events. More...

virtual void	connectNotify (const char *signal)
	This virtual function is called when something has been connected to signal in this object. More...

virtual void	customEvent (QEvent *)
	This event handler can be reimplemented in a subclass to receive custom events. More...

virtual void	disconnectNotify (const char *signal)
	This virtual function is called when something has been disconnected from signal in this object. More...

	QObject (QObjectPrivate &dd, QObject *parent=0)

int	receivers (const char *signal) const
	Returns the number of receivers connected to the signal. More...

QObject *	sender () const
	Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...

int	senderSignalIndex () const

virtual void	timerEvent (QTimerEvent *)
	This event handler can be reimplemented in a subclass to receive timer events for the object. More...

Protected Functions inherited from QScreen
void	setGraphicsSystem (QGraphicsSystem *system)

void	setPixelFormat (QImage::Format format)
	Sets the screen's pixel format to format. More...

void	setPixmapDataFactory (QPixmapDataFactory *factory)

Static Protected Functions
static void	clearCache (QScreen *instance, int)
	Removes all entries from the cache for the specified screen instance and client identified by the given clientId. More...

Protected Variables
int	cacheStart

bool	canaccel

int	dataoffset

Protected Variables inherited from QFbScreen
QPlatformSoftwareCursor *	cursor

int	mDepth

QImage::Format	mFormat

QRect	mGeometry

QSize	mPhysicalSize

QImage *	mScreenImage

QTimer	redrawTimer

QRegion	repaintRegion

QList< QFbWindow * >	windowStack

Protected Variables inherited from QObject
QScopedPointer< QObjectData >	d_ptr

Protected Variables inherited from QScreen
int	d
	the pixel depth More...

uchar *	data
	points to the first visible pixel in the frame buffer. More...

int	dh
	the device height More...

int	displayId

int	dw
	the device width More...

QPoolEntry *	entries

int *	entryp

bool	grayscale
	the gray scale screen mode flag More...

int	h
	the logical height of the screen. More...

unsigned int *	lowest

int	lstep
	the number of bytes representing a line in the frame buffer. More...

int	mapsize
	the total number of bytes in the frame buffer More...

int	physHeight
	the physical height of the screen in millimeters. More...

int	physWidth
	the physical width of the screen in millimeters. More...

PixelType	pixeltype
	set to BGRPixel More...

QRgb	screenclut [256]
	the color table More...

int	screencols
	the number of entries in the color table More...

int	size
	the number of bytes in the visible region of the frame buffer More...

int	w
	the logical width of the screen. More...

Private Functions
void	createPalette (fb_cmap &cmap, fb_var_screeninfo &vinfo, fb_fix_screeninfo &finfo)

void	delete_entry (int)

void	insert_entry (int, int, int)

void	setPixelFormat (struct fb_var_screeninfo)

void	setupOffScreen ()

Properties
int	bytesPerLine

QPainter *	compositePainter

QLinuxFbScreenPrivate *	d_ptr

uchar *	data

QImage *	mFbScreenImage

Additional Inherited Members
Signals inherited from QObject
void	destroyed (QObject *=0)
	This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...

Static Public Functions inherited from QPlatformScreen
static QPlatformScreen *	platformScreenForWidget (const QWidget *widget)

Static Public Functions inherited from QObject
static bool	connect (const QObject sender, const char signal, const QObject receiver, const char member, Qt::ConnectionType=Qt::AutoConnection)
	Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...

static bool	connect (const QObject sender, const QMetaMethod &signal, const QObject receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)

static bool	disconnect (const QObject sender, const char signal, const QObject receiver, const char member)
	Disconnects signal in object sender from method in object receiver. More...

static bool	disconnect (const QObject sender, const QMetaMethod &signal, const QObject receiver, const QMetaMethod &member)

static uint	registerUserData ()

static QString	tr (const char sourceText, const char comment=0, int n=-1)

static QString	trUtf8 (const char sourceText, const char comment=0, int n=-1)

Static Public Functions inherited from QScreen
static QScreen *	instance ()
	Returns a pointer to the application's QScreen instance. More...

Static Public Variables inherited from QObject
static const QMetaObject	staticMetaObject
	This variable stores the meta-object for the class. More...

Protected Slots inherited from QFbScreen
virtual QRegion	doRedraw ()

Static Protected Variables inherited from QObject
static const QMetaObject	staticQtMetaObject

Static Protected Variables inherited from QScreen
static ClearCacheFunc	clearCacheFunc = 0

Related Functions inherited from QObject
T	qFindChildqFindChildren (const QObject *obj, const QString &name)()

QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QString &name)()

QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QRegExp &regExp)()

T *	qobject_cast (QObject *object)

	QObjectList

void *	qt_find_obj_child (QObject parent, const char type, const QString &name)
	Returns a pointer to the object named name that inherits type and with a given parent. More...

Related Functions inherited from QScreen
void	setTransformation (int transformation, int screenNo)
	Here it is. More...

Detailed Description

The QLinuxFbScreen class implements a screen driver for the Linux framebuffer.

Warning: This function is not part of the public interface.

Note that this class is only available in Qt for Embedded Linux. Custom screen drivers can be added by subclassing the QScreenDriverPlugin class, using the QScreenDriverFactory class to dynamically load the driver into the application, but there should only be one screen object per application.

The QLinuxFbScreen class provides the cache() function allocating off-screen graphics memory, and the complementary uncache() function releasing the allocated memory. The latter function will first sync the graphics card to ensure the memory isn't still being used by a command in the graphics card FIFO queue. The deleteEntry() function deletes the given memory block without such synchronization. Given the screen instance and client id, the memory can also be released using the clearCache() function, but this should only be necessary if a client exits abnormally.

In addition, when in paletted graphics modes, the set() function provides the possibility of setting a specified color index to a given RGB value.

The QLinuxFbScreen class also acts as a factory for the unaccelerated screen cursor and the unaccelerated raster-based implementation of QPaintEngine (QRasterPaintEngine); accelerated drivers for Linux should derive from this class.

See also: QScreen, QScreenDriverPlugin, {Running Applications}

Definition at line 80 of file qscreenlinuxfb_qws.h.

Enumerations

◆ DriverTypes

enum QLinuxFbScreen::DriverTypes

This enum describes the driver type.

GenericDriver Generic Linux framebuffer driver
EInk8Track e-Ink framebuffer driver using the 8Track chipset

Enumerator
GenericDriver
EInk8Track

Definition at line 91 of file qscreenlinuxfb_qws.h.

91 { GenericDriver, EInk8Track };

QLinuxFbScreen::EInk8Track

Definition: qscreenlinuxfb_qws.h:91

QLinuxFbScreen::GenericDriver

Definition: qscreenlinuxfb_qws.h:91

Constructors and Destructors

◆ QLinuxFbScreen() [1/2]

QLinuxFbScreen::QLinuxFbScreen ( int displayId )

explicit

Constructs a QLinuxFbScreen object.

The displayId argument identifies the Qt for Embedded Linux server to connect to.

Definition at line 264 of file qscreenlinuxfb_qws.cpp.

     : QScreen(display_id, LinuxFBClass), d_ptr(new QLinuxFbScreenPrivate)
 {
     canaccel=false;
     clearCacheFunc = &clearCache;
 #ifdef QT_QWS_CLIENTBLIT
     setSupportsBlitInClients(true);
 #endif
 }

◆ ~QLinuxFbScreen()

QLinuxFbScreen::~QLinuxFbScreen ( )

virtual

Destroys this QLinuxFbScreen object.

Definition at line 278 of file qscreenlinuxfb_qws.cpp.

 {
 #ifdef QT_NO_QWS_SIGNALHANDLER
     delete d_ptr;
 #endif
 }

◆ QLinuxFbScreen() [2/2]

QLinuxFbScreen::QLinuxFbScreen	(	uchar *	d,
		int	w,
		int	h,
		int	lstep,
		QImage::Format	screenFormat
	)

Definition at line 818 of file qlinuxfbintegration.cpp.

                                                  : compositePainter(0)
 {
     data = d;
     mGeometry = QRect(0,0,w,h);
     bytesPerLine = lstep;
     mFormat = screenFormat;
     mDepth = 16;
     mScreenImage = new QImage(mGeometry.width(), mGeometry.height(),
                               mFormat);
     mFbScreenImage = new QImage(data, mGeometry.width(), mGeometry.height(),
                               bytesPerLine, mFormat);
 #ifndef QT_NO_CURSOR
     cursor = new QPlatformSoftwareCursor(this);
 #endif
 }

Functions

◆ blank()

void QLinuxFbScreen::blank ( bool on )

virtual

Reimplemented Function

Reimplemented from QScreen.

Definition at line 1302 of file qscreenlinuxfb_qws.cpp.

Referenced by initDevice().

 {
     if (d_ptr->blank == on)
         return;
 
 #if defined(QT_QWS_IPAQ)
     if (on)
         system("apm -suspend");
 #else
     if (d_ptr->fd == -1)
         return;
 // Some old kernel versions don't have this.  These defines should go
 // away eventually
 #if defined(FBIOBLANK)
 #if defined(VESA_POWERDOWN) && defined(VESA_NO_BLANKING)
     ioctl(d_ptr->fd, FBIOBLANK, on ? VESA_POWERDOWN : VESA_NO_BLANKING);
 #else
     ioctl(d_ptr->fd, FBIOBLANK, on ? 1 : 0);
 #endif
 #endif
 #endif
 
     d_ptr->blank = on;
 }

◆ cache()

uchar * QLinuxFbScreen::cache ( int amount )

virtual

Requests the specified amount of offscreen graphics card memory from the memory manager, and returns a pointer to the data within the framebuffer (or 0 if there is no free memory).

Note that the display is locked while memory is allocated in order to preserve the memory pool's integrity.

Use the QScreen::onCard() function to retrieve an offset (in bytes) from the start of graphics card memory for the returned pointer.

See also: uncache(), clearCache(), deleteEntry()

Reimplemented from QScreen.

Definition at line 915 of file qscreenlinuxfb_qws.cpp.

 {
     if (!canaccel || entryp == 0)
         return 0;
 
     qt_fbdpy->grab();
 
     int startp = cacheStart + (*entryp+1) * sizeof(QPoolEntry);
     if (startp >= (int)*lowest) {
         // We don't have room for another cache QPoolEntry.
 #ifdef DEBUG_CACHE
         qDebug("No room for pool entry in VRAM");
 #endif
         qt_fbdpy->ungrab();
         return 0;
     }
 
     int align = pixmapOffsetAlignment();
 
     if (*entryp > 1) {
         // Try to find a gap in the allocated blocks.
         for (int loopc = 0; loopc < *entryp-1; loopc++) {
             int freestart = entries[loopc+1].end;
             int freeend = entries[loopc].start;
             if (freestart != freeend) {
                 while (freestart % align) {
                     freestart++;
                 }
                 int len=freeend-freestart;
                 if (len >= amount) {
                     insert_entry(loopc+1, freestart, freestart+amount);
                     qt_fbdpy->ungrab();
                     return data+freestart;
                 }
             }
         }
     }
 
     // No free blocks in already-taken memory; get some more
     // if we can
     int newlowest = (*lowest)-amount;
     if (newlowest % align) {
         newlowest -= align;
         while (newlowest % align) {
             newlowest++;
         }
     }
     if (startp >= newlowest) {
         qt_fbdpy->ungrab();
 #ifdef DEBUG_CACHE
         qDebug("No VRAM available for %d bytes", amount);
 #endif
         return 0;
     }
     insert_entry(*entryp, newlowest, *lowest);
     qt_fbdpy->ungrab();
 
     return data + newlowest;
 }

◆ clearCache()

void QLinuxFbScreen::clearCache	(	QScreen *	instance,
		int	clientId
	)

staticprotected

Removes all entries from the cache for the specified screen instance and client identified by the given clientId.

Calling this function should only be necessary if a client exits abnormally.

See also: cache(), uncache(), deleteEntry()

Definition at line 1040 of file qscreenlinuxfb_qws.cpp.

Referenced by QLinuxFbScreen().

 {
     QLinuxFbScreen *screen = (QLinuxFbScreen *)instance;
     if (!screen->canaccel || !screen->entryp)
         return;
     qt_fbdpy->grab();
     for (int loopc = 0; loopc < *(screen->entryp); loopc++) {
         if (screen->entries[loopc].clientId == clientId) {
             screen->delete_entry(loopc);
             loopc--;
         }
     }
     qt_fbdpy->ungrab();
 }

◆ connect()

bool QLinuxFbScreen::connect ( const QString & displaySpec )

virtual

This is called by Qt for Embedded Linux clients to map in the framebuffer.

Reimplemented Function

It should be reimplemented by accelerated drivers to map in graphics card registers; those drivers should then call this function in order to set up offscreen memory management. The device is specified in displaySpec; e.g. "/dev/fb".

See also: disconnect()

Implements QScreen.

Definition at line 300 of file qscreenlinuxfb_qws.cpp.

Referenced by setMode().

 {
     d_ptr->displaySpec = displaySpec;
 
     const QStringList args = displaySpec.split(QLatin1Char(':'));
 
     if (args.contains(QLatin1String("nographicsmodeswitch")))
         d_ptr->doGraphicsMode = false;
 
 #ifdef QT_QWS_DEPTH_GENERIC
     if (args.contains(QLatin1String("genericcolors")))
         d_ptr->doGenericColors = true;
 #endif
 
     QRegExp ttyRegExp(QLatin1String("tty=(.*)"));
     if (args.indexOf(ttyRegExp) != -1)
         d_ptr->ttyDevice = ttyRegExp.cap(1);
 
 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
 #ifndef QT_QWS_FRAMEBUFFER_LITTLE_ENDIAN
     if (args.contains(QLatin1String("littleendian")))
 #endif
         QScreen::setFrameBufferLittleEndian(true);
 #endif
 
     QString dev = QLatin1String("/dev/fb0");
     foreach(QString d, args) {
     if (d.startsWith(QLatin1Char('/'))) {
         dev = d;
         break;
     }
     }
 
     if (access(dev.toLatin1().constData(), R_OK|W_OK) == 0)
         d_ptr->fd = QT_OPEN(dev.toLatin1().constData(), O_RDWR);
     if (d_ptr->fd == -1) {
         if (QApplication::type() == QApplication::GuiServer) {
             perror("QScreenLinuxFb::connect");
             qCritical("Error opening framebuffer device %s", qPrintable(dev));
             return false;
         }
         if (access(dev.toLatin1().constData(), R_OK) == 0)
             d_ptr->fd = QT_OPEN(dev.toLatin1().constData(), O_RDONLY);
     }
 
     ::fb_fix_screeninfo finfo;
     ::fb_var_screeninfo vinfo;
     //#######################
     // Shut up Valgrind
     memset(&vinfo, 0, sizeof(vinfo));
     memset(&finfo, 0, sizeof(finfo));
     //#######################
 
     /* Get fixed screen information */
     if (d_ptr->fd != -1 && ioctl(d_ptr->fd, FBIOGET_FSCREENINFO, &finfo)) {
         perror("QLinuxFbScreen::connect");
         qWarning("Error reading fixed information");
         return false;
     }
 
     d_ptr->driverType = strcmp(finfo.id, "8TRACKFB") ? GenericDriver : EInk8Track;
 
     if (finfo.type == FB_TYPE_VGA_PLANES) {
         qWarning("VGA16 video mode not supported");
         return false;
     }
 
     /* Get variable screen information */
     if (d_ptr->fd != -1 && ioctl(d_ptr->fd, FBIOGET_VSCREENINFO, &vinfo)) {
         perror("QLinuxFbScreen::connect");
         qWarning("Error reading variable information");
         return false;
     }
 
     fixupScreenInfo(finfo, vinfo);
 
     grayscale = vinfo.grayscale;
     d = vinfo.bits_per_pixel;
     if (d == 24) {
         d = vinfo.red.length + vinfo.green.length + vinfo.blue.length;
         if (d <= 0)
             d = 24; // reset if color component lengths are not reported
     } else if (d == 16) {
         d = vinfo.red.length + vinfo.green.length + vinfo.blue.length;
         if (d <= 0)
             d = 16;
     }
     lstep = finfo.line_length;
 
     int xoff = vinfo.xoffset;
     int yoff = vinfo.yoffset;
     const char* qwssize;
     if((qwssize=::getenv("QWS_SIZE")) && sscanf(qwssize,"%dx%d",&w,&h)==2) {
         if (d_ptr->fd != -1) {
             if ((uint)w > vinfo.xres) w = vinfo.xres;
             if ((uint)h > vinfo.yres) h = vinfo.yres;
         }
         dw=w;
         dh=h;
         int xxoff, yyoff;
         if (sscanf(qwssize, "%*dx%*d+%d+%d", &xxoff, &yyoff) == 2) {
             if (xxoff < 0 || xxoff + w > (int)vinfo.xres)
                 xxoff = vinfo.xres - w;
             if (yyoff < 0 || yyoff + h > (int)vinfo.yres)
                 yyoff = vinfo.yres - h;
             xoff += xxoff;
             yoff += yyoff;
         } else {
             xoff += (vinfo.xres - w)/2;
             yoff += (vinfo.yres - h)/2;
         }
     } else {
         dw=w=vinfo.xres;
         dh=h=vinfo.yres;
     }
 
     if (w == 0 || h == 0) {
         qWarning("QScreenLinuxFb::connect(): Unable to find screen geometry, "
                  "will use 320x240.");
         dw = w = 320;
         dh = h = 240;
     }
 
     setPixelFormat(vinfo);
 
     // Handle display physical size spec.
     QStringList displayArgs = displaySpec.split(QLatin1Char(':'));
     QRegExp mmWidthRx(QLatin1String("mmWidth=?(\\d+)"));
     int dimIdxW = displayArgs.indexOf(mmWidthRx);
     QRegExp mmHeightRx(QLatin1String("mmHeight=?(\\d+)"));
     int dimIdxH = displayArgs.indexOf(mmHeightRx);
     if (dimIdxW >= 0) {
         mmWidthRx.exactMatch(displayArgs.at(dimIdxW));
         physWidth = mmWidthRx.cap(1).toInt();
         if (dimIdxH < 0)
             physHeight = dh*physWidth/dw;
     }
     if (dimIdxH >= 0) {
         mmHeightRx.exactMatch(displayArgs.at(dimIdxH));
         physHeight = mmHeightRx.cap(1).toInt();
         if (dimIdxW < 0)
             physWidth = dw*physHeight/dh;
     }
     if (dimIdxW < 0 && dimIdxH < 0) {
         if (vinfo.width != 0 && vinfo.height != 0
             && vinfo.width != UINT_MAX && vinfo.height != UINT_MAX) {
             physWidth = vinfo.width;
             physHeight = vinfo.height;
         } else {
             const int dpi = 72;
             physWidth = qRound(dw * 25.4 / dpi);
             physHeight = qRound(dh * 25.4 / dpi);
         }
     }
 
     dataoffset = yoff * lstep + xoff * d / 8;
     //qDebug("Using %dx%dx%d screen",w,h,d);
 
     /* Figure out the size of the screen in bytes */
     size = h * lstep;
 
     mapsize = finfo.smem_len;
 
     data = (unsigned char *)-1;
     if (d_ptr->fd != -1)
         data = (unsigned char *)mmap(0, mapsize, PROT_READ | PROT_WRITE,
                                      MAP_SHARED, d_ptr->fd, 0);
 
     if ((long)data == -1) {
         if (QApplication::type() == QApplication::GuiServer) {
             perror("QLinuxFbScreen::connect");
             qWarning("Error: failed to map framebuffer device to memory.");
             return false;
         }
         data = 0;
     } else {
         data += dataoffset;
     }
 
     canaccel = useOffscreen();
     if(canaccel)
         setupOffScreen();
 
     // Now read in palette
     if((vinfo.bits_per_pixel==8) || (vinfo.bits_per_pixel==4)) {
         screencols= (vinfo.bits_per_pixel==8) ? 256 : 16;
         int loopc;
         ::fb_cmap startcmap;
         startcmap.start=0;
         startcmap.len=screencols;
         startcmap.red=(unsigned short int *)
                  malloc(sizeof(unsigned short int)*screencols);
         startcmap.green=(unsigned short int *)
                    malloc(sizeof(unsigned short int)*screencols);
         startcmap.blue=(unsigned short int *)
                   malloc(sizeof(unsigned short int)*screencols);
         startcmap.transp=(unsigned short int *)
                     malloc(sizeof(unsigned short int)*screencols);
         if (d_ptr->fd == -1 || ioctl(d_ptr->fd, FBIOGETCMAP, &startcmap)) {
             perror("QLinuxFbScreen::connect");
             qWarning("Error reading palette from framebuffer, using default palette");
             createPalette(startcmap, vinfo, finfo);
         }
         int bits_used = 0;
         for(loopc=0;loopc<screencols;loopc++) {
             screenclut[loopc]=qRgb(startcmap.red[loopc] >> 8,
                                    startcmap.green[loopc] >> 8,
                                    startcmap.blue[loopc] >> 8);
             bits_used |= startcmap.red[loopc]
                          | startcmap.green[loopc]
                          | startcmap.blue[loopc];
         }
         // WORKAROUND: Some framebuffer drivers only return 8 bit
         // color values, so we need to not bit shift them..
         if ((bits_used & 0x00ff) && !(bits_used & 0xff00)) {
             for(loopc=0;loopc<screencols;loopc++) {
                 screenclut[loopc] = qRgb(startcmap.red[loopc],
                                          startcmap.green[loopc],
                                          startcmap.blue[loopc]);
             }
             qWarning("8 bits cmap returned due to faulty FB driver, colors corrected");
         }
         free(startcmap.red);
         free(startcmap.green);
         free(startcmap.blue);
         free(startcmap.transp);
     } else {
         screencols=0;
     }
 
     return true;
 }

◆ createPalette()

void QLinuxFbScreen::createPalette	(	fb_cmap &	cmap,
		fb_var_screeninfo &	vinfo,
		fb_fix_screeninfo &	finfo
	)

private

Definition at line 554 of file qscreenlinuxfb_qws.cpp.

Referenced by connect(), and initDevice().

 {
     if((vinfo.bits_per_pixel==8) || (vinfo.bits_per_pixel==4)) {
         screencols= (vinfo.bits_per_pixel==8) ? 256 : 16;
         cmap.start=0;
         cmap.len=screencols;
         cmap.red=(unsigned short int *)
                  malloc(sizeof(unsigned short int)*screencols);
         cmap.green=(unsigned short int *)
                    malloc(sizeof(unsigned short int)*screencols);
         cmap.blue=(unsigned short int *)
                   malloc(sizeof(unsigned short int)*screencols);
         cmap.transp=(unsigned short int *)
                     malloc(sizeof(unsigned short int)*screencols);
 
         if (screencols==16) {
             if (finfo.type == FB_TYPE_PACKED_PIXELS) {
                 // We'll setup a grayscale cmap for 4bpp linear
                 int val = 0;
                 for (int idx = 0; idx < 16; ++idx, val += 17) {
                     cmap.red[idx] = (val<<8)|val;
                     cmap.green[idx] = (val<<8)|val;
                     cmap.blue[idx] = (val<<8)|val;
                     screenclut[idx]=qRgb(val, val, val);
                 }
             } else {
                 // Default 16 colour palette
                 // Green is now trolltech green so certain images look nicer
                 //                             black  d_gray l_gray white  red  green  blue cyan magenta yellow
                 unsigned char reds[16]   = { 0x00, 0x7F, 0xBF, 0xFF, 0xFF, 0xA2, 0x00, 0xFF, 0xFF, 0x00, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x82 };
                 unsigned char greens[16] = { 0x00, 0x7F, 0xBF, 0xFF, 0x00, 0xC5, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F };
                 unsigned char blues[16]  = { 0x00, 0x7F, 0xBF, 0xFF, 0x00, 0x11, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0x7F, 0x7F, 0x7F, 0x00, 0x00 };
 
                 for (int idx = 0; idx < 16; ++idx) {
                     cmap.red[idx] = ((reds[idx]) << 8)|reds[idx];
                     cmap.green[idx] = ((greens[idx]) << 8)|greens[idx];
                     cmap.blue[idx] = ((blues[idx]) << 8)|blues[idx];
                     cmap.transp[idx] = 0;
                     screenclut[idx]=qRgb(reds[idx], greens[idx], blues[idx]);
                 }
             }
         } else {
             if (grayscale) {
                 // Build grayscale palette
                 int i;
                 for(i=0;i<screencols;++i) {
                     int bval = screencols == 256 ? i : (i << 4);
                     ushort val = (bval << 8) | bval;
                     cmap.red[i] = val;
                     cmap.green[i] = val;
                     cmap.blue[i] = val;
                     cmap.transp[i] = 0;
                     screenclut[i] = qRgb(bval,bval,bval);
                 }
             } else {
                 // 6x6x6 216 color cube
                 int idx = 0;
                 for(int ir = 0x0; ir <= 0xff; ir+=0x33) {
                     for(int ig = 0x0; ig <= 0xff; ig+=0x33) {
                         for(int ib = 0x0; ib <= 0xff; ib+=0x33) {
                             cmap.red[idx] = (ir << 8)|ir;
                             cmap.green[idx] = (ig << 8)|ig;
                             cmap.blue[idx] = (ib << 8)|ib;
                             cmap.transp[idx] = 0;
                             screenclut[idx]=qRgb(ir, ig, ib);
                             ++idx;
                         }
                     }
                 }
                 // Fill in rest with 0
                 for (int loopc=0; loopc<40; ++loopc) {
                     screenclut[idx]=0;
                     ++idx;
                 }
                 screencols=idx;
             }
         }
     } else if(finfo.visual==FB_VISUAL_DIRECTCOLOR) {
         cmap.start=0;
         int rbits=0,gbits=0,bbits=0;
         switch (vinfo.bits_per_pixel) {
         case 8:
             rbits=vinfo.red.length;
             gbits=vinfo.green.length;
             bbits=vinfo.blue.length;
             if(rbits==0 && gbits==0 && bbits==0) {
                 // cyber2000 driver bug hack
                 rbits=3;
                 gbits=3;
                 bbits=2;
             }
             break;
         case 15:
             rbits=5;
             gbits=5;
             bbits=5;
             break;
         case 16:
             rbits=5;
             gbits=6;
             bbits=5;
             break;
         case 18:
         case 19:
             rbits=6;
             gbits=6;
             bbits=6;
             break;
         case 24: case 32:
             rbits=gbits=bbits=8;
             break;
         }
         screencols=cmap.len=1<<qMax(rbits,qMax(gbits,bbits));
         cmap.red=(unsigned short int *)
                  malloc(sizeof(unsigned short int)*256);
         cmap.green=(unsigned short int *)
                    malloc(sizeof(unsigned short int)*256);
         cmap.blue=(unsigned short int *)
                   malloc(sizeof(unsigned short int)*256);
         cmap.transp=(unsigned short int *)
                     malloc(sizeof(unsigned short int)*256);
         for(unsigned int i = 0x0; i < cmap.len; i++) {
             cmap.red[i] = i*65535/((1<<rbits)-1);
             cmap.green[i] = i*65535/((1<<gbits)-1);
             cmap.blue[i] = i*65535/((1<<bbits)-1);
             cmap.transp[i] = 0;
         }
     }
 }

◆ delete_entry()

void QLinuxFbScreen::delete_entry ( int pos )

private

Definition at line 836 of file qscreenlinuxfb_qws.cpp.

Referenced by clearCache(), and deleteEntry().

 {
     if (pos > *entryp || pos < 0) {
         qWarning("Attempt to delete odd pos! %d %d", pos, *entryp);
         return;
     }
 
 #ifdef DEBUG_CACHE
     qDebug("Remove entry: %d", pos);
 #endif
 
     QPoolEntry *qpe = &entries[pos];
     if (qpe->start <= *lowest) {
         // Lowest goes up again
         *lowest = entries[pos-1].start;
 #ifdef DEBUG_CACHE
         qDebug("   moved lowest to %d", *lowest);
 #endif
     }
 
     (*entryp)--;
     if (pos == *entryp)
         return;
 
     int size = (*entryp)-pos;
     memmove(&entries[pos], &entries[pos+1], size*sizeof(QPoolEntry));
 }

◆ deleteEntry()

void QLinuxFbScreen::deleteEntry ( uchar * memoryBlock )

protected

Deletes the specified memoryBlock allocated from the graphics card memory.

See also: uncache(), cache(), clearCache()

Definition at line 1010 of file qscreenlinuxfb_qws.cpp.

Referenced by uncache().

 {
     qt_fbdpy->grab();
     unsigned long pos=(unsigned long)c;
     pos-=((unsigned long)data);
     unsigned int hold=(*entryp);
     for(unsigned int loopc=1;loopc<hold;loopc++) {
         if (entries[loopc].start==pos) {
             if (entries[loopc].clientId == qws_client_id)
                 delete_entry(loopc);
             else
                 qWarning("Attempt to delete client id %d cache entry",
                          entries[loopc].clientId);
             qt_fbdpy->ungrab();
             return;
         }
     }
     qt_fbdpy->ungrab();
     qWarning("Attempt to delete unknown offset %ld",pos);
 }

◆ disconnect()

void QLinuxFbScreen::disconnect ( )

virtual

This unmaps the framebuffer.

Reimplemented Function

See also: connect()

Implements QScreen.

Definition at line 544 of file qscreenlinuxfb_qws.cpp.

Referenced by setMode().

 {
     data -= dataoffset;
     if (data)
         munmap((char*)data,mapsize);
     close(d_ptr->fd);
 }

◆ doRedraw

QRegion QLinuxFbScreen::doRedraw ( )

slot

Definition at line 863 of file qlinuxfbintegration.cpp.

 {
     QRegion touched;
     touched = QFbScreen::doRedraw();
 
     if (!compositePainter) {
         compositePainter = new QPainter(mFbScreenImage);
     }
 
     QVector<QRect> rects = touched.rects();
     for (int i = 0; i < rects.size(); i++)
         compositePainter->drawImage(rects[i], *mScreenImage, rects[i]);
     return touched;
 }

◆ fixupScreenInfo()

void QLinuxFbScreen::fixupScreenInfo	(	fb_fix_screeninfo &	finfo,
		fb_var_screeninfo &	vinfo
	)

protectedvirtual

Adjust the values returned by the framebuffer driver, to work around driver bugs or nonstandard behavior in certain drivers.

finfo and vinfo specify the fixed and variable screen info returned by the driver.

Definition at line 193 of file qscreenlinuxfb_qws.cpp.

Referenced by connect(), initDevice(), and setMode().

 {
     // 8Track e-ink devices (as found in Sony PRS-505) lie
     // about their bit depth -- they claim they're 1 bit per
     // pixel while the only supported mode is 8 bit per pixel
     // grayscale.
     // Caused by this, they also miscalculate their line length.
     if(!strcmp(finfo.id, "8TRACKFB") && vinfo.bits_per_pixel == 1) {
         vinfo.bits_per_pixel = 8;
         finfo.line_length = vinfo.xres;
     }
 }

◆ initDevice()

bool QLinuxFbScreen::initDevice ( )

virtual

This is called by the Qt for Embedded Linux server at startup time.

Reimplemented Function

It turns off console blinking, sets up the color palette, enables write combining on the framebuffer and initialises the off-screen memory manager.

Implements QScreen.

Definition at line 696 of file qscreenlinuxfb_qws.cpp.

 {
     d_ptr->openTty();
 
     // Grab current mode so we can reset it
     fb_var_screeninfo vinfo;
     fb_fix_screeninfo finfo;
     //#######################
     // Shut up Valgrind
     memset(&vinfo, 0, sizeof(vinfo));
     memset(&finfo, 0, sizeof(finfo));
     //#######################
 
     if (ioctl(d_ptr->fd, FBIOGET_VSCREENINFO, &vinfo)) {
         perror("QLinuxFbScreen::initDevice");
         qFatal("Error reading variable information in card init");
         return false;
     }
 
 #ifdef DEBUG_VINFO
     qDebug("Greyscale %d",vinfo.grayscale);
     qDebug("Nonstd %d",vinfo.nonstd);
     qDebug("Red %d %d %d",vinfo.red.offset,vinfo.red.length,
            vinfo.red.msb_right);
     qDebug("Green %d %d %d",vinfo.green.offset,vinfo.green.length,
            vinfo.green.msb_right);
     qDebug("Blue %d %d %d",vinfo.blue.offset,vinfo.blue.length,
            vinfo.blue.msb_right);
     qDebug("Transparent %d %d %d",vinfo.transp.offset,vinfo.transp.length,
            vinfo.transp.msb_right);
 #endif
 
     if (ioctl(d_ptr->fd, FBIOGET_FSCREENINFO, &finfo)) {
         perror("QLinuxFbScreen::initDevice");
         qCritical("Error reading fixed information in card init");
         // It's not an /error/ as such, though definitely a bad sign
         // so we return true
         return true;
     }
 
     fixupScreenInfo(finfo, vinfo);
 
     d_ptr->startupw=vinfo.xres;
     d_ptr->startuph=vinfo.yres;
     d_ptr->startupd=vinfo.bits_per_pixel;
     grayscale = vinfo.grayscale;
 
 #ifdef __i386__
     // Now init mtrr
     if(!::getenv("QWS_NOMTRR")) {
         int mfd=QT_OPEN("/proc/mtrr",O_WRONLY,0);
         // MTRR entry goes away when file is closed - i.e.
         // hopefully when QWS is killed
         if(mfd != -1) {
             mtrr_sentry sentry;
             sentry.base=(unsigned long int)finfo.smem_start;
             //qDebug("Physical framebuffer address %p",(void*)finfo.smem_start);
             // Size needs to be in 4k chunks, but that's not always
             // what we get thanks to graphics card registers. Write combining
             // these is Not Good, so we write combine what we can
             // (which is not much - 4 megs on an 8 meg card, it seems)
             unsigned int size=finfo.smem_len;
             size=size >> 22;
             size=size << 22;
             sentry.size=size;
             sentry.type=MTRR_TYPE_WRCOMB;
             if(ioctl(mfd,MTRRIOC_ADD_ENTRY,&sentry)==-1) {
                 //printf("Couldn't add mtrr entry for %lx %lx, %s\n",
                 //sentry.base,sentry.size,strerror(errno));
             }
         }
 
         // Should we close mfd here?
         //QT_CLOSE(mfd);
     }
 #endif
     if ((vinfo.bits_per_pixel==8) || (vinfo.bits_per_pixel==4) || (finfo.visual==FB_VISUAL_DIRECTCOLOR))
     {
         fb_cmap cmap;
         createPalette(cmap, vinfo, finfo);
         if (ioctl(d_ptr->fd, FBIOPUTCMAP, &cmap)) {
             perror("QLinuxFbScreen::initDevice");
             qWarning("Error writing palette to framebuffer");
         }
         free(cmap.red);
         free(cmap.green);
         free(cmap.blue);
         free(cmap.transp);
     }
 
     if (canaccel) {
         *entryp=0;
         *lowest = mapsize;
         insert_entry(*entryp, *lowest, *lowest);  // dummy entry to mark start
     }
 
     shared->fifocount = 0;
     shared->buffer_offset = 0xffffffff;  // 0 would be a sensible offset (screen)
     shared->linestep = 0;
     shared->cliptop = 0xffffffff;
     shared->clipleft = 0xffffffff;
     shared->clipright = 0xffffffff;
     shared->clipbottom = 0xffffffff;
     shared->rop = 0xffffffff;
 
 #ifdef QT_QWS_DEPTH_GENERIC
     if (pixelFormat() == QImage::Format_Invalid && screencols == 0
         && d_ptr->doGenericColors)
     {
         qt_set_generic_blit(this, vinfo.bits_per_pixel,
                             vinfo.red.length, vinfo.green.length,
                             vinfo.blue.length, vinfo.transp.length,
                             vinfo.red.offset, vinfo.green.offset,
                             vinfo.blue.offset, vinfo.transp.offset);
     }
 #endif
 
 #ifndef QT_NO_QWS_CURSOR
     QScreenCursor::initSoftwareCursor();
 #endif
     blank(false);
 
     return true;
 }

◆ insert_entry()

void QLinuxFbScreen::insert_entry	(	int	pos,
		int	start,
		int	end
	)

private

Definition at line 864 of file qscreenlinuxfb_qws.cpp.

Referenced by cache(), and initDevice().

 {
     if (pos > *entryp) {
         qWarning("Attempt to insert odd pos! %d %d",pos,*entryp);
         return;
     }
 
 #ifdef DEBUG_CACHE
     qDebug("Insert entry: %d, %d -> %d", pos, start, end);
 #endif
 
     if (start < (int)*lowest) {
         *lowest = start;
 #ifdef DEBUG_CACHE
         qDebug("    moved lowest to %d", *lowest);
 #endif
     }
 
     if (pos == *entryp) {
         entries[pos].start = start;
         entries[pos].end = end;
         entries[pos].clientId = qws_client_id;
         (*entryp)++;
         return;
     }
 
     int size=(*entryp)-pos;
     memmove(&entries[pos+1],&entries[pos],size*sizeof(QPoolEntry));
     entries[pos].start=start;
     entries[pos].end=end;
     entries[pos].clientId=qws_client_id;
     (*entryp)++;
 }

◆ restore()

void QLinuxFbScreen::restore ( )

virtual

This is called when the virtual console is switched back to Qt for Embedded Linux and restores the palette.

Reimplemented Function

Reimplemented from QScreen.

Definition at line 1234 of file qscreenlinuxfb_qws.cpp.

 {
     if (d_ptr->fd == -1)
         return;
 
     if ((d == 8) || (d == 4)) {
         fb_cmap cmap;
         cmap.start=0;
         cmap.len=screencols;
         cmap.red=(unsigned short int *)
                  malloc(sizeof(unsigned short int)*256);
         cmap.green=(unsigned short int *)
                    malloc(sizeof(unsigned short int)*256);
         cmap.blue=(unsigned short int *)
                   malloc(sizeof(unsigned short int)*256);
         cmap.transp=(unsigned short int *)
                     malloc(sizeof(unsigned short int)*256);
         for (int loopc = 0; loopc < screencols; loopc++) {
             cmap.red[loopc] = qRed(screenclut[loopc]) << 8;
             cmap.green[loopc] = qGreen(screenclut[loopc]) << 8;
             cmap.blue[loopc] = qBlue(screenclut[loopc]) << 8;
             cmap.transp[loopc] = 0;
         }
         ioctl(d_ptr->fd, FBIOPUTCMAP, &cmap);
         free(cmap.red);
         free(cmap.green);
         free(cmap.blue);
         free(cmap.transp);
     }
 }

◆ save()

void QLinuxFbScreen::save ( )

virtual

This doesn't do anything; accelerated drivers may wish to reimplement it to save graphics cards registers.

Reimplemented Function

It's called by the Qt for Embedded Linux server when the virtual console is switched.

Reimplemented from QScreen.

Definition at line 1218 of file qscreenlinuxfb_qws.cpp.

 {
     // nothing to do.
 }

◆ set()

void QLinuxFbScreen::set	(	unsigned int	index,
		unsigned int	red,
		unsigned int	green,
		unsigned int	blue
	)

virtual

Sets the specified color index to the specified RGB value, (red, green, blue), when in paletted graphics modes.

Reimplemented from QScreen.

Definition at line 1119 of file qscreenlinuxfb_qws.cpp.

 {
     if (d_ptr->fd != -1) {
         fb_cmap cmap;
         cmap.start=i;
         cmap.len=1;
         cmap.red=(unsigned short int *)
                  malloc(sizeof(unsigned short int)*256);
         cmap.green=(unsigned short int *)
                    malloc(sizeof(unsigned short int)*256);
         cmap.blue=(unsigned short int *)
                   malloc(sizeof(unsigned short int)*256);
         cmap.transp=(unsigned short int *)
                     malloc(sizeof(unsigned short int)*256);
         cmap.red[0]=r << 8;
         cmap.green[0]=g << 8;
         cmap.blue[0]=b << 8;
         cmap.transp[0]=0;
         ioctl(d_ptr->fd, FBIOPUTCMAP, &cmap);
         free(cmap.red);
         free(cmap.green);
         free(cmap.blue);
         free(cmap.transp);
     }
     screenclut[i] = qRgb(r, g, b);
 }

◆ setDirty()

void QLinuxFbScreen::setDirty ( const QRect & r )

virtual

Reimplemented Function

Reimplemented from QScreen.

Definition at line 1282 of file qscreenlinuxfb_qws.cpp.

 {
     if(d_ptr->driverType == EInk8Track) {
         // e-Ink displays need a trigger to actually show what is
         // in their framebuffer memory. The 8-Track driver does this
         // by adding custom IOCTLs - FBIO_EINK_DISP_PIC (0x46a2) takes
         // an argument specifying whether or not to flash the screen
         // while updating.
         // There doesn't seem to be a way to tell it to just update
         // a subset of the screen.
         if(r.left() == 0 && r.top() == 0 && r.width() == dw && r.height() == dh)
             ioctl(d_ptr->fd, 0x46a2, 1);
         else
             ioctl(d_ptr->fd, 0x46a2, 0);
     }
 }

◆ setFormat()

void QLinuxFbScreen::setFormat ( QImage::Format format )

virtual

Reimplemented from QFbScreen.

Definition at line 849 of file qlinuxfbintegration.cpp.

 {
     mFormat = format;
     delete mFbScreenImage;
     mFbScreenImage = new QImage(data, mGeometry.width(), mGeometry.height(),
                              bytesPerLine, mFormat);
     delete compositePainter;
     compositePainter = 0;
 
     delete mScreenImage;
     mScreenImage = new QImage(mGeometry.width(), mGeometry.height(),
                               mFormat);
 }

◆ setGeometry()

void QLinuxFbScreen::setGeometry ( QRect rect )

virtual

Reimplemented from QFbScreen.

Definition at line 835 of file qlinuxfbintegration.cpp.

 {
     mGeometry = rect;
     delete mFbScreenImage;
     mFbScreenImage = new QImage(data, mGeometry.width(), mGeometry.height(),
                            bytesPerLine, mFormat);
     delete compositePainter;
     compositePainter = 0;
 
     delete mScreenImage;
     mScreenImage = new QImage(mGeometry.width(), mGeometry.height(),
                               mFormat);
 }

◆ setMode()

void QLinuxFbScreen::setMode	(	int	nw,
		int	nh,
		int	nd
	)

virtual

Sets the framebuffer to a new resolution and bit depth.

Reimplemented Function

The width is in nw, the height is in nh, and the depth is in nd. After doing this any currently-existing paint engines will be invalid and the screen should be completely redrawn. In a multiple-process Embedded Qt situation you must signal all other applications to call setMode() to the same mode and redraw.

Implements QScreen.

Definition at line 1160 of file qscreenlinuxfb_qws.cpp.

 {
     if (d_ptr->fd == -1)
         return;
 
     fb_fix_screeninfo finfo;
     fb_var_screeninfo vinfo;
     //#######################
     // Shut up Valgrind
     memset(&vinfo, 0, sizeof(vinfo));
     memset(&finfo, 0, sizeof(finfo));
     //#######################
 
     if (ioctl(d_ptr->fd, FBIOGET_VSCREENINFO, &vinfo)) {
         perror("QLinuxFbScreen::setMode");
         qFatal("Error reading variable information in mode change");
     }
 
     vinfo.xres=nw;
     vinfo.yres=nh;
     vinfo.bits_per_pixel=nd;
 
     if (ioctl(d_ptr->fd, FBIOPUT_VSCREENINFO, &vinfo)) {
         perror("QLinuxFbScreen::setMode");
         qCritical("Error writing variable information in mode change");
     }
 
     if (ioctl(d_ptr->fd, FBIOGET_VSCREENINFO, &vinfo)) {
         perror("QLinuxFbScreen::setMode");
         qFatal("Error reading changed variable information in mode change");
     }
 
     if (ioctl(d_ptr->fd, FBIOGET_FSCREENINFO, &finfo)) {
         perror("QLinuxFbScreen::setMode");
         qFatal("Error reading fixed information");
     }
 
     fixupScreenInfo(finfo, vinfo);
     disconnect();
     connect(d_ptr->displaySpec);
     exposeRegion(region(), 0);
 }

◆ setPixelFormat()

void QLinuxFbScreen::setPixelFormat ( struct fb_var_screeninfo info )

private

Definition at line 1327 of file qscreenlinuxfb_qws.cpp.

Referenced by connect().

 {
     const fb_bitfield rgba[4] = { info.red, info.green,
                                   info.blue, info.transp };
 
     QImage::Format format = QImage::Format_Invalid;
 
     switch (d) {
     case 32: {
         const fb_bitfield argb8888[4] = {{16, 8, 0}, {8, 8, 0},
                                          {0, 8, 0}, {24, 8, 0}};
         const fb_bitfield abgr8888[4] = {{0, 8, 0}, {8, 8, 0},
                                          {16, 8, 0}, {24, 8, 0}};
         if (memcmp(rgba, argb8888, 4 * sizeof(fb_bitfield)) == 0) {
             format = QImage::Format_ARGB32;
         } else if (memcmp(rgba, argb8888, 3 * sizeof(fb_bitfield)) == 0) {
             format = QImage::Format_RGB32;
         } else if (memcmp(rgba, abgr8888, 3 * sizeof(fb_bitfield)) == 0) {
             format = QImage::Format_RGB32;
             pixeltype = QScreen::BGRPixel;
         }
         break;
     }
     case 24: {
         const fb_bitfield rgb888[4] = {{16, 8, 0}, {8, 8, 0},
                                        {0, 8, 0}, {0, 0, 0}};
         const fb_bitfield bgr888[4] = {{0, 8, 0}, {8, 8, 0},
                                        {16, 8, 0}, {0, 0, 0}};
         if (memcmp(rgba, rgb888, 3 * sizeof(fb_bitfield)) == 0) {
             format = QImage::Format_RGB888;
         } else if (memcmp(rgba, bgr888, 3 * sizeof(fb_bitfield)) == 0) {
             format = QImage::Format_RGB888;
             pixeltype = QScreen::BGRPixel;
         }
         break;
     }
     case 18: {
         const fb_bitfield rgb666[4] = {{12, 6, 0}, {6, 6, 0},
                                        {0, 6, 0}, {0, 0, 0}};
         if (memcmp(rgba, rgb666, 3 * sizeof(fb_bitfield)) == 0)
             format = QImage::Format_RGB666;
         break;
     }
     case 16: {
         const fb_bitfield rgb565[4] = {{11, 5, 0}, {5, 6, 0},
                                        {0, 5, 0}, {0, 0, 0}};
         const fb_bitfield bgr565[4] = {{0, 5, 0}, {5, 6, 0},
                                        {11, 5, 0}, {0, 0, 0}};
         if (memcmp(rgba, rgb565, 3 * sizeof(fb_bitfield)) == 0) {
             format = QImage::Format_RGB16;
         } else if (memcmp(rgba, bgr565, 3 * sizeof(fb_bitfield)) == 0) {
             format = QImage::Format_RGB16;
             pixeltype = QScreen::BGRPixel;
         }
         break;
     }
     case 15: {
         const fb_bitfield rgb1555[4] = {{10, 5, 0}, {5, 5, 0},
                                         {0, 5, 0}, {15, 1, 0}};
         const fb_bitfield bgr1555[4] = {{0, 5, 0}, {5, 5, 0},
                                         {10, 5, 0}, {15, 1, 0}};
         if (memcmp(rgba, rgb1555, 3 * sizeof(fb_bitfield)) == 0) {
             format = QImage::Format_RGB555;
         } else if (memcmp(rgba, bgr1555, 3 * sizeof(fb_bitfield)) == 0) {
             format = QImage::Format_RGB555;
             pixeltype = QScreen::BGRPixel;
         }
         break;
     }
     case 12: {
         const fb_bitfield rgb444[4] = {{8, 4, 0}, {4, 4, 0},
                                        {0, 4, 0}, {0, 0, 0}};
         if (memcmp(rgba, rgb444, 3 * sizeof(fb_bitfield)) == 0)
             format = QImage::Format_RGB444;
         break;
     }
     case 8:
         break;
     case 1:
         format = QImage::Format_Mono; //###: LSB???
         break;
     default:
         break;
     }
 
     QScreen::setPixelFormat(format);
 }

◆ setupOffScreen()

void QLinuxFbScreen::setupOffScreen ( )

private

Definition at line 1056 of file qscreenlinuxfb_qws.cpp.

Referenced by connect().

 {
     // Figure out position of offscreen memory
     // Set up pool entries pointer table and 64-bit align it
     int psize = size;
 
     // hw: this causes the limitation of cursors to 64x64
     // the cursor should rather use the normal pixmap mechanism
     psize += 4096;  // cursor data
     psize += 8;     // for alignment
     psize &= ~0x7;  // align
 
     unsigned long pos = (unsigned long)data;
     pos += psize;
     entryp = ((int *)pos);
     lowest = ((unsigned int *)pos)+1;
     pos += (sizeof(int))*4;
     entries = (QPoolEntry *)pos;
 
     // beginning of offscreen memory available for pixmaps.
     cacheStart = psize + 4*sizeof(int) + sizeof(QPoolEntry);
 }

◆ sharedRamSize()

int QLinuxFbScreen::sharedRamSize ( void * end )

virtual

Warning: This function is not part of the public interface.

Reimplemented from QScreen.

Definition at line 1272 of file qscreenlinuxfb_qws.cpp.

 {
     shared=(QLinuxFb_Shared *)end;
     shared--;
     return sizeof(QLinuxFb_Shared);
 }

◆ shutdownDevice()

void QLinuxFbScreen::shutdownDevice ( )

virtual

This is called by the Qt for Embedded Linux server when it shuts down, and should be inherited if you need to do any card-specific cleanup.

Reimplemented Function

The default version hides the screen cursor and reenables the blinking cursor and screen blanking.

Reimplemented from QScreen.

Definition at line 1091 of file qscreenlinuxfb_qws.cpp.

 {
     // Causing crashes. Not needed.
     //setMode(startupw,startuph,startupd);
 /*
     if (startupd == 8) {
         ioctl(fd,FBIOPUTCMAP,startcmap);
         free(startcmap->red);
         free(startcmap->green);
         free(startcmap->blue);
         free(startcmap->transp);
         delete startcmap;
         startcmap = 0;
     }
 */
     d_ptr->closeTty();
 }

◆ uncache()

void QLinuxFbScreen::uncache ( uchar * memoryBlock )

virtual

Deletes the specified memoryBlock allocated from the graphics card memory.

Note that the display is locked while memory is unallocated in order to preserve the memory pool's integrity.

This function will first sync the graphics card to ensure the memory isn't still being used by a command in the graphics card FIFO queue. It is possible to speed up a driver by overriding this function to avoid syncing. For example, the driver might delay deleting the memory until it detects that all commands dealing with the memory are no longer in the queue. Note that it will then be up to the driver to ensure that the specified memoryBlock no longer is being used.

See also: cache(), deleteEntry(), clearCache()

Reimplemented from QScreen.

Definition at line 995 of file qscreenlinuxfb_qws.cpp.

 {
     // need to sync graphics card
 
     deleteEntry(c);
 }

◆ useOffscreen()

bool QLinuxFbScreen::useOffscreen ( )

virtual

Warning: This function is not part of the public interface.

Definition at line 1415 of file qscreenlinuxfb_qws.cpp.

Referenced by connect().

 {
     // Not done for 8Track because on e-Ink displays,
     // everything is offscreen anyway
     if (d_ptr->driverType == EInk8Track || ((mapsize - size) < 16*1024))
         return false;
 
     return true;
 }

Properties

◆ bytesPerLine

int QLinuxFbScreen::bytesPerLine

private

Definition at line 64 of file qlinuxfbintegration.h.

Referenced by QLinuxFbScreen(), setFormat(), and setGeometry().

◆ cacheStart

int QLinuxFbScreen::cacheStart

protected

Definition at line 113 of file qscreenlinuxfb_qws.h.

Referenced by cache(), and setupOffScreen().

◆ canaccel

bool QLinuxFbScreen::canaccel

protected

Definition at line 111 of file qscreenlinuxfb_qws.h.

Referenced by cache(), clearCache(), connect(), initDevice(), and QLinuxFbScreen().

◆ compositePainter

QPainter* QLinuxFbScreen::compositePainter

private

Definition at line 66 of file qlinuxfbintegration.h.

Referenced by doRedraw(), setFormat(), and setGeometry().

◆ d_ptr

QLinuxFbScreenPrivate* QLinuxFbScreen::d_ptr

private

Definition at line 126 of file qscreenlinuxfb_qws.h.

Referenced by blank(), connect(), disconnect(), initDevice(), restore(), set(), setDirty(), setMode(), shutdownDevice(), useOffscreen(), and ~QLinuxFbScreen().

◆ data

uchar* QLinuxFbScreen::data

private

Definition at line 63 of file qlinuxfbintegration.h.

Referenced by cache(), connect(), deleteEntry(), disconnect(), QLinuxFbScreen(), setFormat(), setGeometry(), and setupOffScreen().

◆ dataoffset

int QLinuxFbScreen::dataoffset

protected

Definition at line 112 of file qscreenlinuxfb_qws.h.

Referenced by connect(), and disconnect().

◆ mFbScreenImage

QImage* QLinuxFbScreen::mFbScreenImage

private

Definition at line 62 of file qlinuxfbintegration.h.

Referenced by doRedraw(), QLinuxFbScreen(), setFormat(), and setGeometry().

◆ shared

QLinuxFb_Shared* QLinuxFbScreen::shared

Definition at line 105 of file qscreenlinuxfb_qws.h.

Referenced by initDevice(), and sharedRamSize().

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

/src/gui/embedded/qscreenlinuxfb_qws.h
/src/plugins/platforms/linuxfb/qlinuxfbintegration.h
/src/gui/embedded/qscreenlinuxfb_qws.cpp
/src/plugins/platforms/linuxfb/qlinuxfbintegration.cpp

Public Types

Public Slots

Public Functions

Public Variables

Protected Functions

Static Protected Functions

Protected Variables

Private Functions

Properties

Additional Inherited Members

Detailed Description

Enumerations

◆ DriverTypes

Constructors and Destructors

◆ QLinuxFbScreen() [1/2]

◆ ~QLinuxFbScreen()

◆ QLinuxFbScreen() [2/2]

Functions

◆ blank()

◆ cache()

◆ clearCache()

◆ connect()

◆ createPalette()

◆ delete_entry()

◆ deleteEntry()

◆ disconnect()

◆ doRedraw

◆ fixupScreenInfo()

◆ initDevice()

◆ insert_entry()

◆ restore()

◆ save()

◆ set()

◆ setDirty()

◆ setFormat()

◆ setGeometry()

◆ setMode()

◆ setPixelFormat()

◆ setupOffScreen()

◆ sharedRamSize()

◆ shutdownDevice()

◆ uncache()

◆ useOffscreen()

Properties

◆ bytesPerLine

◆ cacheStart

◆ canaccel

◆ compositePainter

◆ d_ptr

◆ data

◆ dataoffset

◆ mFbScreenImage

◆ shared