Espoo, Finland — Nokia today announced that its Qt cross-platform User Interface (UI) and application framework for desktop and embedded platforms will be available under the Lesser General Public License (LGPL) version 2.1 license from the release of Qt 4.5, scheduled for March 2009. Previously, Qt has been made available to the open source community under the General Public License (GPL) license. In addition, Qt will now be available from the new domain, www.qtsoftware.com.

The move to LGPL licensing will provide open source and commercial developers with more permissive licensing than GPL and so increase flexibility for developers. In addition, Qt source code repositories will be made publicly available and will encourage contributions from desktop and embedded developer communities. With these changes, developers will be able to actively drive the evolution of the Qt framework.

Qt 4.5 will also be available under commercial licensing terms, while licensing for previous versions of Qt remains unchanged. In addition, service offerings for Qt will be expanded to ensure that all Qt development projects can have access to the same levels of support, independent of the selected license.

Good news for those of us too cheap to pay the $4950 per developer multi-platform license.

Continuing with our task of creating a C++ version of basicwin.c, we next look at XCreateSimpleWindow. Here’s some code snippets from basicwin.c showing the use of XCreateSimpleWindow:

/* basicwin.c */
#include <X11/Xlib.h>

Display *display;
int screen_num;

static char *progname; /* name this program was invoked by */

void main(argc, argv)
int argc;
char **argv;
{
	Window win;
/*
 .
 .
 .
 */

	/* connect to X server */
	if ( (display=XOpenDisplay(display_name)) == NULL )
	{
		(void) fprintf( stderr, "%s: cannot connect to X server %s\n", 
				progname, XDisplayName(display_name));
		exit( -1 );
	}

	/* get screen size from display structure macro */
	screen_num = DefaultScreen(display);
	display_width = DisplayWidth(display, screen_num);
	display_height = DisplayHeight(display, screen_num);

	/* Note that in a real application, x and y would default to 0
	 * but would be settable from the command line or resource database.  
	 */
	x = y = 0;

	/* size window with enough room for text */
	width = display_width/3, height = display_height/4;

	/* create opaque window */
	win = XCreateSimpleWindow(display, RootWindow(display,screen_num), 
			x, y, width, height, border_width, BlackPixel(display,
			screen_num), WhitePixel(display,screen_num));

/*
 .
 .
 .
 */

        /* Display window */
	XMapWindow(display, win);

/*
 .
 .
 .
 */

}

In the C++ version, we can do something like this:

/* basicwin.cpp */

#include " xwindow.h"

/*
 .
 .
 .
 */
int main(int argc, char **argv)
{
  try
  {
    CXDisplayPtr display(CXDisplay::OpenDisplay()) ;

    /* get screen size from display structure macro */
    display_width = display->GetDisplayWidth();
    display_height = display->GetDisplayHeight();

    /* Note that in a real application, x and y would default to 0
     * but would be settable from the command line or resource database.  
     */
    x = y = 0;

    /* size window with enough room for text */
    width = display_width / 3 ;
    height = display_height / 4;

    /* create opaque window */
    CXWindowPtr win(CXWindow::CreateWindow(display,
                    x, y, width, height, border_width,
                    display->GetBlackPixel(),
                    display->GetWhitePixel())) ;

/*
 .
 .
 .
 */
    /* Display window */
    win->Map();
/*
 .
 .
 .
 */
  }
  catch(bad_CXDisplay& e)
  {
    cerr << e.what() << endl ;
  }
  catch(bad_CXWindow& e)
  {
    cerr << e.what() << endl ;
  }
      
  return -1 ;
}

CXWindowPtr is defined in xwindow.h. Creating a window is handled by the constructor for the class CXWindow. XDestoryWindow is called by CXWindow’s destructor. CXWindowPtr wraps CXWindow in a boost::shared_ptr. The static member function, CXWindow::CreateWindow creates a window by calling XCreateSimpleWindow (future versions will likely also support XCreateWindow). CXWindow::CreateWindow creates a window and returns a CXWindowPtr which can be used as a pointer to a Window by dereferencing it. CXWindow’s destructor is called when the CXWindowPtr goes out of scope and all references to it are released.

– start –

/*******************************************************************
 *
 * xdisplay.h -- Wrap Window with a boost::shared_ptr
 *
 *  Copyright (C) 2007 by James A. Chappell (rlrrlrll@gmail.com)
 *
 *  Permission is hereby granted, free of charge, to any person
 *  obtaining a copy of this software and associated documentation
 *  files (the "Software"), to deal in the Software without
 *  restriction, including without limitation the rights to use,
 *  copy, modify, merge, publish, distribute, sublicense, and/or
 *  sell copies of the Software, and to permit persons to whom the
 *  Software is furnished to do so, subject to the following
 *  condition:
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 *  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 *  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *  OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef __XWINDOW_H__
#define __XWINDOW_H__

#include "xdisplay.h"

class bad_CXWindow : public std::exception
{
public:
  virtual const char* what() const throw()
  {
    return "bad_CXWindow" ; // for now
  }
} ;


class CXWindow ;

typedef boost::shared_ptr<CXWindow> CXWindowPtr ;

class CXWindow : private boost::noncopyable
{
public:

  static CXWindowPtr CreateWindow(CXDisplayPtr& display,
                                  int x, int y,
                                  unsigned int width,
                                  unsigned int height,
                                  unsigned int border_width,
                                  unsigned long border,
                                  unsigned long background,
                                  int screen_num = USE_DEFAULT_SCREEN)
  {
    Window parent(display->GetRootWindow(screen_num)) ;
    return CXWindowPtr(new CXWindow(display, parent,
                                    x, y, width, height, 
                                    border_width, border, background)) ;
  }
  
  
  static CXWindowPtr CreateWindow(CXDisplayPtr& display,
                                  CXWindowPtr& parent,
                                  int x, int y,
                                  unsigned int width,
                                  unsigned int height,
                                  unsigned int border_width,
                                  unsigned long border,
                                  unsigned long background)
  {
    return CXWindowPtr(new CXWindow(display, *parent,
                                    x, y, width, height, 
                                    border_width, border, background)) ;
  }

  ~CXWindow()
  {
    XDestroyWindow(*display_, window_) ;
  }

  operator Window const () { return window_ ; }

  void GetWindowAttributes(XWindowAttributes &attr)
  {
    if (!XGetWindowAttributes(*display_, window_, &attr))
    {
      throw bad_CXWindow() ;
    }
  }

  void Map() const
  {
    XMapWindow(*display_, window_);
  }

  void Unmap()
  {
    XUnmapWindow(*display_, window_) ;
  }

private:
  Window window_ ;
  CXDisplayPtr display_ ;

  CXWindow(CXDisplayPtr& display, Window parent,
           int x, int y,
           unsigned int width, unsigned int height,
           unsigned int border_width,
           unsigned long border,
           unsigned long background)
    : display_(display)
  {
    window_ = XCreateSimpleWindow(*display_, parent,
                                   x, y, width, height, 
                                   border_width, border, background) ;
  }

  CXWindow() {} 
} ;

#endif

– end –

Continuing with our task of creating a C++ version of basicwin.c, we next look at XOpenDisplay / XCloseDisplay. Here’s some code snippets from basicwin.c showing the use of these functions:

/* basicwin.c */

#include <X11/Xlib.h>

/*
 .
 .
 .
 */

Display *display;
int screen_num;

/*
 .
 .
 .
 */

void main(argc, argv)
int argc;
char **argv;
{
/*
 .
 .
 .
 */
  char *display_name = NULL;

/* connect to X server */
  if ( (display=XOpenDisplay(display_name)) == NULL )
  {
    (void) fprintf( stderr, "%s: cannot connect to X server %s\n", 
                    progname, XDisplayName(display_name));
    exit( -1 );
  }

  /* get screen size from display structure macro */
  screen_num = DefaultScreen(display);
  display_width = DisplayWidth(display, screen_num);
  display_height = DisplayHeight(display, screen_num);
/*
 .
 .
 .
 */
    XCloseDisplay(display);
    exit(1);
/*
 .
 .
 .
 */
}

C++ allows us to do something like this:

/* basicwin.cpp */
 
#include "xdisplay.h"

/*
 .
 .
 .
 */

int main(int argc, char **argv)
{
/*
 .
 .
 .
 */

  try
  {
    CXDisplayPtr display(CXDisplay::OpenDisplay()) ;

    /*
     * get screen size -- one could pass the screen num if
     * a screen other then the default screen is used
     */
    display_width = display->GetDisplayWidth();
    display_height = display->GetDisplayHeight();
/*
 .
 .
 .
 */
    /* Get available icon sizes from Window manager */
    // Dereferencing a CXDisplayPtr returns a Display *
    if (!XGetIconSizes(*display, display->GetRootWindow(), 
                       &size_list, &count))

  }
  catch(bad_CXDisplay& e)
  {
    cerr << e.what() << endl ;
  }

  /*
   * XCloseDisplay gets called automatically 
   */
  return -1 ;
}

CXDisplayPtr is defined in xdisplay.h. Connecting to an X server is handled by the constructor for the class CXDisplay. Disconnecting from an X server is handled by CXDisplay’s destructor. CXDisplayPtr wraps CXDisplay in a boost::shared_ptr. The static member function, CXDisplay::OpenDisplay connects to an X server (by calling CXDisplay’s constructor) and returns a CXDisplayPtr which can be used as a pointer to a Display by dereferencing it. CXDisplay’s destructor is called when the CXDisplayPtr goes out of scope and all references to it are released.

– start –

/*******************************************************************
 *
 * xdisplay.h -- Wrap Display with a boost::shared_ptr
 *
 *  Copyright (C) 2006 by James A. Chappell (rlrrlrll@gmail.com)
 *
 *  Permission is hereby granted, free of charge, to any person
 *  obtaining a copy of this software and associated documentation
 *  files (the "Software"), to deal in the Software without
 *  restriction, including without limitation the rights to use,
 *  copy, modify, merge, publish, distribute, sublicense, and/or
 *  sell copies of the Software, and to permit persons to whom the
 *  Software is furnished to do so, subject to the following
 *  condition:
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 *  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 *  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *  OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef __xdisplay_h__
#define __xdisplay_h__

#include <X11/Xlib.h>

#include <exception>

#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>

#define USE_DEFAULT_SCREEN -1

class bad_CXDisplay : public std::exception
{
public:
  virtual const char* what() const throw()
  {
    return "bad_CXDisplay" ; // for now
  }
} ;

class CXDisplay ;

typedef boost::shared_ptr<CXDisplay> CXDisplayPtr ;

class CXDisplay : private boost::noncopyable
{
public:
  static CXDisplayPtr OpenDisplay(const char *display_name = NULL) ;

  ~CXDisplay() ;

  Display* operator->() { return display_ ; }
  operator Display* const () { return display_ ; }

  int GetScreenCount() const { return ScreenCount(display_) ; }
  int GetDefaultScreen() const { return DefaultScreen(display_) ; }
  Window GetRootWindow(int screen_num = USE_DEFAULT_SCREEN) const ;
  int GetDisplayWidth(int screen_num = USE_DEFAULT_SCREEN) const ;
  int GetDisplayHeight(int screen_num = USE_DEFAULT_SCREEN) const ;
  int GetDefaultDepth(int screen_num = USE_DEFAULT_SCREEN) const ;
  unsigned long GetBlackPixel(int screen_num = USE_DEFAULT_SCREEN) const ;
  unsigned long GetWhitePixel(int screen_num = USE_DEFAULT_SCREEN) const ;

private:
  Display *display_ ;
  //
  // Only call via static member function OpenDisplay
  //
  CXDisplay(const char *display_name) ;
 
  //
  // see if s indicates using the default screen, otherwise
  // return s
  int screen(int s) const
  {
    return (s == USE_DEFAULT_SCREEN) ? GetDefaultScreen() : s ;
  }

  // no default constructor
  CXDisplay() {}
} ;


inline CXDisplayPtr CXDisplay::OpenDisplay(const char *display_name)
{
  return CXDisplayPtr(new CXDisplay(display_name)) ;
}


inline CXDisplay::CXDisplay(const char *display_name)
{
  display_ = XOpenDisplay(display_name) ;
  if (!display_)
  {
    throw bad_CXDisplay() ;
  }
}


inline CXDisplay::~CXDisplay()
{
  XCloseDisplay(display_);
}


inline Window CXDisplay::GetRootWindow(int screen_num) const
{
  return RootWindow(display_, screen(screen_num)) ;
}


inline int CXDisplay::GetDisplayWidth(int screen_num) const
{
  return DisplayWidth(display_, screen(screen_num)) ;
}


inline int CXDisplay::GetDisplayHeight(int screen_num) const
{
  return DisplayHeight(display_, screen(screen_num)) ;
}


inline int CXDisplay::GetDefaultDepth(int screen_num) const 
{
  return DefaultDepth(display_, screen(screen_num)) ;
}


inline unsigned long CXDisplay::GetBlackPixel(int screen_num) const
{
  return BlackPixel(display_, screen(screen_num)) ;
}


inline unsigned long CXDisplay::GetWhitePixel(int screen_num) const
{
  return WhitePixel(display_, screen(screen_num)) ;
}

#endif

– end –

A fews years later, I worked on another project using X and Motif. It was mandated that this software be written in C leading to same frustration I experience when I first started learning X (by this time I was a seasoned C++ developer, so writing anything in C seemed like a step backward).

I’ve decided to revisit X Windows programming on my own for a few reasons:

• I’m a little rusty when it comes to X Windows programming.
  
  
• I want to use X in a project I’ve been contemplating for the past few years.
  
  
• I’m currently working on Microsoft Windows C++/C# project at work and I want to do some non-Microsoft programming on my own.

My first step in getting back into X Windows programming was to revist the book, Xlib Programming Manual, Rel. 5. The examples in this book are written in C (Kerninghan and Ritchie C, no less). One of these examples, basicwin.c, demonstrates the fundementals of programming with the X library. I figure coming up with a C++ version of basicwin.c would be a useful learning experience for myself and possibly others.

I’ll start out by taking pieces of basicwin.c and converting them to C++. I’ll start with following code fragments showing the use of the structures: XSizeHints, XWMHints, and XClassHint.

#include <X11/Xlib.h>
#include <X11/Xutil.h>

/*
 .
 .
 .
 */

void main(argc, argv)
int argc;
char **argv;
{
  XSizeHints *size_hints;
  XWMHints *wm_hints;
  XClassHint *class_hints;
  Display *display;
  Window win;
  
  char *window_name = "Basic Window Program";
  char *icon_name = "basicwin";

  if (!(size_hints = XAllocSizeHints())) {
    fprintf(stderr, "%s: failure allocating memory\n", argv[0]);
    exit(0);
  }
  if (!(wm_hints = XAllocWMHints())) {
    fprintf(stderr, "%s: failure allocating memory\n", argv[0]);
    exit(0);
  }
  if (!(class_hints = XAllocClassHint())) {
    fprintf(stderr, "%s: failure allocating memory\n", argv[0]);
    exit(0);
  }

/*
 .
 .
 .
 */

  size_hints->flags = PPosition | PSize | PMinSize;
  size_hints->min_width = 300;
  size_hints->min_height = 200;

  wm_hints->initial_state = NormalState;
  wm_hints->input = True;
  wm_hints->icon_pixmap = icon_pixmap;
  wm_hints->flags = StateHint | IconPixmapHint | InputHint;

  class_hints->res_name = progname;
  class_hints->res_class = "Basicwin";

  XSetWMProperties(display, win, &windowName, &iconName,
      argv, argc, size_hints, wm_hints,
      class_hints);

/*
 .
 .
 .
 */

  XFree(size_hints) ;
  XFree(wm_hints) ;
  XFree(class_hints) ;

/*
 .
 .
 .
 */
}

C++ allows us to do something like this:

#include "xalloc.h"

/*
 .
 .
 .
 */

int main(int argc, char **argv)
{
  CXSizeHints size_hints;
  CXClassHint class_hints;
  CXWMHints wm_hints;

  Window win;
  Display *display;

/*
 .
 .
 .
 */

  size_hints->flags = PPosition | PSize | PMinSize;
  size_hints->min_width = 300;
  size_hints->min_height = 200;

  wm_hints->initial_state = NormalState;
  wm_hints->input = True;
  wm_hints->icon_pixmap = icon_pixmap;
  wm_hints->flags = StateHint | IconPixmapHint | InputHint;

  class_hints->res_name = progname;
  class_hints->res_class = "Basicwin";

  XSetWMProperties(display, win, &windowName, &iconName, 
                   argv, argc, size_hints, wm_hints, 
                   class_hints);
/*
 .
 .
 .
 */

  return 0 ;
}

CXSizeHints, CXClassHint and CXWMHints are defined in xalloc.h, along with CXIconSize which isn’t shown in the above example. The allocation is taken care of in the constructors and XFree is called from the destructors. Check out xalloc.h to see how this all works.

– start –

/*******************************************************************
 *
 * xlloc.h - Define wrappers around pointers to ClassHint, IconSize, 
 *           SizeHints, and WMHints
 *
 *  Copyright (C) 2006 by James A. Chappell
 *
 *  Permission is hereby granted, free of charge, to any person
 *  obtaining a copy of this software and associated documentation
 *  files (the "Software"), to deal in the Software without
 *  restriction, including without limitation the rights to use,
 *  copy, modify, merge, publish, distribute, sublicense, and/or
 *  sell copies of the Software, and to permit persons to whom the
 *  Software is furnished to do so, subject to the following
 *  condition:
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 *  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 *  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *  OTHER DEALINGS IN THE SOFTWARE.
 */
#ifndef __xalloc_h__
#define __xalloc_h__

#include <X11/Xlib.h>
#include <X11/Xutil.h>

#include <exception>

//
// Exception, thrown if alloc fails
//
class bad_XAlloc : public std::exception
{
public:
  virtual const char* what() const throw()
  {
    return "bad_XAlloc" ; // for now
  }
} ;


template<class T, T (*alloc())> class _XAlloc 
{
public:
//
// Default Constructor
//
  _XAlloc()
  {
    allocator() ;
  }
//
// Copy Constructor
//
  _XAlloc(const _XAlloc& a)
  {
    allocator() ;
    copy(a.p_) ;
  }
//
// More Constructors
//
  _XAlloc(const T *a)
  {
    allocator() ;
    copy(a) ;
  }

  _XAlloc(const T& a)
  {
    allocator() ;
    copy(&a) ;
  }
//
// Destructor
//
  ~_XAlloc()
  {
    XFree(p_) ; 
  }
//
// Assignment operators
//
  _XAlloc& operator= (const _XAlloc& a)
  {
    if (p_ != a.p_)
    {
      copy(a.p_) ;
    }
   
    return *this ;
  }

  _XAlloc& operator= (const T *a)
  {
    if (p_ != a)
    {
      copy(a) ;
    }
   
    return *this ;
  }

  _XAlloc& operator= (const T& a)
  {
    if (p_ != &a)
    {
      copy(&a) ;
    }
   
    return *this ;
  }
//
// More operators
//
  T* operator->() { return p_ ; }
  operator T* const () { return p_ ; }

private:

  void allocator()
  {
    p_ = alloc() ;
    if (!p_)
    {
      throw bad_XAlloc() ;
    }
  }

  void copy (const T *p)
  {
    *p_ = *p ;
  }
  
  T *p_ ;
} ;

//
// Hide some of the nastiness above with typedefs...
//
typedef _XAlloc<XClassHint, &XAllocClassHint> CXClassHint ;
typedef _XAlloc<XIconSize, &XAllocIconSize> CXIconSize ;
typedef _XAlloc<XSizeHints, &XAllocSizeHints> CXSizeHints ;
typedef _XAlloc<XWMHints, &XAllocWMHints> CXWMHints ;

#endif

– end –