• Java Bindings for OpenDDS
• Added the ability for using multiple repositories to provide redundant service metadata management
• Implemented the WaitSet, GuardCondition, and StatusCondition interfaces from the OMG DDS specification
• Implemented DomainParticipant::get_current_time() from formal/07-01-01
• Removed requirement for repository domain specification files
• Internal service Entity identifiers have been expanded to 128 bits
• dcps_ts.pl changes
• DCPSInfoRepo changes
• Fixed bug in DCPSInfoRepo that did not re-evaluate the compatibility and associations when QoS change is made
• Fixed bugs that affected connection establishment
• Added datalink_release_delay and removed keep_link configuration
• Fixed a potential deadlock in reliable multicast transport

See the Release Notes for details.

Goals

The VMS (Virtual Memory System) operating system is available only on VAX, Alpha and Itanium processors, and in spite of its undeniable qualities, its future seems uncertain. The FreeVMS project tends to the coding of an operating system under the GPL licence according to the specifications of the VMS systems. This operating system has to function at least on I386 architecture. It is developed using the C language.

I may have to try it out…

• More QoS features have been implemented
• dispose() notifications have been added
• Added IPv6 support
• Improved memory management
• Multicast transport improvements
• Implemented Changeable QoS policies
• Use multiple DCPSInfoRepos
• Documentation updates
• New tests and examples

See the Release Notes for details.

Here's some C++ functions which handle the conversion between these two formats:

std::string DMS::DegreesMinutesSeconds(double ang,
                                       unsigned int num_dec_places = 2)
std::string DMS::DegreesMinutesSecondsLat(double ang,
                                          unsigned int num_dec_places = 2)
std::string DMS::DegreesMinutesSecondsLon(double ang,
                                          unsigned int num_dec_places = 2)

double DMS::DecimalDegrees(const std::string& dms)

These are inline functions defined in the header file, dms.h:

--- start ---

//==================================================================
/**
 *  dms.h -- C++ functions to convert between decimal degrees
 *           and degrees, minutes, and seconds
 *
 *  Copyright (C) 2005-2008 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
 *  conditions:
 *
 *  The above copyright notice and this permission notice shall be
 *  included in all copies or substantial portions of the Software.
 *
 *  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.
 */
//=================================================================
/*
 * dms.h:  Version 0.02
 * Created by James A. Chappell
 * Created 23 August 2005
 *
 * History:
 * 23-aug-2005  created
 * 25-apr-2008  added latitude/longitude conversions
 * 
 */
//=================================================================

#ifndef __DMS_H__
#define __DMS_H__

#include <sstream>
#include <math.h> // for nearbyint()

namespace DMS
{
  static const char DEG_SIM = 176 ;

//
//  Convert decimal degrees to degrees, minutes and seconds
// 
  inline std::string DegreesMinutesSeconds(double ang,
                                           unsigned int num_dec_places = 2)
  {
    bool neg(false) ;
    if (ang < 0.0)
    {
      neg = true ;
      ang = -ang ;
    }
  
    int deg = (int)ang ;
    double frac = ang - (double)deg ;

    frac *= 60.0 ;

    int min = (int)frac ;

    frac = frac - (double)min ;

    // fix the DDD MM 60 case
    // TODO: nearbyint isn’t alway available (Visual C++,
    //       for example)
    double sec = nearbyint(frac * 600000.0) ;
    sec /= 10000.0 ;

    if (sec >= 60.0)
    {
      min++ ;
      sec -= 60.0 ;
    }

    std::ostringstream oss ;

    if (neg)
    {
      oss << "-" ;
    }

//  TODO: allow user to define delimiters separating
//        degrees, minutes, and seconds.
    oss.setf(std::ios::fixed, std::ios::floatfield);

    oss << deg  
        << DEG_SIM ;
    oss.fill('0') ;
    oss.width(2) ;
    oss << min
        << "\'" ;
    if (num_dec_places == 0)
    {
      oss.width(2) ;
      oss.precision(0) ;
    }
    else
    {
      oss.width(num_dec_places + 3) ;
      oss.precision(num_dec_places) ;
    }
    oss << sec 
        << "\"" ;

    return oss.str() ;
  }


  inline std::string DegreesMinutesSecondsLat(double ang,
                        unsigned int num_dec_places = 2)
  {
    std::string lat(DegreesMinutesSeconds(ang, num_dec_places)) ;
  
    if (lat[0] == '-')
    {
      lat += std::string(" S") ;
      lat.erase(0, 1) ;
    }
    else
    {
      lat += std::string(" N") ;
    }

    lat = std::string(" ") + lat ;

    return lat ;
  }


  inline std::string DegreesMinutesSecondsLon(double ang,
                        unsigned int num_dec_places = 2)
  {
    std::string lon(DegreesMinutesSeconds(ang, num_dec_places)) ;

    if (lon[0] == '-')
    {
      lon += std::string(" W") ;
      lon.erase(0, 1) ;
    }
    else
    {
      lon += std::string(" E") ;
    }

    if (fabs(ang) < 100.0)
    {
      lon = std::string("0") + lon ;
    }

    return lon ;
  }


//
// Convert degrees, minutes and seconds to decimal degrees.
// 
  inline double DecimalDegrees(const std::string& dms)
  {
    std::string tmp(dms) ;

    // need to handle the -0 MM SS case
    // TODO: handle leading spaces before potential minus sign
    bool neg(false) ;

    if ((tmp[tmp.length() - 1] == 'W') || (tmp[tmp.length() - 1] == 'S') ||
        (tmp[0] == '-'))
    {
      neg = true ;
    }

    for (unsigned int i = 0 ; i < tmp.length() ; i++)
    {
      if (!isdigit(tmp[i]) && (tmp[i] != '.'))
      {
        tmp[i] = ' ' ;
      }
    }

    double deg(0.0), min(0.0), sec(0.0) ;
//  TODO: handle other delimiters
    std::istringstream iss(tmp) ;
    iss >> deg >> min >> sec ;

    double ang = deg + ((min + (sec / 60.0)) / 60.0) ;

    if (neg)
    {
      ang = -ang ;
    }

    return ang ;
  }
} ;

#endif

--- end ---

Here's a sample program using the functions in dms.h:

--- start ---

#include <iostream>
#include "dms.h"

using namespace std;
using namespace DMS;

int main()
{
    double ang ;
    
    cout << "Enter angle (decimal degrees): " ;
    cin >> ang ;
    
    string dms ;

    dms = DegreesMinutesSeconds(ang) ;

    cout << dms << endl ;

    ang = DecimalDegrees(dms) ;

    cout << ang << endl ;

    return 0 ;
}

--- end ---

At some point these functions may be incorporated into a class encapsulating angular measure.

Multics (Multiplexed Information and Computing Service) was a mainframe timesharing operating system that began at MIT as a research project in 1965. It was an important influence on operating system development.

…

In order to preserve the ideas and innovations that made Multics so important in the development of computer systems, Bull HN has provided the source code for the final Multics release, MR 12.5 of November 1992 to MIT. It is a generous contribution to computer science knowledge and is provided for academic purposes. Additionally, we intend this site to become a repository for many papers and documents that were created during the Multics development as a complement to the other Multics sites.

Check out: Multics Source and Listings.

T₀(x):
double T0(double x) ;

T₁(x):
double T1(double x) ;

T₂(x):
double T2(double x) ;

T_n(x):
double Tn(unsigned int n, double x) ;

These are inline functions defined in the header file, chebyshev.h:

– start –

//==================================================================
/**
 *  chebyshev.h -- C++ functions to evaluate Chebyshev polynomials
 *
 *  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.
 */
//=================================================================
/*
 * chebyshev.h:  Version 0.01
 * Created by James A. Chappell
 * Created 29 September 2005
 *
 * History:
 * 28-jul-2007  created
 */
//==============

#ifndef __CHEBYSHEV_H__
#define __CHEBYSHEV_H__
/*
 *	Function calculates Chebyshev Polynomials Tn(x)
 */

namespace Chebyshev
{
  // n = 0
  inline double T0(double x)
  {
    return 1.0 ;
  }

  // n = 1
  inline double T1(double x)
  {
    return x ;
  }

  // n = 2
  inline double T2(double x)
  {
    return (2.0 * x*x) - 1.0 ;
  }

/*
 *	Tn(x)
 */
  inline double Tn(unsigned int n, double x)
  {
    if (n == 0)
    {
      return T0(x) ;
    }
    else if (n == 1)
    {
      return T1(x) ;
    }
    else if (n == 2)
    {
      return T2(x) ;
    }

/* We could simply do this:
    return (2.0 * x * Tn(n - 1, x)) - Tn(n - 2, x) ;
   but it could be slow for large n */
 
    double tnm1(T2(x)) ;
    double tnm2(T1(x)) ;
    double tn(tnm1) ;

    for (unsigned int l = 3 ; l <= n ; l++)
    { 
      tn = (2.0 * x * tnm1) - tnm2 ;
      tnm2 = tnm1;
      tnm1 = tn;
    }

    return tn ;
  }
}
#endif

– end –

Here’s a sample program:

– start –

#include <iostream>
#include "chebyshev.h"

using namespace std ;
using namespace Chebyshev ;

int main()
{
  double tn ;

  cout.precision(5) ;
  for (unsigned int n = 0 ; n <= 5 ; n++)
  {
    for (double x = -1.0 ; x <= 1.0 ; x = x + 0.1)
    { 
      tn = Tn(n, x) ;
      cout << "T" << n << "(" << x << ") = " << tn << endl ;
    }
    cout << endl ;
  }

  return 0 ;
}

– end –

OpenDDS is an open source C++ implementation of the Object Management Group (OMG) Data Distribution Service (DDS). OpenDDS leverages the Adaptive Communication Environment (ACE) to provide a cross platform environment.

OpenDDS is supported by Object Computing, Inc.

Download OpenDDS here.

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 –