#ifndef _MACADDRESS_UTILITY_H
#define _MACADDRESS_UTILITY_H

class MACAddressUtility
{
public:
	static long GetMACAddress(unsigned char * result);
private:
#if defined(WIN32) || defined(UNDER_CE)
	static long GetMACAddressMSW(unsigned char * result);
#elif defined(__APPLE__)
	static long GetMACAddressMAC(unsigned char * result);
#elif defined(LINUX) || defined(linux)
	static long GetMACAddressLinux(unsigned char * result);
#endif
};

#endif

MACAddressUtility.cpp

#include "MACAddressUtility.h"

#include <stdio.h>

#if defined(WIN32) || defined(UNDER_CE)
#	include <windows.h>
#	if defined(UNDER_CE)
#		include <Iphlpapi.h>
#	endif
#elif defined(__APPLE__)
#	include <CoreFoundation/CoreFoundation.h>
#	include <IOKit/IOKitLib.h>
#	include <IOKit/network/IOEthernetInterface.h>
#	include <IOKit/network/IONetworkInterface.h>
#	include <IOKit/network/IOEthernetController.h>
#elif defined(LINUX) || defined(linux)
#	include <string.h>
#	include <net/if.h>
#	include <sys/ioctl.h>
#   include <sys/socket.h>
#   include <arpa/inet.h>
#endif

long MACAddressUtility::GetMACAddress(unsigned char * result)
{
	// Fill result with zeroes
	memset(result, 0, 6);
	// Call appropriate function for each platform
#if defined(WIN32) || defined(UNDER_CE)
	return GetMACAddressMSW(result);
#elif defined(__APPLE__)
	return GetMACAddressMAC(result);
#elif defined(LINUX) || defined(linux)
	return GetMACAddressLinux(result);
#endif
	// If platform is not supported then return error code
	return -1;
}

#if defined(WIN32) || defined(UNDER_CE)

inline long MACAddressUtility::GetMACAddressMSW(unsigned char * result)
{

#if defined(UNDER_CE)
	IP_ADAPTER_INFO AdapterInfo[16]; // Allocate information
	DWORD dwBufLen = sizeof(AdapterInfo); // Save memory size of buffer
	if(GetAdaptersInfo(AdapterInfo, &dwBufLen) == ERROR_SUCCESS)
	{
		memcpy(result, AdapterInfo->Address, 6);
	}
	else return -1;
#else
	UUID uuid;
	if(UuidCreateSequential(&uuid) == RPC_S_UUID_NO_ADDRESS) return -1;
	memcpy(result, (char*)(uuid.Data4+2), 6);
#endif
	return 0;
}

#elif defined(__APPLE__)

static kern_return_t FindEthernetInterfaces(io_iterator_t *matchingServices)
{
    kern_return_t		kernResult;
    CFMutableDictionaryRef	matchingDict;
    CFMutableDictionaryRef	propertyMatchDict;

    matchingDict = IOServiceMatching(kIOEthernetInterfaceClass);

    if (NULL != matchingDict)
	{
        propertyMatchDict =
			CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
				&kCFTypeDictionaryKeyCallBacks,
				&kCFTypeDictionaryValueCallBacks);

        if (NULL != propertyMatchDict)
		{
            CFDictionarySetValue(propertyMatchDict,
				CFSTR(kIOPrimaryInterface), kCFBooleanTrue);
            CFDictionarySetValue(matchingDict,
				CFSTR(kIOPropertyMatchKey), propertyMatchDict);
            CFRelease(propertyMatchDict);
        }
    }
    kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault,
		matchingDict, matchingServices);
    return kernResult;
}

static kern_return_t GetMACAddress(io_iterator_t intfIterator,
								   UInt8 *MACAddress, UInt8 bufferSize)
{
    io_object_t		intfService;
    io_object_t		controllerService;
    kern_return_t	kernResult = KERN_FAILURE;

	if (bufferSize < kIOEthernetAddressSize) {
		return kernResult;
	}

    bzero(MACAddress, bufferSize);

    while (intfService = IOIteratorNext(intfIterator))
    {
        CFTypeRef	MACAddressAsCFData;        

        // IONetworkControllers can't be found directly by the IOServiceGetMatchingServices call,
        // since they are hardware nubs and do not participate in driver matching. In other words,
        // registerService() is never called on them. So we've found the IONetworkInterface and will
        // get its parent controller by asking for it specifically.

        // IORegistryEntryGetParentEntry retains the returned object,
		// so release it when we're done with it.
        kernResult =
			IORegistryEntryGetParentEntry(intfService,
				kIOServicePlane,
				&controllerService);

        if (KERN_SUCCESS != kernResult) {
            printf("IORegistryEntryGetParentEntry returned 0x%08x\n", kernResult);
        }
        else {
            // Retrieve the MAC address property from the I/O Registry in the form of a CFData
            MACAddressAsCFData =
				IORegistryEntryCreateCFProperty(controllerService,
					CFSTR(kIOMACAddress),
					kCFAllocatorDefault,
					0);
            if (MACAddressAsCFData) {
                CFShow(MACAddressAsCFData); // for display purposes only; output goes to stderr

                // Get the raw bytes of the MAC address from the CFData
                CFDataGetBytes((CFDataRef)MACAddressAsCFData,
					CFRangeMake(0, kIOEthernetAddressSize), MACAddress);
                CFRelease(MACAddressAsCFData);
            }

            // Done with the parent Ethernet controller object so we release it.
            (void) IOObjectRelease(controllerService);
        }

        // Done with the Ethernet interface object so we release it.
        (void) IOObjectRelease(intfService);
    }

    return kernResult;
}

long MACAddressUtility::GetMACAddressMAC(unsigned char * result)
{
	io_iterator_t	intfIterator;
	kern_return_t	kernResult = KERN_FAILURE;
	do
	{
		kernResult = ::FindEthernetInterfaces(&intfIterator);
		if (KERN_SUCCESS != kernResult) break;
	    kernResult = ::GetMACAddress(intfIterator, (UInt8*)result, 6);
    }
	while(false);
    (void) IOObjectRelease(intfIterator);
}

#elif defined(LINUX) || defined(linux)

long MACAddressUtility::GetMACAddressLinux(unsigned char * result)
{
	struct ifreq ifr;
    struct ifreq *IFR;
    struct ifconf ifc;
    char buf[1024];
    int s, i;
    int ok = 0;

    s = socket(AF_INET, SOCK_DGRAM, 0);
    if (s == -1)
	{
        return -1;
    }

    ifc.ifc_len = sizeof(buf);
    ifc.ifc_buf = buf;
    ioctl(s, SIOCGIFCONF, &ifc);

    IFR = ifc.ifc_req;
    for (i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; IFR++)
	{
        strcpy(ifr.ifr_name, IFR->ifr_name);
        if (ioctl(s, SIOCGIFFLAGS, &ifr) == 0)
		{
            if (! (ifr.ifr_flags & IFF_LOOPBACK))
			{
                if (ioctl(s, SIOCGIFHWADDR, &ifr) == 0)
				{
                    ok = 1;
                    break;
                }
            }
        }
    }

    shutdown(s, SHUT_RDWR);
    if (ok)
	{
        bcopy( ifr.ifr_hwaddr.sa_data, result, 6);
    }
    else
	{
        return -1;
    }
    return 0;
}

#endif

wxMACAddressUtility.h

#ifndef _WX_MACADDRESS_UTILITY_H
#define _WX_MACADDRESS_UTILITY_H

#include "MACAddressUtility.h"
#include <wx/wx.h>

class wxMACAddressUtility
{
public:
	static wxString GetMACAddress()
	{
		unsigned char result[6];
		if(MACAddressUtility::GetMACAddress(result) == 0)
		{
			return wxString::Format(wxT("%02X:%02X:%02X:%02X:%02X:%02X"),
				(unsigned int)result[0], (unsigned int)result[1], (unsigned int)result[2],
				(unsigned int)result[3], (unsigned int)result[4], (unsigned int)result[5]);
		}
		return wxEmptyString;
	}
};

#endif

Sample of usage:

m_MACAddress = wxMACAddressUtility::GetMACAddress();

As you can see, core class does not depend on wxWidgets and can be used in native applications written without wxWidgets.

Download sample application

It is official bug that wxScreenDC does not work properly under Mac OS and you can’t use Blit() message for copying screen onto wxMemoryDC.

After digging the Internet I found a kind of solution which used OpenGL and created wxWidgets-based class which takes screenshots also under Mac OS. It was really hard task for me because I haven’t used neither Carbon nor Cocoa before. However everything works now and I’m happy.

Here it is:

wxScreenshotMaker.h

#pragma once

#include <wx/wx.h>
#ifdef __WXMAC__
#include <OpenGL/OpenGL.h>
#endif

class wxScreenshotMaker
{
public:
	wxScreenshotMaker();
	~wxScreenshotMaker();
	wxBitmap GetScreenshot();
private:
#ifdef __WXMAC__

	int screenWidth;
	int screenHeight;

	CGLContextObj glContextObj;
	int rowSize;
	unsigned char * glBitmapData;
	unsigned char * glRowData;

	void InitOpenGL();
	void GrabGLScreen();
	void SwizzleBitmap();
	void FinalizeOpenGL();
#endif
};

wxScreenshotMaker.cpp

#include "wxScreenshotMaker.h"
#ifndef __WXMAC__
#include <wx/dcscreen.h>
#else
#include <CoreFoundation/CoreFoundation.h>
#include <ApplicationServices/ApplicationServices.h>
#include <OpenGL/gl.h>
#endif

wxScreenshotMaker::wxScreenshotMaker()
#ifdef __WXMAC__
: screenWidth(0), screenHeight(0), glBitmapData(NULL), glRowData(NULL)
#endif
{
#ifdef __WXMAC__
	wxSize size = wxGetDisplaySize();
	screenWidth = size.GetWidth();
	screenHeight = size.GetHeight();
	InitOpenGL();
#endif
}

wxScreenshotMaker::~wxScreenshotMaker()
{
#ifdef __WXMAC__
	FinalizeOpenGL();
#endif
}

wxBitmap wxScreenshotMaker::GetScreenshot()
{
#ifndef __WXMAC__
	wxScreenDC screenDC;
	wxBitmap bmp(screenDC.GetSize().GetWidth(), screenDC.GetSize().GetHeight());
	wxMemoryDC mdc(bmp);
	mdc.Blit(0, 0, bmp.GetWidth(), bmp.GetHeight(), &screenDC, 0, 0);
	mdc.SelectObject(wxNullBitmap);
	return bmp;
#else
	if(glBitmapData)
	{
		GrabGLScreen();
		wxImage img = wxImage(screenWidth, screenHeight, glBitmapData, true);
		return wxBitmap(img.Copy());
	}
#endif
}

#ifdef __WXMAC__

void wxScreenshotMaker::InitOpenGL()
{
	do
	{
		rowSize = screenWidth * 3;
		rowSize = (rowSize + 2) & ~2;

		glRowData = (unsigned char *)realloc(glRowData, rowSize);
		glBitmapData = (unsigned char *)realloc(glBitmapData, rowSize * screenHeight);

		bzero(glRowData, rowSize);
		bzero(glBitmapData, rowSize * screenHeight);

		CGDirectDisplayID display = CGMainDisplayID();
		CGLPixelFormatObj pixelFormatObj ;
		GLint numPixelFormats;
		CGLPixelFormatAttribute attribs[] =
		{
			kCGLPFAFullScreen,
			kCGLPFADisplayMask,
			(CGLPixelFormatAttribute)0,    /* Display mask bit goes here */
			(CGLPixelFormatAttribute)0
		};

		attribs[2] = (CGLPixelFormatAttribute) CGDisplayIDToOpenGLDisplayMask(display);

		/* Build a full-screen GL context */
		CGLChoosePixelFormat( attribs, &pixelFormatObj, &numPixelFormats );
		if ( pixelFormatObj == NULL ) break;
		CGLCreateContext( pixelFormatObj, NULL, &glContextObj ) ;
		CGLDestroyPixelFormat( pixelFormatObj ) ;
		if ( glContextObj == NULL ) break;
		CGLSetCurrentContext( glContextObj ) ;
		CGLSetFullScreen( glContextObj ) ;
	}
	while(false);
}

void wxScreenshotMaker::FinalizeOpenGL()
{
    CGLSetCurrentContext( NULL );
    CGLClearDrawable( glContextObj );
    CGLDestroyContext( glContextObj );
	free(glRowData);
	free(glBitmapData);
}

void wxScreenshotMaker::GrabGLScreen()
{
	glReadBuffer(GL_FRONT);
    /* Read framebuffer into our bitmap */
    glFinish();
    glPixelStorei(GL_PACK_ALIGNMENT, 3);
    glPixelStorei(GL_PACK_ROW_LENGTH, 0);
    glPixelStorei(GL_PACK_SKIP_ROWS, 0);
    glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
    /*
      * Fetch the data in RGB format, matching the bitmap context.
      */
    glReadPixels((GLint)0, (GLint)0, (GLint)screenWidth, (GLint)screenHeight,
		GL_RGB, GL_BYTE, glBitmapData);

	SwizzleBitmap();
}

void wxScreenshotMaker::SwizzleBitmap()
{
	int top, bottom;
	top = 0;
    bottom = screenHeight - 1;
	void * base = glBitmapData;
	void * topP = NULL;
	void * bottomP = NULL;

	while(top < bottom)
	{
		topP = (void *)((top * rowSize) + (intptr_t)base);
        bottomP = (void *)((bottom * rowSize) + (intptr_t)base);

		bcopy( topP, glRowData, rowSize );
        bcopy( bottomP, topP, rowSize );
        bcopy( glRowData, bottomP, rowSize );

        ++top;
        --bottom;
	}
}

#endif

Sample

wxScreenshotMaker screenshot;
m_Canvas->SetBitmap(screenshot.GetScreenshot());
m_Canvas->Refresh();

Download wxScreenshotMaker and sample project.

What is AxTk?

AxTk (pronounced Ay Ex Tee Kay) is an open source, C++ add-on for wxWidgets that helps developers create highly accessible, talking applications for users with impaired vision. It may also be useful for other impairments that benefit from a simplified user interface.

AxTk features a new menu-based system that is easy to learn and use, in addition to providing adaptation for some existing GUI controls and dialogs. The developer can choose whether to use the menu system, or to adapt an existing application UI, or use a combination of methods.

AxTk is cross-platform (tested so far on Windows XP, Linux and Mac OS X 10.5), and includes text-to-speech classes with the ability to drive SAPI 5, Apple Speech Synthesis Manager, eSpeak, and Cepstral. Other speech engines can be driven by writing additional handlers.

Note that AxTk is a work in progress and the API is subject to change.

What else is AxTk?

There is an additional, higher-level layer for building applications that help the user maintain ‘resource libraries’ for all kinds of files and services. The motivation is to provided simplified access to many resources and activities that are currently spread amongst many applications and web sites. By making this part of AxTk, we increase the chances of providing a really useful, accessible application platform that can be customised in interesting ways for individuals or government sectors. However, this is currently a less well-developed aspect of AxTk and one which you can ignore fo now. The resource demo shows playing of audio albums and reading Epub books (having converted the XHTML content to plain text first).

What about Braille output?

Although nothing is specifically coded yet for Braille devices, they could be supported relatively easily by adding handlers to the wxTextToSpeech system, to output to the device instead of a speech engine.

Why not just use a screen reader?

Screen readers don’t have an in-depth knowledge of the application; in theory, an AxTk application can make use of knowledge of its own structure to make speech more helpful and less verbose. Also, an application’s custom controls are not accessible to screen readers. In additon, AxTk provides an alternative, menu-based user interface that is not so prone to the problems of accessing conventional layouts via a screen reader. Finally, an AxTk application provides support for application-wide colour and text size changes that are harder to achieve in an ad-hoc way.

Is this anything to do with MSAA (Microsoft Active Accessibility)?

No; a different approach is used. Although wxWidgets has some basic MSAA support, other ports have no similar support and it may be hard to create a comprehensive cross-platform solution to accessibility based on OS-level accessibility support. It would still leave applications and users at the mercy of particular screen readers and it would not solve other problems that AxTk sets out to solve: visual adaptation, fine control over speech (such as content voicing), customisable shortcut support, and more.

Having said that, work on integrating MSAA equivalents for other platforms would be very welcome, either as part of AxTk or built into wxWidgets.

How hard is it to use?

Apart from some housekeeping that you can pinch from the sample, the amount of extra code can be small if you’re just adapting existing UIs. For example, to make a dialog self-voicing and responsive to visual appearance changes (assuming the dialog’s controls are in the set of controls currently handled by AxTk):

#include "ax/ax_ui_adaptation.h"
...
class MyDialog: public wxDialog
{
    ...
    AxSelfVoicing m_adapter;
};

MyDialog::MyDialog(...)
{
    ...
    m_adapter.Adapt(this);
}

If you have controls that are not currently handled by AxTk, you can write adapter classes and also handler classes that detect the appropriate controls and create their adapters.

Using the new menu system is also pretty straightforward as you can see from the sample (mainframe.cpp). There are some new concepts such as AxActivator, which handles menu item activation, but there’s plenty in common with conventional wxWidgets programming.

Where and how do I get it?

AxTk is hosted at Google Code and is available via SVN or as a source tarball or zip file.

http://code.google.com/p/axtk/

The discussion group is axtk-dev_at_googlegroups.com.

The documentation is available here:

http://www.anthemion.co.uk/axtk/html/index.html

Are there demos?

Yes; you can download axsample binaries for Windows, Linux and Mac from:

http://www.anthemion.co.uk/axtk/

You can ignore axresourcesample unless you’re interested in the higher-level resource library layer mentioned previously.

Can I contribute?

Please do! See docs/todo.txt for some of the things left to do. You’ll probably find things to do yourself. You can supply patches in the AxTk’s Issue Tracker, or you can ask to be added to the list of project members in order to make changes in SVN.

What’s the build system?

None to speak of. This would make a good contribution. Currently you can use DialogBlocks to generate projects and makefiles for the two samples, which simply include all the AxTk code.

What is the license?

The license is the New BSD License, which is very brief, easy to understand, and industry-friendly. Please see license.txt in the source tarball for details.

I hope you find AxTk useful – or at least, fun to play with.

So, in this post I’m going to tell a bit about creating About boxes for your software.

wxWidgets has builf-in API for creating “standard” dialog boxes. wxAboutBox() function is used for displaying About box and wxAboutDialogInfo object, which contains all necessary information, should be passed to wxAboutBox() function.

wxAboutDialogInfo can contain such information as:

• Application name
• Application icon
• Application description
• Application version
• List of developers
• List of artists
• List of documentation writers
• List of translators
• Copyright message
• Web-site URL
• Application license

Only wxGTK port supports native way of displaying application license. On other platforms generic implementation will be used and it is better to create a separate dialog for this purpose.

Well, here is a small example of using API described above:

#include
...
// This object will contain all information displayed in About box
wxAboutDialogInfo info;
// Call of AddDeveloper() method adds a record to list of developers
info.AddDeveloper(_("John Doe"));
// Call of AddDocWriter() method adds a record to list of documentation writers
info.AddDocWriter(_("Donald Duck"));
// Call of AddArtist() method adds a record to list of artists
info.AddArtist(_("Scrooge Mc.Duck"));
// Call of AddTranslator() method adds a record to list of translators
info.AddTranslator(_("Mickey Mouse"));
// This method adds application description.
info.SetDescription(_("Sample wxWidgets application for testing wxAboutBox() function."));
// This method sets application version string
info.SetVersion(wxT("1.0.0 beta 1"));
// SetName() method sets application name displayed in About box.
// It is better to pass wxApp::GetAppName() to this method
info.SetName(wxTheApp->GetAppName());
// Sets application Web-site URL
info.SetWebSite(wxT("http://wxwidgets.info"));
// Sets the icon which will be displayed in About box.
info.SetIcon(wxICON(wxICON_AAA));
// Sets application license string. Only wxGTK port has native way of
// displaying application license. All other ports will use generic way for this purpose.
info.SetLicence(_("Public Domain"));

// At last, we can display about box
wxAboutBox(info);

As you can see, there are several collapsible panels placed to dialog. The amount of these panels changes according theinformation specified in wxAboutDialogInfo object.
After expanding collapsible panels we’ll get something like this:

Looks nice but a bit boring. So I decided to create more fancy About box. In fact, I was inspired by this post at wxForum but used my own way and also made some changes.

wxMozillaLikeAboutBoxDialog.h

#ifndef _WXMOZILLALIKEABOUTBOXDIALOG_H_
#define _WXMOZILLALIKEABOUTBOXDIALOG_H_

#include "wx/gbsizer.h"
#include "wx/statline.h"

#define SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_STYLE wxCAPTION|wxSYSTEM_MENU|wxCLOSE_BOX|wxTAB_TRAVERSAL
#define SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_TITLE _("About ")
#define SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_IDNAME ID_WXMOZILLALIKEABOUTBOXDIALOG
#define SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_SIZE wxSize(400, 300)
#define SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_POSITION wxDefaultPosition

class wxMozillaLikeAboutBoxDialog: public wxDialog
{
    DECLARE_DYNAMIC_CLASS( wxMozillaLikeAboutBoxDialog )
    DECLARE_EVENT_TABLE()
public:
    wxMozillaLikeAboutBoxDialog();
    wxMozillaLikeAboutBoxDialog( wxWindow* parent,
		wxWindowID id = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_IDNAME,
		const wxString& caption = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_TITLE,
		const wxPoint& pos = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_POSITION,
		const wxSize& size = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_SIZE,
		long style = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_STYLE );

    bool Create( wxWindow* parent,
		wxWindowID id = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_IDNAME,
		const wxString& caption = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_TITLE,
		const wxPoint& pos = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_POSITION,
		const wxSize& size = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_SIZE,
		long style = SYMBOL_WXMOZILLALIKEABOUTBOXDIALOG_STYLE );

    ~wxMozillaLikeAboutBoxDialog();

    void Init();
    void CreateControls();

    wxString GetAppName() const { return m_AppName ; }
    void SetAppName(wxString value) { m_AppName = value ; }

    wxString GetVersion() const { return m_Version ; }
    void SetVersion(wxString value) { m_Version = value ; }

    wxString GetCopyright() const { return m_Copyright ; }
    void SetCopyright(wxString value) { m_Copyright = value ; }

    wxString GetCustomBuildInfo() const { return m_CustomBuildInfo ; }
    void SetCustomBuildInfo(wxString value) { m_CustomBuildInfo = value ; }

    wxBitmap GetBitmapResource( const wxString& name );
    wxIcon GetIconResource( const wxString& name );

    enum wxBuildInfoFormat
    {
        wxBUILDINFO_SHORT,
        wxBUILDINFO_LONG
    };

    static wxString GetBuildInfo(wxBuildInfoFormat format);

    void SetHeaderBitmap(const wxBitmap & value);
    void ApplyInfo();

private:
    wxPanel* m_ContentPanel;
    wxStaticBitmap* m_HeaderStaticBitmap;
    wxStaticText* m_AppNameStaticText;
    wxStaticText* m_CopyrightStaticText;
    wxStaticText* m_VersionStaticText;
    wxStaticText* m_BuildInfoStaticText;
    wxString m_AppName;
    wxString m_Version;
    wxString m_Copyright;
    wxString m_CustomBuildInfo;
    /// Control identifiers
    enum {
        ID_WXMOZILLALIKEABOUTBOXDIALOG = 10000,
        ID_ContentPanel = 10001
    };
};

wxBitmap wxGetBitmapFromMemory(const void * data, size_t length);

#endif

wxMozillaLikeAboutBoxDialog.cpp

#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include "wxMozillaLikeAboutBoxDialog.h"
#include <wx/mstream.h>

IMPLEMENT_DYNAMIC_CLASS( wxMozillaLikeAboutBoxDialog, wxDialog )

BEGIN_EVENT_TABLE( wxMozillaLikeAboutBoxDialog, wxDialog )
END_EVENT_TABLE()

wxMozillaLikeAboutBoxDialog::wxMozillaLikeAboutBoxDialog()
{
    Init();
}

wxMozillaLikeAboutBoxDialog::wxMozillaLikeAboutBoxDialog( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
    Init();
    Create(parent, id, caption, pos, size, style);
}

bool wxMozillaLikeAboutBoxDialog::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
    SetExtraStyle(wxWS_EX_BLOCK_EVENTS);
    wxDialog::Create( parent, id, caption, pos, size, style );
    CreateControls();
    if (GetSizer())
    {
        GetSizer()->SetSizeHints(this);
    }
    Centre();
    return true;
}

wxMozillaLikeAboutBoxDialog::~wxMozillaLikeAboutBoxDialog()
{
}

void wxMozillaLikeAboutBoxDialog::Init()
{
    m_ContentPanel = NULL;
    m_HeaderStaticBitmap = NULL;
    m_AppNameStaticText = NULL;
    m_CopyrightStaticText = NULL;
    m_VersionStaticText = NULL;
    m_BuildInfoStaticText = NULL;
}

void wxMozillaLikeAboutBoxDialog::CreateControls()
{
    wxMozillaLikeAboutBoxDialog* itemDialog1 = this;
    wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxVERTICAL);
    itemDialog1->SetSizer(itemBoxSizer2);
    m_ContentPanel = new wxPanel( itemDialog1, ID_ContentPanel, wxDefaultPosition, wxSize(200, 300), wxNO_BORDER|wxTAB_TRAVERSAL );
    m_ContentPanel->SetBackgroundColour(wxColour(255, 255, 255));
    itemBoxSizer2->Add(m_ContentPanel, 0, wxGROW, 0);
    wxBoxSizer* itemBoxSizer4 = new wxBoxSizer(wxVERTICAL);
    m_ContentPanel->SetSizer(itemBoxSizer4);
    m_HeaderStaticBitmap = new wxStaticBitmap( m_ContentPanel, wxID_STATIC, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer4->Add(m_HeaderStaticBitmap, 0, wxGROW, 0);
    wxGridBagSizer* itemGridBagSizer6 = new wxGridBagSizer(0, 0);
    itemGridBagSizer6->AddGrowableRow(2);
    itemGridBagSizer6->AddGrowableRow(3);
    itemGridBagSizer6->SetEmptyCellSize(wxSize(10, 20));
    itemBoxSizer4->Add(itemGridBagSizer6, 0, wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 10);
    m_AppNameStaticText = new wxStaticText( m_ContentPanel, wxID_STATIC, _T(""), wxDefaultPosition, wxDefaultSize, 0 );
    m_AppNameStaticText->SetForegroundColour(wxColour(255, 0, 0));
    m_AppNameStaticText->SetFont(wxFont(28, wxSWISS, wxNORMAL, wxNORMAL, false, wxT("Arial Narrow")));
    itemGridBagSizer6->Add(m_AppNameStaticText, wxGBPosition(0, 0), wxGBSpan(1, 2), wxALIGN_LEFT|wxALIGN_BOTTOM|wxLEFT|wxRIGHT|wxTOP, 5);
    wxStaticText* itemStaticText8 = new wxStaticText( m_ContentPanel, wxID_STATIC, _("version"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStaticText8->SetForegroundColour(wxColour(192, 192, 192));
    itemStaticText8->SetFont(wxFont(8, wxSWISS, wxNORMAL, wxBOLD, false, wxT("Arial")));
    itemGridBagSizer6->Add(itemStaticText8, wxGBPosition(1, 0), wxGBSpan(1, 1), wxALIGN_RIGHT|wxALIGN_TOP|wxLEFT|wxBOTTOM, 5);
    m_CopyrightStaticText = new wxStaticText( m_ContentPanel, wxID_STATIC, _T(""), wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE );
    itemGridBagSizer6->Add(m_CopyrightStaticText, wxGBPosition(2, 0), wxGBSpan(1, 2), wxGROW|wxGROW|wxALL, 5);
    m_VersionStaticText = new wxStaticText( m_ContentPanel, wxID_STATIC, _T(""), wxDefaultPosition, wxDefaultSize, 0 );
    m_VersionStaticText->SetForegroundColour(wxColour(192, 192, 192));
    m_VersionStaticText->SetFont(wxFont(8, wxSWISS, wxNORMAL, wxBOLD, false, wxT("Arial")));
    itemGridBagSizer6->Add(m_VersionStaticText, wxGBPosition(1, 1), wxGBSpan(1, 1), wxALIGN_LEFT|wxALIGN_TOP|wxLEFT|wxRIGHT|wxBOTTOM, 5);
    m_BuildInfoStaticText = new wxStaticText( m_ContentPanel, wxID_STATIC, _T(""), wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE );
    itemGridBagSizer6->Add(m_BuildInfoStaticText, wxGBPosition(3, 0), wxGBSpan(1, 2), wxGROW|wxGROW|wxALL, 5);
    itemBoxSizer4->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
    wxStaticLine* itemStaticLine13 = new wxStaticLine( itemDialog1, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
    itemBoxSizer2->Add(itemStaticLine13, 0, wxGROW, 0);
    wxStdDialogButtonSizer* itemStdDialogButtonSizer14 = new wxStdDialogButtonSizer;
    itemBoxSizer2->Add(itemStdDialogButtonSizer14, 0, wxALIGN_RIGHT|wxALL, 5);
    wxButton* itemButton15 = new wxButton( itemDialog1, wxID_OK, _("&OK"), wxDefaultPosition, wxDefaultSize, 0 );
    itemStdDialogButtonSizer14->AddButton(itemButton15);
    itemStdDialogButtonSizer14->Realize();
    m_BuildInfoStaticText->SetLabel(wxMozillaLikeAboutBoxDialog::GetBuildInfo(wxBUILDINFO_LONG));
}

And here is a method which returns a string with build information

wxString wxMozillaLikeAboutBoxDialog::GetBuildInfo(wxBuildInfoFormat format)
{
    wxString wxbuild(wxVERSION_STRING);

    if (format == wxBUILDINFO_LONG)
    {
#if defined(__WXMSW__)
        wxbuild << _T("-Windows");
#elif defined(__WXMAC__)
        wxbuild << _T("-Mac");
#elif defined(__UNIX__)
        wxbuild << _T("-Linux");
#endif

#if wxUSE_UNICODE
        wxbuild << _T("-Unicode");
#else
        wxbuild << _T("-ANSI");
#endif // wxUSE_UNICODE
    }
	wxbuild << _(" build");
    return wxbuild;
}

This method utilizes wxVERSION_STRING macro which returns a string with wxWidgets version.

wxBitmap wxGetBitmapFromMemory(const void * data, size_t length)
{
	wxMemoryInputStream stream(data, length);
	return wxBitmap(stream, wxBITMAP_TYPE_ANY);
}

void wxMozillaLikeAboutBoxDialog::SetHeaderBitmap(const wxBitmap & value)
{
    m_HeaderStaticBitmap->SetBitmap(value);
}

wxGetBitmapFromMemory() method creates wxBitmap from memory buffer using wxMemoryInputStream.

void wxMozillaLikeAboutBoxDialog::ApplyInfo()
{
	wxASSERT_MSG(m_HeaderStaticBitmap->GetBitmap().IsOk(), _("Header bitmap for About box is empty"));
	SetTitle(wxString::Format(wxT("%s %s"), _("About"), m_AppName.GetData()));
    m_AppNameStaticText->SetLabel(m_AppName);
    m_VersionStaticText->SetLabel(m_Version);
    m_CopyrightStaticText->SetLabel(m_Copyright);
	wxString buildInfo;
	if(m_CustomBuildInfo.IsEmpty())
	{
		buildInfo = wxMozillaLikeAboutBoxDialog::GetBuildInfo(wxBUILDINFO_LONG);
	}
	else
	{
		buildInfo = m_CustomBuildInfo;
	}
	m_BuildInfoStaticText->SetLabel(buildInfo);
	int labelWidth = m_HeaderStaticBitmap->GetSize().GetWidth() - 20;
	m_VersionStaticText->Wrap(labelWidth);
	m_CopyrightStaticText->Wrap(labelWidth);
	m_BuildInfoStaticText->Wrap(labelWidth);
	m_ContentPanel->Layout();
	m_ContentPanel->GetSizer()->Fit(m_ContentPanel);
    GetSizer()->Fit(this);
	Centre();
}

ApplyInfo method sets labels of all wxStaticText controls, applies header image and then fixes the layout according to changes.

Here is an example of usage of our Mozilla-like About box:

wxAboutBoxTestMainFrame.cpp

void wxAboutBoxTestMainFrame::OnMOZILLALIKEABOUTBOXClick( wxCommandEvent& event )
{
	// Create About box
	wxMozillaLikeAboutBoxDialog * dlg = new wxMozillaLikeAboutBoxDialog(this);
	// Set application name
	dlg->SetAppName(wxTheApp->GetAppName());
	// Set application version
	dlg->SetVersion(wxT("1.0.0 b1"));
	// Set copyright message
	dlg->SetCopyright(wxString::Format(wxT("%c %i %s"),
		(wxChar) 0x00A9, wxDateTime::Now().GetYear(),
		_("Volodymir (T-Rex) Tryapichko. All rights reserved. Please contact author if you have any copyright-related questions.")));
	// Set build info message. This is optional step. If you don't specify build info message then
	// default one will be used
	dlg->SetCustomBuildInfo(wxString::Format(wxT("%s. %s"),
		wxMozillaLikeAboutBoxDialog::GetBuildInfo(wxMozillaLikeAboutBoxDialog::wxBUILDINFO_LONG).GetData(),
		_("Compiled by T-Rex personally  ")));
	// Set header bitmap
	dlg->SetHeaderBitmap(wxGetBitmapFromMemory(header_png, sizeof(header_png)));
	// Apply changes
	dlg->ApplyInfo();
	// Show dialog
	dlg->ShowModal();
	// Destroy dialog
	dlg->Destroy();
}

header_png is a char array created from PNG image using Bin2C utility:

unsigned char header_png[] ={
	0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A,0x00,0x00,0x00,0x0D,0x49,0x48,
	...
};

And here is a screenshot of what we get after compiling the source code listed above:

Download the source code for this tutorial.

Данная статья посвящена внедрению в грид ячеек для редактирования дат и времени. Сам котрол для дат существует – wxDatePickerCtrl. Остается вопрос, как прикрутить его к гриду.

Я позаимствовал готовый контрол, за что спасибо автору, и переделал его под свои нужды, а именно, мне нужно было время в 24-часовом формате. Реализацию самого эдитора времени, который я назвал Бcode>wxTimeCtrl я приводить в статье не буду, т.к. много текста. Но обращу Ваше внимание на то, что макрос GRID_TIME_EDITOR, объявленный в wxTextCtrl.h, нужен исключительно для использования контрола в гриде, потому, если нужно будет использовать его в ином качестве, закоментируйте строку #define GRID_TIME_EDITOR.
wxGridCell.h

#pragma once
#include <wx/grid.h>
#include <wx/generic/gridctrl.h>
#include <wx/datectrl.h>
#include <wx/dateevt.h>
#include "wxTimeCtrl.h"

/*** Renderers ***/
/*** Date Renderer ***/
class wxGridCellDateRenderer: public wxGridCellDateTimeRenderer {
public:
    wxGridCellDateRenderer(wxString sOutFormat = wxT("%d.%m.%Y"),
                           wxString sInputFormat = wxT("%Y%m%d"));
};
/*** Time Renderer ***/
class wxGridCellTimeRenderer: public wxGridCellDateTimeRenderer {
public:
    wxGridCellTimeRenderer();
};

/*** Editors ***/
/*** Date Editor ***/
class wxGridCellDateEditor: public wxGridCellEditor {
    const wxString m_Format;
    wxString m_startValue;

    void SetDateValue();
    wxDatePickerCtrl* DateCtrl() const;
protected:
//    void OnDateChanged(wxDateEvent& event);
    DECLARE_NO_COPY_CLASS(wxGridCellDateEditor)
public:
    wxGridCellDateEditor(const wxString& format=wxT("%d.%m.%Y"));
    ~wxGridCellDateEditor();

    void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler);
    void PaintBackground(const wxRect& rectCell, wxGridCellAttr* attr);
    void SetSize(const wxRect& rectOrig);
    void BeginEdit(int row, int col, wxGrid* grid);
    bool EndEdit(int row, int col, wxGrid* grid);
    bool IsAcceptedKey(wxKeyEvent& event);
    void Reset();
    wxString GetValue() const;
    wxGridCellEditor* Clone() const;
};

/*** Time Editor ***/
class wxGridCellTimeEditor: public wxGridCellEditor {
    wxString m_startValue;

    void SetTimeValue();
    wxTimeCtrl* TimeCtrl() const;
protected:
    DECLARE_NO_COPY_CLASS(wxGridCellTimeEditor)
public:
    wxGridCellTimeEditor();
    ~wxGridCellTimeEditor();

    void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler);
    void PaintBackground(const wxRect& rectCell, wxGridCellAttr* attr);
    void SetSize(const wxRect& rectOrig);
    void BeginEdit(int row, int col, wxGrid* grid);
    bool EndEdit(int row, int col, wxGrid* grid);
    bool IsAcceptedKey(wxKeyEvent& event);
    void Reset();
    wxString GetValue() const;
    wxGridCellEditor* Clone() const;
};

Теперь несколько слов о предоставленных классах:

• wxGridCellDateRenderer - нужен для отображения дат, в том виде, как это нужно программисту, что определяется параметрами wxString sOutFormat - это формат собственно отображения даты, например, wxT("%d.%m.%Y"), т.е. ДД.ММ.ГГГГ, и wxString sInputFormat - это формат, в котором помещается в грид строка, содержащая дату
• wxGridCellTimeRenderer - нужен для отображения времени. Пераметров он не имеет, принимает и отображает время в формате ЧЧ:ММ:СС
• wxGridCellDateEditor - это редактор дат, который параметром принимает формат даты
• wxGridCellTimeEditor - это редактор времени

wxGridCell.cpp

#include "wxGridCell.h"

/*** Renderers ***/
/*** Date Renderer ***/
wxGridCellDateRenderer::wxGridCellDateRenderer(wxString sOutFormat,
                                               wxString sInputFormat)
    : wxGridCellDateTimeRenderer(sOutFormat,sInputFormat)
{
}
/*** Time Renderer ***/
wxGridCellTimeRenderer::wxGridCellTimeRenderer()
    : wxGridCellDateTimeRenderer(wxT("%H:%M:%S"),wxT("%H:%M:%S"))
{
}

/*** Editors ***/
/*** Date Editor ***/
wxGridCellDateEditor::wxGridCellDateEditor(const wxString& format)
    : wxGridCellEditor(),
    m_Format(format),
    m_startValue(wxT(""))
{
}

wxGridCellDateEditor::~wxGridCellDateEditor()
{
    if (m_control) {
        m_control->Destroy();
        m_control = NULL;
    }
}

void wxGridCellDateEditor::Create(wxWindow* parent,
                                  wxWindowID id,
                                  wxEvtHandler* evtHandler)
{
    m_control = new wxDatePickerCtrl(parent, id,
        wxDefaultDateTime, wxDefaultPosition, wxDefaultSize,
        wxDP_SPIN | wxDP_SHOWCENTURY);
    wxGridCellEditor::Create(parent, id, evtHandler);
}

wxDatePickerCtrl* wxGridCellDateEditor::DateCtrl() const
{
    return (wxDatePickerCtrl*)m_control;
}

void wxGridCellDateEditor::PaintBackground(const wxRect& rectCell,
                                           wxGridCellAttr* attr)
{
    wxGridCellEditor::PaintBackground(rectCell, attr);
}

void wxGridCellDateEditor::SetSize(const wxRect& rectOrig)
{
    wxRect rect(rectOrig);
#if defined(__WXGTK__)
    if (rect.x != 0) {
        rect.x+=1;
        rect.y+=1;
        rect.width-=1;
        rect.height-=1;
    }
#elif defined(__WXMSW__)
//    rect.x-=2;
//    rect.y-=2;
//    rect.width+=2;
    rect.height+=2;
#else
    int extra_x=(rect.x>2)?2:1;
    int extra_y=(rect.y>2)?2:1;
    #if defined(__WXMOTIF__)
        extra_x*=2;
        extra_y*=2;
    #endif
    rect.SetLeft(wxMax(0, rect.x-extra_x));
    rect.SetTop(wxMax(0, rect.y-extra_y));
    rect.SetRight(rect.GetRight()+2*extra_x);
    rect.SetBottom(rect.GetBottom()+2*extra_y);
#endif
    wxGridCellEditor::SetSize(rect);
}

void wxGridCellDateEditor::SetDateValue()
{
    wxDateTime tmp;
    if (!tmp.ParseFormat(m_startValue.c_str(),m_Format.c_str())) {
        tmp.SetToCurrent();
    }
    DateCtrl()->SetValue(tmp);
}

void wxGridCellDateEditor::BeginEdit(int row, int col, wxGrid* grid)
{
    wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));

    m_startValue = grid->GetTable()->GetValue(row, col);
    SetDateValue();
    DateCtrl()->SetFocus();
}

bool wxGridCellDateEditor::EndEdit(int row, int col, wxGrid* grid)
{
    wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
    bool changed = false;
    wxDateTime tmp = DateCtrl()->GetValue();
    wxString s=tmp.Format(m_Format.c_str());

    if (s != m_startValue)
        changed = true;
    if (changed)
        grid->GetTable()->SetValue(row, col, s);

    m_startValue = wxEmptyString;
    tmp.SetToCurrent();
    DateCtrl()->SetValue(tmp);

    return changed;
}

bool wxGridCellDateEditor::IsAcceptedKey(wxKeyEvent& event)
{
    if (wxGridCellEditor::IsAcceptedKey(event)) {
        int keycode=event.GetKeyCode();
        if (keycode<128 && (wxIsdigit(keycode) || keycode=='.')) {
            return true;
        }
    }
    return false;
}

void wxGridCellDateEditor::Reset()
{
    wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
    SetDateValue();
}

wxString wxGridCellDateEditor::GetValue() const
{
    wxDateTime tmp = DateCtrl()->GetValue();
    wxString s=tmp.Format(m_Format.c_str());
    return s;
}

wxGridCellEditor* wxGridCellDateEditor::Clone() const
{
    return new wxGridCellDateEditor(m_Format);
}

/*** Time Editor ***/
wxGridCellTimeEditor::wxGridCellTimeEditor()
    : wxGridCellEditor(),
    m_startValue(wxT(""))
{
}

wxGridCellTimeEditor::~wxGridCellTimeEditor()
{
    if (m_control) {
        m_control->Destroy();
        m_control = NULL;
    }
}

void wxGridCellTimeEditor::Create(wxWindow* parent,
                                  wxWindowID id,
                                  wxEvtHandler* evtHandler)
{
    m_control = new wxTimeCtrl(parent, id);
    wxGridCellEditor::Create(parent, id, evtHandler);
}

void wxGridCellTimeEditor::PaintBackground(const wxRect& rectCell,
                                           wxGridCellAttr* attr)
{
    wxGridCellEditor::PaintBackground(rectCell, attr);
}

wxTimeCtrl* wxGridCellTimeEditor::TimeCtrl() const
{
    return (wxTimeCtrl*)m_control;
}

void wxGridCellTimeEditor::SetSize(const wxRect& rectOrig)
{
    wxRect rect(rectOrig);
#if defined(__WXGTK__)
    if (rect.x != 0) {
        rect.x+=1;
        rect.y+=1;
        rect.width-=1;
        rect.height-=1;
    }
#elif defined(__WXMSW__)
//    rect.x-=2;
//    rect.y-=2;
//    rect.width+=2;
    rect.height+=2;
#else
    int extra_x=(rect.x>2)?2:1;
    int extra_y=(rect.y>2)?2:1;
    #if defined(__WXMOTIF__)
        extra_x*=2;
        extra_y*=2;
    #endif
    rect.SetLeft(wxMax(0, rect.x-extra_x));
    rect.SetTop(wxMax(0, rect.y-extra_y));
    rect.SetRight(rect.GetRight()+2*extra_x);
    rect.SetBottom(rect.GetBottom()+2*extra_y);
#endif
    wxGridCellEditor::SetSize(rect);
}

void wxGridCellTimeEditor::SetTimeValue()
{
    wxString s=m_startValue;
    if (s.IsEmpty()) {
        s=wxTimeCtrl::GetCurrentTime();
    }
    TimeCtrl()->SetValue(s);
}

void wxGridCellTimeEditor::BeginEdit(int row, int col, wxGrid* grid)
{
    wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));

    m_startValue = grid->GetTable()->GetValue(row, col);
    SetTimeValue();
    TimeCtrl()->SetFocus();
}

bool wxGridCellTimeEditor::EndEdit(int row, int col, wxGrid* grid)
{
    wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));

    bool changed = false;
    wxString s=TimeCtrl()->GetValue();

    if (s != m_startValue)
        changed = true;
    if (changed)
        grid->GetTable()->SetValue(row, col, s);

    m_startValue = wxEmptyString;
    TimeCtrl()->SetValue(m_startValue);

    return changed;
}

bool wxGridCellTimeEditor::IsAcceptedKey(wxKeyEvent& event)
{
    if (wxGridCellEditor::IsAcceptedKey(event)) {
        int keycode=event.GetKeyCode();
        if (keycode<128 && (wxIsdigit(keycode) || keycode=='.')) {
            return true;
        }
    }
    return false;
}

void wxGridCellTimeEditor::Reset()
{
    wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
    SetTimeValue();
}

wxString wxGridCellTimeEditor::GetValue() const
{
    return TimeCtrl()->GetValue();
}

wxGridCellEditor* wxGridCellTimeEditor::Clone() const
{
    return new wxGridCellTimeEditor();
}

Как это все работает? Вот пример, в котором я использую wxGridCtrl из предыдущей статьи.
Example.cpp

#include "wxGridCtrl.h"
#include "wxGridCell.h"
/* ... */
    m_pGrid = new wxGridCtrl(this, IDC_CHILD_GRID);
    m_pGrid->CreateGrid(0,0);
    m_pGrid->SetRowLabelSize(20);
    m_pGrid->SetColLabelSize(20);
    m_pGrid->DisableDragRowSize();
    m_pGrid->SetDefaultCellBackgroundColour(wxColour(128,128,128));

    m_pGrid->AppendCols(3);

    wxGridCellAttr* pDateAttr = new wxGridCellAttr;
    pDateAttr->SetBackgroundColour(wxColour(255,255,255));
    pDateAttr->SetAlignment(wxALIGN_RIGHT,wxALIGN_CENTRE);
    pDateAttr->SetRenderer(new wxGridCellDateRenderer());
    pDateAttr->SetEditor(new wxGridCellDateEditor(wxT("%Y%m%d")));

    wxGridCellAttr* pTimeAttr = new wxGridCellAttr;
    pTimeAttr->SetBackgroundColour(wxColour(255,255,255));
    pTimeAttr->SetAlignment(wxALIGN_RIGHT,wxALIGN_CENTRE);
    pTimeAttr->SetRenderer(new wxGridCellTimeRenderer());
    pTimeAttr->SetEditor(new wxGridCellTimeEditor());

    m_pGrid->SetColLabelValue(0,wxT("DateCells"));
    m_pGrid->SetColLabelValue(1,wxT("TimeCells"));
    m_pGrid->SetColAttr(0,pDateAttr);
    m_pGrid->SetColAttr(1,pTimeAttr);
    m_pGrid->Refresh();
/* ... */

Вот так в результате будет выглядеть наше приложение:

Захотелось мне как-то, чтобы в гриде были не номера строк, а маркер.
К тому же очень хотелось, чтобы незаполненное пространство грида было не белым, а, примерно, как на рисунке ниже.

Навеяно это было в основном аналогичными и другими классами, предоставляемыми MFC. Тут же и вспомнилось, что подобные классы также прдоставляют очень полезные методы для хранения дополнительных не отображаемых данных, такие как SetData() или GetData().

Вначеле даже была мысль, использовать для этого wxGrid::SetRowLabelValue(), с учетом того, что перерисовку лэйбла я собирался переопределить. Но, покурив исходники грида, я обнаружил, что в функциях bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true) и bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true), третий аргумент не используется. А это значит, что при вставке или удалении строки у меня все посыпется. К тому же неизвестно, как в будущем этот аргумент будет использоваться.

Потому не нашел я ничего лучшего, как переопределить грид и снабдить его необходимыми функциями.
wxGridCtrl.h

#pragma once
#include <wx/wx.h>
#include <wx/grid.h>
#include <map>

class wxGridCtrl: public wxGrid {
    std::map<int,int> m_mRowData;
    DECLARE_DYNAMIC_CLASS(wxGridCtrl)
protected:
    virtual void DrawRowLabel(wxDC& dc, int row);
    virtual void OnLabelLeftClick(wxGridEvent& event);
    virtual void OnSelectCell(wxGridEvent& event);

    DECLARE_EVENT_TABLE();
public:
    wxGridCtrl();
    wxGridCtrl(wxWindow* parent, const long& id);
/// Override
    bool CreateGrid(int numRows, int numCols,
                    wxGrid::wxGridSelectionModes selmode = wxGrid::wxGridSelectCells);
    bool AppendRows(int numRows = 1, bool updateLabels = true);
    bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true);
    bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true);
/// New
    void SetRowData(const int& row, const int& data);
    int GetRowData(const int& row);
};

Теперь, как это все реализовано:

• DrawRowLabel – это функция, реализующая перерисовку лэйбла грида, а именно, рисующая маркер в лэйбле.
• OnLabelLeftClick – усталавливает визуальный курсор в первую колонку, выделенной строки.
• Это понадобилось для того, чтобы маркер не оставался на предыдущей строке, когда кликаем по следующей.
• OnSelectCell – функция, без которой я не смог обойтись, чтобы все хорошо работало:)

Несколько слов о контейнере std::map m_mRowData:

Этот контейнер, имеющий ключем номер строки, и содержит значения, присваиваемые функцией SetRowData. И, чтобы данные соответствовали строками после создания грида, добаления, вставки и удаления записей, пришлось переопределить соответсвующие функции: CreateGrid, AppendRows, InsertRows, DeleteRows. Получить данные для соответствующей строки, как и сами догадываетесь, можно функцией GetRowData.
wxGridCtrl.cpp

#include "wxGridCtrl.h"
#include "cursor.xpm"

IMPLEMENT_DYNAMIC_CLASS(wxGridCtrl, wxGrid);

wxGridCtrl::wxGridCtrl()
{
}

wxGridCtrl::wxGridCtrl(wxWindow* parent, const long& id):
    wxGrid(parent,id,wxDefaultPosition,wxDefaultSize)
{
}

BEGIN_EVENT_TABLE(wxGridCtrl, wxGrid)
    EVT_GRID_LABEL_LEFT_CLICK(wxGridCtrl::OnLabelLeftClick)
    EVT_GRID_SELECT_CELL(wxGridCtrl::OnSelectCell)
END_EVENT_TABLE();

void wxGridCtrl::DrawRowLabel(wxDC& dc, int row)
{
    if (GetRowHeight(row)<=0 || m_rowLabelWidth<=0)
        return;
    wxRect rect;
#ifdef __WXGTK20__
    rect.SetX(1);
    rect.SetY(GetRowTop(row)+1);
    rect.SetWidth(m_rowLabelWidth-2);
    rect.SetHeight(GetRowHeight(row)-2);
    CalcScrolledPosition(0, rect.y, NULL, &rect.y);
    wxWindowDC *win_dc=(wxWindowDC*)&dc;
    wxRendererNative::Get().DrawHeaderButton(win_dc->m_owner, dc, rect, 0);
#else
    int rowTop=GetRowTop(row),
        rowBottom=GetRowBottom(row)-1;
    dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID));
    dc.DrawLine(m_rowLabelWidth - 1, rowTop, m_rowLabelWidth - 1, rowBottom);
    dc.DrawLine(0, rowTop, 0, rowBottom);
    dc.DrawLine(0, rowBottom, m_rowLabelWidth, rowBottom);
    dc.SetPen(*wxWHITE_PEN);
    dc.DrawLine(1, rowTop, 1, rowBottom);
    dc.DrawLine(1, rowTop, m_rowLabelWidth - 1, rowTop);
#endif
    if (row==GetGridCursorRow()) {
        dc.DrawBitmap(wxBitmap(cursor_xpm),0,GetRowTop(row),true);
    }
}

void wxGridCtrl::OnLabelLeftClick(wxGridEvent& event)
{
    if (event.GetRow() != -1) {
        SetGridCursor(event.GetRow(),0);
    }
    event.Skip();
}

void wxGridCtrl::OnSelectCell(wxGridEvent& event)
{
    GetGridRowLabelWindow()->Refresh();
    event.Skip();
}

/// Override
bool wxGridCtrl::CreateGrid(int numRows, int numCols,
                            wxGrid::wxGridSelectionModes selmode)
{
    bool bCreate=wxGrid::CreateGrid(numRows,numCols,selmode);
    if (bCreate) {
        for (int i=0;i<numRows;i++) {
            m_mRowData[i]=0;
        }
    }
    return bCreate;
}

bool wxGridCtrl::AppendRows(int numRows, bool updateLabels)
{
    int nRow=GetNumberRows();
    bool bAdd=wxGrid::AppendRows(numRows,updateLabels);
    if (bAdd) {
        while (nRow<GetNumberRows()) {
            m_mRowData[nRow]=0;
            nRow++;
        }
    }
    return bAdd;
}

bool wxGridCtrl::InsertRows(int pos, int numRows, bool updateLabels)
{
    std::map<int,int> mRow;
    for (int i=0;i<GetNumberRows();i++) {
        mRow[i]=GetRowData(i);
    }
    bool bIns=wxGrid::InsertRows(pos,numRows,updateLabels);
    if (bIns) {
        for (int i=pos+numRows;i<GetNumberRows();i++) {
            m_mRowData[i]=mRow[i-numRows];
        }
        for (int i=pos;i<pos+numRows;i++) {
            m_mRowData[i]=0;
        }
    }
    return bIns;
}

bool wxGridCtrl::DeleteRows(int pos, int numRows, bool updateLabels)
{
    std::map<int,int> mRow;
    for (int i=0;i<GetNumberRows();i++) {
        mRow[i]=GetRowData(i);
    }
    bool bDel=wxGrid::DeleteRows(pos,numRows,updateLabels);
    if (bDel) {
        for (int i=pos;i<GetNumberRows();i++) {
            m_mRowData[i]=mRow[i+numRows];
        }
    }
    return bDel;
}

/// New
void wxGridCtrl::SetRowData(const int& row, const int& data)
{
    if (row<GetNumberRows()) {
        m_mRowData[row]=data;
    }
}

int wxGridCtrl::GetRowData(const int& row)
{
    int data=0;
    if (row<GetNumberRows() && m_mRowData.find(row)!=m_mRowData.end()) {
        data=m_mRowData[row];
    }
    return data;
}

Что касается цветов, это я не включил в класс. Мало ли как кому нужно будет?

Пример использования примерно следующий:

Exmple.cpp

#include "wxGridCtrl.h"
/* ... */
    m_pGrid = new wxGridCtrl(this, wxID_ANY);
    m_pGrid->CreateGrid(0,0);
    m_pGrid->SetRowLabelSize(20);
    m_pGrid->SetColLabelSize(20);
    m_pGrid->DisableDragRowSize();
    m_pGrid->SetDefaultCellBackgroundColour(wxColour(128,128,128));

    m_pGrid->AppendCols(3);
    m_pGrid->SetColLabelValue(0,wxT("A"));
    m_pGrid->SetColLabelValue(1,wxT("B"));
    m_pGrid->SetColLabelValue(2,wxT("C"));

    wxGridCellAttr* pAttr = new wxGridCellAttr;
    pAttr->SetBackgroundColour(wxColour(255,255,255));

    wxGridCellAttr* pAttrBool = new wxGridCellAttr;
    pAttrBool->SetBackgroundColour(wxColour(255,255,255));
    pAttrBool->SetRenderer(new wxGridCellBoolRenderer());
    pAttrBool->SetEditor(new wxGridCellBoolEditor());
    pAttrBool->SetAlignment(wxALIGN_CENTRE,wxALIGN_CENTRE);

    m_pGrid->SetColAttr(0,pAttr);
    m_pGrid->SetColAttr(1,pAttr);
    m_pGrid->SetColAttr(2,pAttrBool);
/* ... */

#ifndef _WX_SMS_SENDER_H
#define _WX_SMS_SENDER_H

#include <wx/wx.h>
#include <atlbase.h>
#include <cemapi.h>
#include <mapiutil.h>

class wxSMSSender
{
public:
	virtual bool Send(const wxString & from,
		const wxString & to, const wxString & text) = 0;
};

class wxSMSSenderMAPI : public wxSMSSender
{
	HRESULT GetSMSFolder(const CComPtr<IMsgStore>& msgStore,
		CComPtr<IMAPIFolder>& folder);
	HRESULT GetSMSMsgStore(const CComPtr<IMAPISession>& session,
		CComPtr<IMsgStore>& msgStore);
	HRESULT SendSMSMessage(const CComPtr<IMAPISession>& session,
		LPCTSTR lpszFrom, LPCTSTR lpszTo, LPCTSTR lpszMessage);
public:
	virtual bool Send(const wxString & from,
		const wxString & to, const wxString & text);
};

#endif

wxSendSMS.cpp

#include "wxSMSSender.h"

HRESULT wxSMSSenderMAPI::GetSMSFolder(
			const CComPtr<IMsgStore>& msgStore,
			CComPtr<IMAPIFolder>& folder)
{
	// Now get the Drafts folder.
	SPropTagArray propDefaultFolder;
	propDefaultFolder.cValues = 1;
	propDefaultFolder.aulPropTag[0] = PR_CE_IPM_DRAFTS_ENTRYID;

	ULONG	values;
	LPSPropValue propVals;
	HRESULT hr = msgStore->GetProps(&propDefaultFolder,
		MAPI_UNICODE, &values, &propVals);
	if (FAILED(hr))
	{
		return hr;
	}

	SBinary& eidDrafts = propVals->Value.bin;

	hr = msgStore->OpenEntry(eidDrafts.cb, (LPENTRYID)eidDrafts.lpb,
		NULL, MAPI_MODIFY, NULL, (LPUNKNOWN*)&folder);
	return hr;
}

HRESULT wxSMSSenderMAPI::GetSMSMsgStore(
			const CComPtr<IMAPISession>& session,
			CComPtr<IMsgStore>& msgStore)
{
	// first we get the msgstores table from the session
	CComPtr<IMAPITable> table;
	HRESULT hr = session->GetMsgStoresTable(MAPI_UNICODE, &table);
	if (FAILED(hr))
	{
		return FALSE;
	}

	// next we loop over the message stores opening each msgstore and
	// getting its name to see if the name matches SMS.
	// If it does then we break out of the loop
	while (TRUE)
	{
		SRowSet* pRowSet = NULL;
		hr = table->QueryRows(1, 0, &pRowSet);

		// If we failed to query the
		// rows then we need to break
		if (FAILED(hr)) break;

		// if we got no rows back then just exit the loop
		//remembering to set an error
		if (pRowSet->cRows == 1)
		{
			ASSERT(pRowSet->aRow[0].lpProps->ulPropTag == PR_ENTRYID);
			SBinary& blob = pRowSet->aRow[0].lpProps->Value.bin;
			hr = session->OpenMsgStore(NULL, blob.cb,
				(LPENTRYID)blob.lpb, NULL, 0, &msgStore);
		}
		else
		{
			hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
		}

		// now remember to free the row set
		FreeProws(pRowSet);
		if (FAILED(hr)) break;

		// now get the display name property from the
		// message store to compare it against the name
		// 'SMS'
		SPropTagArray props;
		props.cValues = 1;
		props.aulPropTag[0] = PR_DISPLAY_NAME;

		ULONG values;
		SPropValue* pProps = NULL;
		hr = msgStore->GetProps(&props, MAPI_UNICODE, &values, &pProps);
		if (FAILED(hr) || values != 1)
		{
			break;
		}

		// if the name matches SMS then break and as
		// hr == S_OK the current MsgStore smart pointer
		// will correctly be set.
		if (_tcsicmp(pProps[0].Value.lpszW, _T("SMS")) == 0)
		{
			break;
		}
	}

	// if we failed for some reason then we clear out
	// the msgstore smartpointer and return the error.
	if (FAILED(hr))
	{
		msgStore.Release();
	}

	return hr;
}

HRESULT wxSMSSenderMAPI::SendSMSMessage(const CComPtr<IMAPISession>& session,
			LPCTSTR lpszFrom, LPCTSTR lpszTo, LPCTSTR lpszMessage)
{

	// now get the SMS message store
	CComPtr<IMsgStore> msgStore;
	HRESULT hr = GetSMSMsgStore(session, msgStore);
	if (FAILED(hr)) return hr;

	CComPtr<IMAPIFolder> folder;
	hr = GetSMSFolder(msgStore, folder);
	if (FAILED(hr)) return hr;

	CComPtr<IMessage> message;
	hr = folder->CreateMessage(NULL, 0 ,&message);
	if (FAILED(hr)) return hr;

	// set the recipients
	// set up the required fields for a recipient
	SPropValue propRecipient[3];
	// it is vital we clear the property structure
	// as there are fields we do not use but MAPI seems
	// to be sentative to them.
	ZeroMemory(&propRecipient, sizeof(propRecipient));
	// set the recipient type which coul be to, cc, bcc
	// but ehre must at least be a to field
	propRecipient[0].ulPropTag = PR_RECIPIENT_TYPE;
	propRecipient[0].Value.l = MAPI_TO;

	// we set the type of address to sms instead of
	// smtp
	propRecipient[1].ulPropTag = PR_ADDRTYPE;
	propRecipient[1].Value.lpszW = _T("SMS");
	// we finally set the email address to the
	// phone number of the person we are sending the message
	// to
	propRecipient[2].ulPropTag = PR_EMAIL_ADDRESS;
	propRecipient[2].Value.lpszW = (LPWSTR)lpszTo;

	// set the addrlist to point to the properties
	ADRLIST adrlist;
	adrlist.cEntries = 1;
	adrlist.aEntries[0].cValues = 3;
	adrlist.aEntries[0].rgPropVals = (LPSPropValue)(&propRecipient);

	// finally modify the recipients of the message
	hr = message->ModifyRecipients(MODRECIP_ADD, &adrlist);
	if (FAILED(hr)) return hr;

	// now we set the additional properties for the
	// message
	SPropValue props[4];

	//note how we zero out the contents of the
	// structure as MAPI is sensative to the
	// contents of other fields we do not use.
	ZeroMemory(&props, sizeof(props));

	// first set the subject of the message
	// as the sms we are going to send
	props[0].ulPropTag = PR_SUBJECT;
	props[0].Value.lpszW = (LPWSTR)lpszMessage;

	// next set the senders email address to
	// the phone number of the person we are
	// sending the message to
	props[1].ulPropTag = PR_SENDER_EMAIL_ADDRESS;
	props[1].Value.lpszW = (LPWSTR)lpszFrom;

	// finally and most importantly tell mapi
	// this is a sms message in need of delivery
	props[2].ulPropTag = PR_MSG_STATUS;
	props[2].Value.ul = MSGSTATUS_RECTYPE_SMS;

    props[3].ulPropTag = PR_MESSAGE_FLAGS;
    props[3].Value.ul = MSGFLAG_FROMME | MSGFLAG_UNSENT;

	hr = message->SetProps(sizeof(props) / sizeof(SPropValue),
		(LPSPropValue)&props, NULL);
	if (FAILED(hr)) return hr;

	// having set all the required fields we can now
	// pass the message over to the msgstore transport
	// to be delivered.
	hr = message->SubmitMessage(0);
	if (FAILED(hr)) return hr;

	return FALSE;
}

bool wxSMSSenderMAPI::Send(const wxString & from,
		const wxString & to, const wxString & text)
{
	do
	{
		HRESULT hr = MAPIInitialize(NULL);
		if (FAILED(hr)) break;
		CComPtr<IMAPISession> mapiSession;
		hr = MAPILogonEx(0 ,NULL, NULL, 0, &mapiSession);
		if (FAILED(hr)) break;
		bool result = SUCCEEDED(SendSMSMessage(mapiSession,
			from.GetData(), to.GetData(), text.GetData()));
		mapiSession->Logoff(0, 0, 0);
		mapiSession.Release();
		MAPIUninitialize();
		return result;
	}
	while(false);
	return false;
}

А пользоваться этим всем очень просто:

wxSMSSenderMAPI sender;
if(!sender.Send(m_FromTextCtrl->GetValue(),
	m_ToTextCtrl->GetValue(), m_SMSTextCtrl->GetValue()))
{
	wxMessageBox(_("Не могу отправить SMS!"));
}

Исходный код примера отправки SMS с помощью CE MAPI для Windows Mobile
Скриншот тестового приложения:

Отправка SMS с помощью CE MAPI - Скришот под Windows Mobile

wxBufferedPaintDC dc(this);

wxRect clientRect = GetClientRect();
wxRect gradientRect = clientRect;
gradientRect.SetHeight(gradientRect.GetHeight()/2);
dc.GradientFillLinear(gradientRect,
wxColour(132,125,132), wxColour(74,69,74), wxSOUTH);
gradientRect.Offset(0, gradientRect.GetHeight());
dc.GradientFillLinear(gradientRect,
wxColour(0,0,0), wxColour(57,56,57), wxSOUTH);

dc.SetPen(wxPen(GetBackgroundColour()));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRectangle(0, 0, clientRect.GetWidth(), clientRect.GetHeight());
dc.SetFont(GetFont());
dc.SetTextForeground(GetForegroundColour());
dc.DrawLabel(m_Label, clientRect,
wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL);

After some experiments I created a simple owner-drawn button control which utilizes this way of drawing:
wxGradientButton.h

/////////////////////////////////////////////////////////////////////////////
// Name:        wxGradientButton.h
// Purpose:
// Author:      Volodymir (T-Rex) Tryapichko
// Modified by:
// Created:     01/08/2008 20:25:42
// RCS-ID:
// Copyright:   Volodymir (T-Rex) Tryapichko, 2008
// Licence:
/////////////////////////////////////////////////////////////////////////////

#ifndef _WXGRADIENTBUTTON_H_
#define _WXGRADIENTBUTTON_H_

/*!
* Includes
*/

////@begin includes
////@end includes

/*!
* Forward declarations
*/

////@begin forward declarations
class wxGradientButton;
////@end forward declarations

/*!
* Control identifiers
*/

////@begin control identifiers
#define ID_WXGRADIENTBUTTON 10003
#define SYMBOL_WXGRADIENTBUTTON_STYLE wxSIMPLE_BORDER|wxFULL_REPAINT_ON_RESIZE
#define SYMBOL_WXGRADIENTBUTTON_IDNAME ID_WXGRADIENTBUTTON
#define SYMBOL_WXGRADIENTBUTTON_SIZE wxSize(100, 100)
#define SYMBOL_WXGRADIENTBUTTON_POSITION wxDefaultPosition
////@end control identifiers

/*!
* wxGradientButton class declaration
*/

class wxGradientButton: public wxWindow
{
DECLARE_DYNAMIC_CLASS( wxGradientButton )
DECLARE_EVENT_TABLE()

wxSize DoGetBestSize() const;
public:
/// Constructors
wxGradientButton();
wxGradientButton(wxWindow* parent,
wxWindowID id = ID_WXGRADIENTBUTTON,
const wxString & label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxSize(100, 100),
long style = wxSIMPLE_BORDER);

/// Creation
bool Create(wxWindow* parent,
wxWindowID id = ID_WXGRADIENTBUTTON,
const wxString & label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxSize(100, 100),
long style = wxSIMPLE_BORDER);

/// Destructor
~wxGradientButton();

/// Initialises member variables
void Init();

/// Creates the controls and sizers
void CreateControls();

////@begin wxGradientButton event handler declarations

/// wxEVT_SIZE event handler for ID_WXGRADIENTBUTTON
void OnSize( wxSizeEvent& event );

/// wxEVT_PAINT event handler for ID_WXGRADIENTBUTTON
void OnPaint( wxPaintEvent& event );

/// wxEVT_ERASE_BACKGROUND event handler for ID_WXGRADIENTBUTTON
void OnEraseBackground( wxEraseEvent& event );

/// wxEVT_LEFT_DOWN event handler for ID_WXGRADIENTBUTTON
void OnLeftDown( wxMouseEvent& event );

/// wxEVT_LEFT_UP event handler for ID_WXGRADIENTBUTTON
void OnLeftUp( wxMouseEvent& event );

////@end wxGradientButton event handler declarations

////@begin wxGradientButton member function declarations

wxString GetLabel() const { return m_Label ; }
void SetLabel(wxString value) { m_Label = value ; }

wxColour GetGradientTopStartColour() const { return m_GradientTopStartColour ; }
void SetGradientTopStartColour(wxColour value) { m_GradientTopStartColour = value ; }

wxColour GetGradientTopEndColour() const { return m_GradientTopEndColour ; }
void SetGradientTopEndColour(wxColour value) { m_GradientTopEndColour = value ; }

wxColour GetGradientBottomStartColour() const { return m_GradientBottomStartColour ; }
void SetGradientBottomStartColour(wxColour value) { m_GradientBottomStartColour = value ; }

wxColour GetGradientBottomEndColour() const { return m_GradientBottomEndColour ; }
void SetGradientBottomEndColour(wxColour value) { m_GradientBottomEndColour = value ; }

wxColour GetPressedColourTop() const { return m_PressedColourTop ; }
void SetPressedColourTop(wxColour value) { m_PressedColourTop = value ; }

wxColour GetPressedColourBottom() const { return m_PressedColourBottom ; }
void SetPressedColourBottom(wxColour value) { m_PressedColourBottom = value ; }

/// Retrieves bitmap resources
wxBitmap GetBitmapResource( const wxString& name );

/// Retrieves icon resources
wxIcon GetIconResource( const wxString& name );
////@end wxGradientButton member function declarations

/// Should we show tooltips?
static bool ShowToolTips();

////@begin wxGradientButton member variables
wxString m_Label;
wxColour m_GradientTopStartColour;
wxColour m_GradientTopEndColour;
wxColour m_GradientBottomStartColour;
wxColour m_GradientBottomEndColour;
wxColour m_PressedColourTop;
wxColour m_PressedColourBottom;
////@end wxGradientButton member variables
};

#endif
// _WXGRADIENTBUTTON_H_

wxGradientButton.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        wxGradientButton.cpp
// Purpose:
// Author:      Volodymir (T-Rex) Tryapichko
// Modified by:
// Created:     01/08/2008 20:25:42
// RCS-ID:
// Copyright:   Volodymir (T-Rex) Tryapichko, 2008
// Licence:
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

////@begin includes
////@end includes

#include "wxGradientButton.h"
#include <wx/dcbuffer.h>

////@begin XPM images
////@end XPM images

/*!
* wxGradientButton type definition
*/

IMPLEMENT_DYNAMIC_CLASS( wxGradientButton, wxWindow )

/*!
* wxGradientButton event table definition
*/

BEGIN_EVENT_TABLE( wxGradientButton, wxWindow )

////@begin wxGradientButton event table entries
EVT_SIZE( wxGradientButton::OnSize )
EVT_PAINT( wxGradientButton::OnPaint )
EVT_ERASE_BACKGROUND( wxGradientButton::OnEraseBackground )
EVT_LEFT_DOWN( wxGradientButton::OnLeftDown )
EVT_LEFT_UP( wxGradientButton::OnLeftUp )

////@end wxGradientButton event table entries

END_EVENT_TABLE()

/*!
* wxGradientButton constructors
*/

wxGradientButton::wxGradientButton()
{
Init();
}

wxGradientButton::wxGradientButton(wxWindow* parent,
wxWindowID id, const wxString & label, const wxPoint& pos,
const wxSize& size, long style)
{
Init();
Create(parent, id, label, pos, size, style);
}

/*!
* wxGradientButton creator
*/

bool wxGradientButton::Create(wxWindow* parent,
wxWindowID id, const wxString & label, const wxPoint& pos,
const wxSize& size, long style)
{
////@begin wxGradientButton creation
wxWindow::Create(parent, id, pos, size, style);
CreateControls();
////@end wxGradientButton creation
m_Label = label;
return true;
}

/*!
* wxGradientButton destructor
*/

wxGradientButton::~wxGradientButton()
{
////@begin wxGradientButton destruction
////@end wxGradientButton destruction
}

/*!
* Member initialisation
*/

void wxGradientButton::Init()
{
////@begin wxGradientButton member initialisation
m_GradientTopStartColour = wxColour(132,125,132);
m_GradientTopEndColour = wxColour(74,69,74);
m_GradientBottomStartColour = wxColour(0,0,0);
m_GradientBottomEndColour = wxColour(57,56,57);
m_PressedColourTop = wxColour(57,56,57);
m_PressedColourBottom = wxColour(0,0,0);
////@end wxGradientButton member initialisation
}

/*!
* Control creation for wxGradientButton
*/

void wxGradientButton::CreateControls()
{
////@begin wxGradientButton content construction
this->SetForegroundColour(wxColour(255, 255, 255));
this->SetBackgroundColour(wxColour(0, 0, 0));
this->SetFont(wxFont(8, wxSWISS, wxNORMAL, wxBOLD, false, wxT("Tahoma")));
////@end wxGradientButton content construction
}

/*!
* Should we show tooltips?
*/

bool wxGradientButton::ShowToolTips()
{
return true;
}

/*!
* Get bitmap resources
*/

wxBitmap wxGradientButton::GetBitmapResource( const wxString& name )
{
// Bitmap retrieval
////@begin wxGradientButton bitmap retrieval
wxUnusedVar(name);
return wxNullBitmap;
////@end wxGradientButton bitmap retrieval
}

/*!
* Get icon resources
*/

wxIcon wxGradientButton::GetIconResource( const wxString& name )
{
// Icon retrieval
////@begin wxGradientButton icon retrieval
wxUnusedVar(name);
return wxNullIcon;
////@end wxGradientButton icon retrieval
}

wxSize wxGradientButton::DoGetBestSize() const
{
wxSize labelSize = wxDefaultSize;
GetTextExtent(m_Label, &labelSize.x, &labelSize.y);
return wxSize(wxMax(40, labelSize.x + 20), wxMax(20, labelSize.y + 10));
}

/*!
* wxEVT_PAINT event handler for ID_WXGRADIENTBUTTON
*/

void wxGradientButton::OnPaint( wxPaintEvent& event )
{
// Before editing this code, remove the block markers.
wxBufferedPaintDC dc(this);

wxRect clientRect = GetClientRect();
wxRect gradientRect = clientRect;
gradientRect.SetHeight(gradientRect.GetHeight()/2 +
((GetCapture() == this) ? 1 : 0));
if(GetCapture() != this)
{
dc.GradientFillLinear(gradientRect,
m_GradientTopStartColour, m_GradientTopEndColour, wxSOUTH);
}
else
{
dc.SetPen(wxPen(m_PressedColourTop));
dc.SetBrush(wxBrush(m_PressedColourTop));
dc.DrawRectangle(gradientRect);
}

gradientRect.Offset(0, gradientRect.GetHeight());

if(GetCapture() != this)
{
dc.GradientFillLinear(gradientRect,
m_GradientBottomStartColour, m_GradientBottomEndColour, wxSOUTH);
}
else
{
dc.SetPen(wxPen(m_PressedColourBottom));
dc.SetBrush(wxBrush(m_PressedColourBottom));
dc.DrawRectangle(gradientRect);
}
dc.SetPen(wxPen(GetBackgroundColour()));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRectangle(0, 0, clientRect.GetWidth(), clientRect.GetHeight());
dc.SetFont(GetFont());
dc.SetTextForeground(GetForegroundColour());
if(GetCapture() == this)
{
clientRect.Offset(1, 1);
}
dc.DrawLabel(m_Label, clientRect, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL);
}

/*!
* wxEVT_LEFT_DOWN event handler for ID_WXGRADIENTBUTTON
*/

void wxGradientButton::OnLeftDown( wxMouseEvent& event )
{
if(GetCapture() != this)
{
CaptureMouse();
Refresh();
}
}

/*!
* wxEVT_LEFT_UP event handler for ID_WXGRADIENTBUTTON
*/

void wxGradientButton::OnLeftUp( wxMouseEvent& event )
{
if(GetCapture() == this)
{
ReleaseMouse();
Refresh();
if(GetClientRect().Contains(event.GetPosition()))
{
wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
GetEventHandler()->AddPendingEvent(evt);
}
}
}

/*!
* wxEVT_ERASE_BACKGROUND event handler for ID_WXGRADIENTBUTTON
*/

void wxGradientButton::OnEraseBackground( wxEraseEvent& event )
{
}

/*!
* wxEVT_SIZE event handler for ID_WXGRADIENTBUTTON
*/

void wxGradientButton::OnSize( wxSizeEvent& event )
{
Refresh();
}

After you compile the code, you’ll get someting like this:

wxGradientButton under Windows Mobile

You can download the source code of sample application which uses wxGradientButton control here. Sample application compiles for Win32 and Windows Mobile 6 platforms.

Read discussion of wxGradientButton at wxForum.

Eran, автор CodeLite IDE поделился кодом класса JobQueue, который реализует пул потоков и позволяет выполнять задачи в фоновом режиме.

class MyJob : public Job {
public:
        MyJob(){}
        ~MyJob(){}

        // Implement your processing code here
        void Process() {
                wxPrintf(wxT("Just doing my work...n"));
        };
};

// define some custom job with progress report
class MyJobWithProgress : public Job {
public:
        MyJobWithProgress(wxEvtHandler *parent) : Job(parent){}
        ~MyJobWithProgress(){}

        // Implement your processing code here
        void Process() {
                // report to parent that we are at stage 0
                Post(0, wxT("Stage Zero"));
                // do the work
                wxPrintf(wxT("Just doing my work...n"));
                // report to parent that we are at stage 1
                Post(1, wxT("Stage Zero Completed!"));
        };
};

// somewhere in your code, start the JobQueue
// for the demo we use pool of size 5
JobQueueSingleton::Instance()->Start(5);

// whenever you want to process MyJob(), just create new instance of MyJob() and add it to the JobQueue
JobQueueSingleton::Instance()->AddJob( new MyJob() );

// at shutdown stop the job queue and release all its resources
JobQueueSingleton::Instance()->Stop();
JobQueueSingleton::Release();

// OR, you can use JobQueue directly without the JobQueueSingleton wrapper class
// so you could have multiple instances of JobQueue

Главный поток получает уведомления таким вот образом:

// in the event table
EVT_COMMAND(wxID_ANY, wxEVT_CMD_JOB_STATUS, MyFrame::OnJobStatus)

void MyFrame::OnJobStatus(wxCommandEvent &e)
{
    wxString msg;
    msg << wxT("Job progress: Stage: ") << e.GetInt() << wxT(" Message: ") << e.GetString();
    wxLogMessage(msg)
}

Скачать исходный код
Читать обсуждение на wxForum

Устанавливаем утилиту wxARG, копируем из папки, куда была установлена wxARG два файла wxActiveRecord.h и wxActiveRecord.cpp в папку SQLiteTest/wxActiveRecord
Здесь хотелось бы отметить, что файлы wxActiveRecord.h и wxActiveRecord.cpp из последней верчии wxARG-1.2.0-rc2 отлично собрались вместе с тестовым проектом, хотя сама утилита работала нестабильно, из-за чего мне пришлось установить поверх нее более раннюю версию wxARG-1.1.0, которая работала нормально.
Итак, запускаем wxARG и выбираем пункт меню File -> Connect to database, в диалоговом окне Database Connection указываем тип базы данных SQLite3 Database и путь к файлу addressbook.db, созданному нашим тестовым приложением. Жмем Connect

В диалоговом окне Tables выбираем таблицы groups и persons. Жмем OK

После этого в левой части главного окна wxARG появится список с выбранными таблицами.
Каждая таблица нашей базы данных имеет ключевое поле id, поэтому на вкладке Properties для каждой таблицы в поле ID Field мы указываем поле id и включаем маркер Overwrite (delete custom stuff).

В нашей базе данных между таблицами groups и persons существует связь один-ко-многим, т.е. каждая группа может содержать множество контактов адресной книги. Переходим на вкладку Relations.
Для таблицы groups:
- Жмем кнопку Has Many
- В диалоговом окне Relation Properties указываем название таблицы со стороны “многие”, в нашем случае это таблица persons
- Указываем поле внешнего ключа в таблице persons. В нашем случае это groupid
Значения остальных параметров можно оставить без изменений.

Для таблицы persons:

• Жмем кнопку Belongs To
• В диалоговом окне Relation Properties указываем название таблицы со стороны “один”, в нашем случае это таблица groups
• Указываем поле внешнего ключа в таблице persons. В нашем случае это groupid

Значения остальных параметров можно оставить без изменений.

В поле Output Dir указываем папку проекта SQLiteTest и жмем Generate
После всех проделанных операций, в папке с проектом SQLiteTest должны появиться файлы:

• Group.h
• Group.cpp
• Person.h
• Person.cpp

Эти файлы нам необходимо добавить в проект.

После того, как все необходимые файлы добавлены, можно приступать к внесению изменений в исходный код.
Для начала в файле wxActiveRecord.h не обходимо раскомментировать строку с макросом AR_USE_SQLITE, который указывает, что мы используем СУБД SQLite. В файле wxActiveRecord.cpp необходимо исправить путь к заголовочному файлу wxActiveRecord.h

wxActiveRecord.h

...
// COMMENT OUT THE ONES YOU DON'T USE

//#define AR_USE_POSTGRESQL
#define AR_USE_SQLITE
//#define AR_USE_MYSQL
//#define AR_USE_FIREBIRD
...

wxActiveRecord.cpp

...

#include "wxActiveRecord.h"

//begin WX_ACTIVE_RECORD
...

Теперь, если посмотреть на исходный код файлов, сгенерированных утилитой wxARG, то можно заметить, что каждая пара .h/.cpp файлов содержит описание и реализацию трех классов:

• XXX – класс таблицы
• XXXRow – класс типизированной записи таблицы
• XXXRowSet – типизированный список записей

где XXX – название таблицы.
И после всего сказанного, вооружившись полученными знаниями, продолжим наш “happy coding”.

SQLiteTestApp.h

...
#include <SqliteDatabaseLayer.h>
#include "Group.h"
#include "Person.h"

class SQLiteTestApp : public wxApp
{
	Group * m_GroupTable;
	Person * m_PersonTable;
	...
public:
	...
	Group * GetGroupTable();
	Person * GetPersonTable();
};
...

SQLiteTestApp.cpp

...
int SQLiteTestApp::OnExit()
{
	wxDELETE(m_PersonTable);
	wxDELETE(m_GroupTable);
	...
}

bool SQLiteTestApp::ConnectToDatabase()
{
	...
	try
	{
		m_GroupTable = new Group(wxGetApp().GetDatabase(), wxT("groups"));
		m_PersonTable = new Person(wxGetApp().GetDatabase(), wxT("persons"));
	}
	catch(DatabaseLayerException & e)
	{
		wxActiveRecord::ProcessException(e);
	}
	return true;
}
...
Group * SQLiteTestApp::GetGroupTable()
{
	return m_GroupTable;
}

Person * SQLiteTestApp::GetPersonTable()
{
	return m_PersonTable;
}

Итак, мы добавили новые члены класса SQLiteTestApp, обеспечивающие доступ к таблицам базы данных и теперь можно приступать к созданию GUI.
Дистрибутив wxWidgets содержит несколько десятков свободно распространяемых иконок, которые мы можем использовать в нашем приложении. Создадим папку SQLiteTest/art и скопируем в нее файлы

• $(WXWIN)/art/addbookm.xpm
• $(WXWIN)/art/delbookm.xpm
• $(WXWIN)/art/new.xpm
• $(WXWIN)/art/delete.xpm

SQLiteTestMainFrame.h

#ifndef _SQLITE_TEST_MAINFRAME_H
#define _SQLITE_TEST_MAINFRAME_H

#include <wx/wx.h>
#include <wx/toolbar.h>
#include <wx/listbox.h>
#include <wx/listctrl.h>
#include <wx/html/htmlwin.h>

class SQLiteTestMainFrame : public wxFrame
{
	wxListBox * m_GroupsListBox;
	wxListView * m_PersonsListView;
	wxHtmlWindow * m_PersonInfoPanel;
	void CreateControls();
	wxToolBar * CreateToolBar();
public:
	SQLiteTestMainFrame();
	bool Create(wxWindow * parent, wxWindowID id, const wxString & title);

	DECLARE_EVENT_TABLE()
	void OnExit(wxCommandEvent & event);
};

#endif

SQLiteTestMainFrame.cpp

...
#include <wx/splitter.h>
#include "new.xpm"
#include "delete.xpm"
#include "addbookm.xpm"
#include "delbookm.xpm"

enum
{
	ID_GROUPS_LISTBOX = 10001,
	ID_PERSONS_LISTCTRL,
	ID_PERSON_INFO_PANEL,
	ID_ADD_GROUP,
	ID_DELETE_GROUP,
	ID_ADD_PERSON,
	ID_DELETE_PERSON
};
...
void SQLiteTestMainFrame::CreateControls()
{
	wxMenuBar * menuBar = new wxMenuBar;
	SetMenuBar(menuBar);

	wxMenu * fileMenu = new wxMenu;
	fileMenu->Append(wxID_EXIT, _("Exit\tAlt+F4"));

	menuBar->Append(fileMenu, _("File"));

	wxBoxSizer * sizer = new wxBoxSizer(wxVERTICAL);
	SetSizer(sizer);

	wxSplitterWindow * splitter = new wxSplitterWindow(this, wxID_ANY,
		wxDefaultPosition, wxSize(500, 400), wxSP_3DSASH);
	splitter->SetMinimumPaneSize(100);
	sizer->Add(splitter, 1, wxEXPAND);

	m_GroupsListBox = new wxListBox(splitter, ID_GROUPS_LISTBOX,
		wxDefaultPosition, wxDefaultSize);

	wxSplitterWindow * personsplitter = new wxSplitterWindow(splitter, wxID_ANY,
		wxDefaultPosition, wxSize(500, 400), wxSP_3DSASH);
	personsplitter->SetMinimumPaneSize(100);
	m_PersonsListView = new wxListView(personsplitter, ID_PERSONS_LISTCTRL,
		wxDefaultPosition, wxDefaultSize, wxLC_REPORT);
	m_PersonsListView->InsertColumn(0, _("First Name"), wxLIST_FORMAT_LEFT, 120);
	m_PersonsListView->InsertColumn(1, _("Last Name"), wxLIST_FORMAT_LEFT, 120);
	m_PersonsListView->InsertColumn(2, _("E-Mail"), wxLIST_FORMAT_LEFT, 130);
	m_PersonsListView->InsertColumn(3, _("Phone"), wxLIST_FORMAT_LEFT, 130);

	m_PersonInfoPanel = new wxHtmlWindow(personsplitter, ID_PERSON_INFO_PANEL);

	personsplitter->SetSashGravity(1.0);	

	splitter->SplitVertically(m_GroupsListBox, personsplitter, 160);
	personsplitter->SplitHorizontally(m_PersonsListView, m_PersonInfoPanel,
		personsplitter->GetSize().GetHeight()-180);

	SetToolBar(CreateToolBar());

	CreateStatusBar(2);
	Centre();
}

wxToolBar * SQLiteTestMainFrame::CreateToolBar()
{
	wxToolBar * toolBar = new wxToolBar(this, wxID_ANY, wxDefaultPosition,
		wxDefaultSize, wxTB_FLAT|wxTB_TEXT);
	toolBar->AddTool(ID_ADD_GROUP, _("Add Group"), wxBitmap(addbookm_xpm));
	toolBar->AddTool(ID_DELETE_GROUP, _("Remove Group"), wxBitmap(delbookm_xpm));
	toolBar->AddSeparator();
	toolBar->AddTool(ID_ADD_PERSON, _("Add Person"), wxBitmap(new_xpm));
	toolBar->AddTool(ID_DELETE_PERSON, _("Remove Person"), wxBitmap(delete_xpm));
	toolBar->Realize();
	return toolBar;
}
...

Для работы с классом wxHtmlWindow в свойствах проекта вразделе Linker -> Input в настройках Additional Dependencies нам необходимо добавить библиотеку wxmsw28ud_html.lib для конфигурации Debug и wxmsw28u_html.lib для конфигурации Release
После всех внесенных изменений, у нас должно получиться нечто подобное:

Отлично, интерфейс приложения готов, теперь можно приступить к реализации функционала.

RecordIDClientData.h

#ifndef _RECORD_ID_CLIENT_DATA_H
#define _RECORD_ID_CLIENT_DATA_H

#include <wx/clntdata.h>

class RecordIDClientData : public wxClientData
{
	int m_ID;
public:
	RecordIDClientData(int id) : m_ID(id) {}

	int GetID() {return m_ID;}
	void SetID(int id) {m_ID = id;}
};

#endif

SQLiteTestMainFrame.h

...
#include <wx/wx.h>
#include <wx/toolbar.h>
#include <wx/listbox.h>
#include <wx/listctrl.h>
#include <wx/html/htmlwin.h>

class SQLiteTestMainFrame : public wxFrame
{
	...
	void FillGroupsList();
	void FillPersonsList(int groupid);
	...
	DECLARE_EVENT_TABLE()
	void OnExit(wxCommandEvent & event);
	void OnGroupListBoxSelected(wxCommandEvent & event);
	void OnPersonListViewSelected(wxListEvent & event);
	void OnPersonInfoPanelLinkClicked(wxHtmlLinkEvent & event);
};
...

SQLiteTestMainFrame.cpp

void SQLiteTestMainFrame::FillGroupsList()
{
	m_GroupsListBox->Freeze();
	m_GroupsListBox->Clear();
	GroupRowSet * allGroups = wxGetApp().GetGroupTable()->All();
	for(unsigned long i = 0; i < allGroups->Count(); ++i)
	{
		m_GroupsListBox->Append(allGroups->Item(i)->name,
			new RecordIDClientData(allGroups->Item(i)->id));
	}
	if(m_GroupsListBox->GetCount())
	{
		m_GroupsListBox->SetSelection(0);
		RecordIDClientData * data = (RecordIDClientData *)
			m_GroupsListBox->GetClientObject(m_GroupsListBox->GetSelection());
		if(data)
		{
			FillPersonsList(data->GetID());
		}
	}
	wxGetApp().GetGroupTable()->CollectRowSet(allGroups);
	m_GroupsListBox->Thaw();
}

void SQLiteTestMainFrame::FillPersonsList(int groupid)
{
	m_PersonsListView->Freeze();
	m_PersonsListView->DeleteAllItems();
	GroupRow * thisGroup = wxGetApp().GetGroupTable()->Id(groupid);
	if(thisGroup)
	{
		PersonRowSet * allPersons = thisGroup->GetPersons();
		long item(0);
		for(unsigned long i = 0; i < allPersons->Count(); ++i)
		{
			item = m_PersonsListView->InsertItem(item, allPersons->Item(i)->first_name);
			m_PersonsListView->SetItem(item, 1, allPersons->Item(i)->last_name);
			m_PersonsListView->SetItem(item, 2, allPersons->Item(i)->email);
			m_PersonsListView->SetItem(item, 3, allPersons->Item(i)->phone);
			m_PersonsListView->SetItemData(item, (long)allPersons->Item(i)->id);
		}
		thisGroup->CollectRowSet(allPersons);
		if(m_PersonsListView->GetItemCount())
		{
			m_PersonsListView->Select(0);
		}
		else
		{
			m_PersonInfoPanel->SetPage(wxT("<html><body></body></html>"));
		}
	}
	wxGetApp().GetGroupTable()->CollectRow(thisGroup);
	m_PersonsListView->Thaw();
}

void SQLiteTestMainFrame::
        OnGroupListBoxSelected(wxCommandEvent & event)
{
 RecordIDClientData * data =
     (RecordIDClientData *)event.GetClientObject();
 if(data)
 {
  FillPersonsList(data->GetID());
 }
}

void SQLiteTestMainFrame::OnPersonListViewSelected(wxListEvent & event)
{
	long personid = event.GetData();
	PersonRow * person = wxGetApp().GetPersonTable()->Id((int)personid);
	if(person)
	{
		m_PersonInfoPanel->SetPage(wxString::Format(
			wxT("<html><body><h3>%s %s<h3><body><html>"),
			person->first_name, person->last_name));
		m_PersonInfoPanel->AppendToPage(wxString::Format(
			wxT("<b>Gender: </b> %s"),
			(person->gender?wxT("Male"):wxT("Female"))));
		m_PersonInfoPanel->AppendToPage(wxT("<hr>"));
		m_PersonInfoPanel->AppendToPage(wxString::Format(
			wxT("<b>Address: </b> %s<br>"),
			person->address.GetData()));
		m_PersonInfoPanel->AppendToPage(wxString::Format(
			wxT("<b>City: </b> %s<br>"),
			person->city.GetData()));
		m_PersonInfoPanel->AppendToPage(wxString::Format(
			wxT("<b>Country: </b> %s"),
			person->country.GetData()));
		m_PersonInfoPanel->AppendToPage(wxT("<hr>"));
		m_PersonInfoPanel->AppendToPage(
			wxString::Format(wxT("<b>Phone: </b> %s<br>"),
			person->phone.GetData()));
		m_PersonInfoPanel->AppendToPage(wxString::Format(
			wxT("<b>E-mail: </b> <a href=\"mailto:%s\">%s</a><br>"),
			person->email, person->email.GetData()));
	}
	else
	{
		m_PersonInfoPanel->SetPage(
			_("<html><body><h3>Can't find info about selected person<h3><body><html>"));
	}
}

void SQLiteTestMainFrame::
    OnPersonInfoPanelLinkClicked(wxHtmlLinkEvent & event)
{
#if defined(__WXMSW__)
 ShellExecute(NULL, NULL,
     event.GetLinkInfo().GetHref().GetData(),
     NULL, NULL, SW_SHOW);
#else
 wxExecute(event.GetLinkInfo().GetHref());
#endif
}

Список в левой части окна содержит названия групп. Каждый элемент списка содержит код группы. Привязка данных к элементам списка реализована с помощью объектов класса RecordIDClientData, каждый объект которого содержит код группы. Класс RecordIDClientData является производным от wxClientData и его использование обеспечивает автоматическую очистку памяти при удалении элемента списка. Доступ к данным, ассоциированным с элементом списка групп, производится посредством метода GetClientObject класса wxListBox
При выборе записи в списке групп, список контактов в правой части окна заполняется данными контактов данной группы.

При выборе элемента списка контактов, информационное поле в нижней части окна заполняется данными контакта, связанного с выбранным элементом списка. Каждый элемент списка контактов содержит в поле данных код контакта. Доступ к полю данных производится посредством метода GetItemData класса wxListView

При нажатии на ссылку с адресом электронной почты в информационном поле, создается новое письмо в почтовом клиенте, назначенном по умолчанию.

Итак, с отображением данных мы закончили. Теперь нужно реализовать добавление новой записи в таблицу и удаление записей из таблицы.
Для начала создадим диалоговые окна вода данных.

EditGroupDialog.h

#ifndef _EDIT_GROUP_DIALOG_H
#define _EDIT_GROUP_DIALOG_H

#include <wx/wx.h>

class EditGroupDialog : public wxDialog
{
	wxString m_GroupName;
	wxString m_GroupDescription;
	void CreateControls();
public:
	EditGroupDialog(wxWindow * parent);
	bool Create(wxWindow * parent, wxWindowID id, const wxString title);

	const wxString & GetGroupName();
	void SetGroupName(const wxString & value);
	const wxString & GetGroupDescription();
	void SetGroupDescription(const wxString & value);
};

#endif

EditGroupDialog.cpp

#include "EditGroupDialog.h"
#include <wx/valgen.h>

enum
{
	ID_EGD_NAME_TEXTCTRL = 10001,
	ID_EGD_DESCRIPTION_TEXTCTRL
};

EditGroupDialog::EditGroupDialog(wxWindow * parent)
{
	Create(parent, wxID_ANY, _("Editing group"));
}

bool EditGroupDialog::Create(wxWindow * parent, wxWindowID id, const wxString title)
{
	bool res = wxDialog::Create(parent, id, title);
	if(res)
	{
		CreateControls();
	}
	return res;
}

void EditGroupDialog::CreateControls()
{
	wxBoxSizer * sizer = new wxBoxSizer(wxVERTICAL);
	SetSizer(sizer);

	wxStaticText * nameLabel = new wxStaticText(this, wxID_ANY, _("Name:"));
	wxStaticText * descriptionLabel = new wxStaticText(this, wxID_ANY, _("Description:"));

	wxTextCtrl * nameEdit = new wxTextCtrl(this, ID_EGD_NAME_TEXTCTRL, wxEmptyString);
	wxTextCtrl * descriptionEdit = new wxTextCtrl(this, ID_EGD_DESCRIPTION_TEXTCTRL,
		wxEmptyString, wxDefaultPosition, wxSize(-1, 150), wxTE_MULTILINE);
	nameEdit->SetValidator(wxGenericValidator(&m_GroupName));
	descriptionEdit->SetValidator(wxGenericValidator(&m_GroupDescription));

	wxFlexGridSizer * fg_sizer = new wxFlexGridSizer(2, 2, 0, 0);
	fg_sizer->Add(nameLabel, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(nameEdit, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(descriptionLabel, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(descriptionEdit, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->AddGrowableCol(1);

	sizer->Add(fg_sizer, 1, wxEXPAND|wxTOP|wxLEFT|wxRIGHT, 5);
	sizer->Add(CreateButtonSizer(wxID_OK|wxID_CANCEL), 0, wxALIGN_RIGHT|wxALL, 5);
}

const wxString & EditGroupDialog::GetGroupName()
{
	return m_GroupName;
}

void EditGroupDialog::SetGroupName(const wxString & value)
{
	m_GroupName = value;
}

const wxString & EditGroupDialog::GetGroupDescription()
{
	return m_GroupDescription;
}

void EditGroupDialog::SetGroupDescription(const wxString & value)
{
	m_GroupDescription = value;
}

EditPersonDialog.h

#ifndef _EDIT_PERSON_DIALOG_H
#define _EDIT_PERSON_DIALOG_H

#include <wx/wx.h>

class EditPersonDialog : public wxDialog
{
	wxString m_FirstName;
	wxString m_LastName;
	wxString m_Address;
	wxString m_City;
	wxString m_Country;
	wxString m_Email;
	wxString m_Phone;
	void CreateControls();
public:
	EditPersonDialog(wxWindow * parent);
	bool Create(wxWindow * parent, wxWindowID id, const wxString title);

	const wxString & GetFirstName();
	const wxString & GetLastName();
	const wxString & GetAddress();
	const wxString & GetCity();
	const wxString & GetCountry();
	const wxString & GetEmail();
	const wxString & GetPhone();
};

#endif

EditPersonDialog.cpp

#include "EditPersonDialog.h"
#include <wx/valgen.h>

enum
{
	ID_EPD_FIRSTNAME_TEXTCTRL = 10001,
	ID_EPD_LASTNAME_TEXTCTRL,
	ID_EPD_ADDRESS_TEXTCTRL,
	ID_EPD_CITY_TEXTCTRL,
	ID_EPD_COUNTRY_TEXTCTRL,
	ID_EPD_EMAIL_TEXTCTRL,
	ID_EPD_PHONE_TEXTCTRL
};

EditPersonDialog::EditPersonDialog(wxWindow * parent)
{
	Create(parent, wxID_ANY, _("Editing person"));
}

bool EditPersonDialog::Create(wxWindow * parent,
wxWindowID id, const wxString title)
{
	bool res = wxDialog::Create(parent, id, title);
	if(res)
	{
		CreateControls();
	}
	return res;
}

void EditPersonDialog::CreateControls()
{
	wxBoxSizer * sizer = new wxBoxSizer(wxVERTICAL);
	SetSizer(sizer);

	wxStaticText * firstnameLabel = new wxStaticText(this, wxID_ANY, _("First Name:"));
	wxStaticText * lastnameLabel = new wxStaticText(this, wxID_ANY, _("Last Name:"));
	wxStaticText * addressLabel = new wxStaticText(this, wxID_ANY, _("Address:"));
	wxStaticText * cityLabel = new wxStaticText(this, wxID_ANY, _("City:"));
	wxStaticText * countryLabel = new wxStaticText(this, wxID_ANY, _("Country:"));
	wxStaticText * emailLabel = new wxStaticText(this, wxID_ANY, _("E-mail:"));
	wxStaticText * phoneLabel = new wxStaticText(this, wxID_ANY, _("Phone:"));

	wxTextCtrl * firstnameEdit = new wxTextCtrl(this, ID_EPD_FIRSTNAME_TEXTCTRL, wxEmptyString);
	wxTextCtrl * lastnameEdit = new wxTextCtrl(this, ID_EPD_LASTNAME_TEXTCTRL, wxEmptyString);
	wxTextCtrl * addressEdit = new wxTextCtrl(this, ID_EPD_ADDRESS_TEXTCTRL, wxEmptyString);
	wxTextCtrl * cityEdit = new wxTextCtrl(this, ID_EPD_CITY_TEXTCTRL, wxEmptyString);
	wxTextCtrl * countryEdit = new wxTextCtrl(this, ID_EPD_COUNTRY_TEXTCTRL, wxEmptyString);
	wxTextCtrl * emailEdit = new wxTextCtrl(this, ID_EPD_EMAIL_TEXTCTRL, wxEmptyString);
	wxTextCtrl * phoneEdit = new wxTextCtrl(this, ID_EPD_PHONE_TEXTCTRL, wxEmptyString);

	firstnameEdit->SetMinSize(wxSize(150,-1));

	firstnameEdit->SetValidator(wxGenericValidator(&m_FirstName));
	lastnameEdit->SetValidator(wxGenericValidator(&m_LastName));
	addressEdit->SetValidator(wxGenericValidator(&m_Address));
	cityEdit->SetValidator(wxGenericValidator(&m_City));
	countryEdit->SetValidator(wxGenericValidator(&m_Country));
	emailEdit->SetValidator(wxGenericValidator(&m_Email));
	phoneEdit->SetValidator(wxGenericValidator(&m_Phone));

	wxFlexGridSizer * fg_sizer = new wxFlexGridSizer(2, 2, 0, 0);
	fg_sizer->Add(firstnameLabel, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(firstnameEdit, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(lastnameLabel, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(lastnameEdit, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(addressLabel, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(addressEdit, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(cityLabel, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(cityEdit, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(countryLabel, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(countryEdit, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(emailLabel, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(emailEdit, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(phoneLabel, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->Add(phoneEdit, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5);
	fg_sizer->AddGrowableCol(1);

	sizer->Add(fg_sizer, 1, wxEXPAND|wxTOP|wxLEFT|wxRIGHT, 5);
	sizer->Add(CreateButtonSizer(wxID_OK|wxID_CANCEL), 0, wxALIGN_RIGHT|wxALL, 5);

	sizer->Fit(this);
}

const wxString & EditPersonDialog::GetFirstName()
{
	return m_FirstName;
}

const wxString & EditPersonDialog::GetLastName()
{
	return m_LastName;
}

const wxString & EditPersonDialog::GetAddress()
{
	return m_Address;
}

const wxString & EditPersonDialog::GetCity()
{
	return m_City;
}

const wxString & EditPersonDialog::GetCountry()
{
	return m_Country;
}

const wxString & EditPersonDialog::GetEmail()
{
	return m_Email;
}

const wxString & EditPersonDialog::GetPhone()
{
	return m_Phone;
}

Теперь можно приступать к написанию обработчиков событий от кнопок на панели инструментов.

SQLiteTestMainFrame.h

...
class SQLiteTestMainFrame : public wxFrame
{
	...
	void OnAddGroup(wxCommandEvent & event);
	void OnRemoveGroup(wxCommandEvent & event);
	void OnAddPerson(wxCommandEvent & event);
	void OnRemovePerson(wxCommandEvent & event);
	void OnRemoveGroupUpdateUI(wxUpdateUIEvent & event);
	void OnAddPersonUpdateUI(wxUpdateUIEvent & event);
	void OnRemovePersonUpdateUI(wxUpdateUIEvent & event);
};
...

SQLiteTestMainFrame.cpp

...
void SQLiteTestMainFrame::OnAddGroup(wxCommandEvent & event)
{
	EditGroupDialog * dlg = new EditGroupDialog(this);
	if(dlg->ShowModal() == wxID_OK)
	{
		GroupRow * newGroup = wxGetApp().GetGroupTable()->New();
		newGroup->name = dlg->GetGroupName();
		newGroup->description = dlg->GetGroupDescription();
		newGroup->Save();
		wxGetApp().GetGroupTable()->CollectRow(newGroup);
		FillGroupsList();
	}
	dlg->Destroy();
}

void SQLiteTestMainFrame::OnRemoveGroup(wxCommandEvent & event)
{
	int selection = m_GroupsListBox->GetSelection();
	RecordIDClientData * data = (RecordIDClientData *)
		m_GroupsListBox->GetClientObject(selection);
	if(data)
	{
		GroupRow * thisGroup = wxGetApp().GetGroupTable()->Id(data->GetID());
		if(thisGroup && (wxMessageBox(_("Do you really want to delete this group?"),
			_("Delete group"), wxYES_NO) == wxYES))
		{
			PersonRowSet * thisPersons = thisGroup->GetPersons();
			for(unsigned long i = 0; i < thisPersons->Count(); ++i)
			{
				thisPersons->Item(i)->Delete();
			}
			thisGroup->CollectRowSet(thisPersons);
			thisGroup->Delete();
			wxGetApp().GetGroupTable()->CollectRow(thisGroup);
			m_GroupsListBox->Delete(selection);
			if(m_GroupsListBox->GetCount())
			{
				m_GroupsListBox->SetSelection(selection <
					(int)m_GroupsListBox->GetCount() ? selection : 0);
				data = (RecordIDClientData *)m_GroupsListBox->GetClientObject(
					m_GroupsListBox->GetSelection());
				if(data)
				{
					FillPersonsList(data->GetID());
				}
			}
		}
	}
}

void SQLiteTestMainFrame::OnAddPerson(wxCommandEvent & event)
{
	RecordIDClientData * data = (RecordIDClientData *)
		m_GroupsListBox->GetClientObject(m_GroupsListBox->GetSelection());
	if(data)
	{
		GroupRow * thisGroup = wxGetApp().GetGroupTable()->Id(data->GetID());
		if(thisGroup)
		{
			EditPersonDialog * dlg = new EditPersonDialog(this);
			if(dlg->ShowModal() == wxID_OK)
			{
				PersonRow * newPerson = wxGetApp().GetPersonTable()->New();
				newPerson->groupid= thisGroup->id;
				newPerson->first_name = dlg->GetFirstName();
				newPerson->last_name = dlg->GetLastName();
				newPerson->address = dlg->GetAddress();
				newPerson->city = dlg->GetCity();
				newPerson->country = dlg->GetCountry();
				newPerson->email = dlg->GetEmail();
				newPerson->phone = dlg->GetPhone();
				newPerson->Save();
				wxGetApp().GetPersonTable()->CollectRow(newPerson);
				FillPersonsList(thisGroup->id);
			}
			dlg->Destroy();
		}
		wxGetApp().GetGroupTable()->CollectRow(thisGroup);
	}
}

void SQLiteTestMainFrame::OnRemovePerson(wxCommandEvent & event)
{
	long selection = m_PersonsListView->GetFirstSelected();
	PersonRow * thisPerson = wxGetApp().GetPersonTable()->Id(
		(int)m_PersonsListView->GetItemData(selection));
	if(thisPerson && (wxMessageBox(_("Do you really want to delete this record?"),
		_("Delete person"), wxYES_NO) == wxYES))
	{
		int groupid = thisPerson->groupid;
		thisPerson->Delete();
		wxGetApp().GetPersonTable()->CollectRow(thisPerson);
		m_PersonsListView->DeleteItem(selection);
		if(m_PersonsListView->GetItemCount())
		{
			m_PersonsListView->Select(wxMin(selection, m_PersonsListView->GetItemCount()-1));
		}
	}
}

void SQLiteTestMainFrame::
        OnRemoveGroupUpdateUI(wxUpdateUIEvent & event)
{
 event.Enable(m_GroupsListBox->GetSelection() >= 0);
}

void SQLiteTestMainFrame::
        OnAddPersonUpdateUI(wxUpdateUIEvent & event)
{
 event.Enable(m_GroupsListBox->GetSelection() >= 0);
}

void SQLiteTestMainFrame::
        OnRemovePersonUpdateUI(wxUpdateUIEvent & event)
{
 event.Enable(m_PersonsListView->GetFirstSelected() >= 0);
}
...

Как видно, кнопка удаления группы и кнопка добавления контакта активна только в случае, если есть активная запись в списке групп. Кнопка удаления контакта становится активной только в случае, если есть активная запись в списке контактов.
При удалении группы удаляются и все связанные с ней контакты.

Ну вот. Мы закончили. Теперь собираем Release-версию программы и тестируем. Можно переходить к созданию проекта под Linux
Продолжение статьи можно почитать здесь.