a2dView Class Reference
[Objects in docview frame work.]

Holds a view on a a2dDocument. More...

#include <docviewref.h>

Inheritance diagram for a2dView:

Inheritance graph
[legend]
Collaboration diagram for a2dView:

Collaboration graph
[legend]

List of all members.

Public Member Functions

 a2dView ()
 constructor
 ~a2dView ()
 destructor
 a2dView (const a2dView &other)
 construct with other view
bool IsClosed ()
 A closed flag is set when a view is closed.
void SetClosed ()
 sets closed flag to true, and calls Release() view.
bool Enable (bool enable)
 returns true if view was enabled/disabled, false if nothing done
bool GetEnabled ()
 return true if the view is enabled. See Enable()
virtual void SetDisplayWindow (wxWindow *display)
 Set the display window.
wxWindow * GetDisplayWindow ()
 Get the display window.
wxUint32 GetId ()
 Get the id of the view (used for identification in event processing.
a2dDocument * GetDocument () const
 get the document of the view
void SetDocument (a2dDocument *doc)
 Set the document for the view and add it to the document its viewlist.
wxString GetViewTypeName () const
 get type name of the view.
a2dViewTemplate * GetViewTemplate () const
 get the a2dViewTemplate with which this view was created
void SetViewTemplate (a2dViewTemplate *viewtemplate)
 to set the view template from which this view was created.
void SetViewTypeName (const wxString &name)
 set type name of the view.
virtual void OnDraw (wxDC *dc)=0
 needs to be implemented to print a view, also so used for simple redrawing of views.
virtual void OnPrint (wxDC *dc, wxObject *info)
 called from a2dDocumentPrintout when printing a view.
virtual void Update (unsigned int hint=0, wxObject *hintObject=NULL)
 force a2dDocumentEvent wxEVT_UPDATE_VIEWS event
void OnUpdate (a2dDocumentEvent &event)
 default handler for a2dDocumentEvent wxEVT_UPDATE_VIEWS
void OnEnableViews (a2dDocumentEvent &event)
 default handler for a2dDocumentEvent of type wxEVT_ENABLE_VIEWS
void OnReport (a2dDocumentEvent &event)
 handler for the wxEVT_REPORT_VIEWS
void OnEnable (a2dViewEvent &event)
 default handler for EVT_ENABLE_VIEW event.
void OnChangeFilename (a2dDocumentEvent &event)
 default handler for file changed event sent from a2dDocument with type wxEVT_CHANGEDFILENAME_DOCUMENT
void OnChangeTitle (a2dDocumentEvent &event)
 default handler for file changed event sent from a2dDocument with type wxEVT_CHANGEDTITLE_DOCUMENT
virtual bool Close (bool force=false)
 Close a view and remove the view from its document.
void OnCloseView (a2dCloseViewEvent &event)
 wxEVT_CLOSE_VIEW event handler to do cleanup/veto Close of the view.
void OnDisConnectView (a2dDocumentEvent &event)
 handler for wxEVT_DISCONNECT_ALLVIEWS
virtual bool ProcessEvent (wxEvent &event)
 Extend event processing to search the view's event table.
void Activate (bool activate)
 is called via ProcessEvent() when the view becomes active
bool GetActive ()
 return if the view is active/
void SetDoDistributeActivateEvent (bool doDistributeActivateEvent)
virtual wxPrintout * OnCreatePrintout (a2dCommand *typeOfPrint)
 called from the a2dDocumentCommandProcessor to create a wxPrintout are derived class

Protected Member Functions

void OnSetFocus (wxFocusEvent &event)
 called on (de)activating (wxWindow) containing the view.
void OnKillFocus (wxFocusEvent &event)
 when a view goes out of focus ( when only one view per window

Protected Attributes

bool m_isClosed
 close flag, to indicate that the view is being closed are is closed.
a2dSmrtPtr< a2dDocument > m_viewDocument
 the document to which this view belongs.
wxString m_viewTypeName
 set via the a2dViewTemplate on generation of this view.
a2dViewTemplatePtr m_viewTemplate
 view was created from this view template or if not used NULL
bool m_active
 true if this view is activated ( its display window has the focus and recieves mouse events )
bool m_DoDistributeActivateEvent
 true if this view does distribute the does Distribute the wxEVT_ACTIVATE_VIEW event.
bool m_viewEnabled
 Is the view enabled?
wxWindow * m_display
 In case of using a window for displaying the view, this holds the window.
wxUint32 m_id
 This identifies the view in event processing.
a2dSmrtPtr< a2dView > m_keepalive

Friends

class a2dSmrtPtrBase

Detailed Description

Holds a view on a a2dDocument.

A a2dView is used for displaying a (part of) a2dDocument its data. It may display this data in any form it wants to. Several a2dView's can exist on a a2dDocument, and they can be of different types. A a2dView displays data stored in wxDocument's. A document can be set for a view, and this will be used by the view to check if wxEVT_UPDATE_VIEWS events coming from the documents, are meant for the view or not. If a view wants to display the data of several documents, this should be arranged in a derived class.

The views using a document work independent of eachother. When using a a2dDocumentCommandProcessor class, this will know the currently active view, in general this is the view which has the focus. Meaning its display window has the focus.

The a2dDocument class uses the a2dEventDistributer to distribute events. a2dView's register themselfs to the a2dEventDistributer, and therefore will receive those events. Any wxEvtHandler derived class may be registered to the a2dEventDistributer. The document does not know all this, it just sent events.

The view may display the data it found in the document, directly to the device or in a delayed fashion. In which case it stores the data to display first locally, and as soon as possible this data is updated to the device ( e.g. a window. ) If the device is a window, the m_display holds a pointer to it.

Views display the data in a document, and therefore if the document data changes, the view might change because of that. The wxDocument::UpdateAllViews() is sending wxEVT_UPDATE_VIEWS to the docmanager, and this sents the event to all registered a2dView's. a2dView::OnUpdate() will handle the event. It checks if it want to process the event coming from that particular document, and if so updates its own data from that document. To update all views at every small change made to the document, is often not desired. Checking a "pending flag" inside the document when the program becomes idle is a better way to update the views.

Often the view is a rectangular drawing area. The view can use a wxWindow derived class to display itself. But this is not a must, a view may be stored anywhere. A view might also display parts of a document(s) via wxDialogs. How and what is displayed on a view depends on the derived class.

The way to update what is displayed by the view needs to be defined in the handler for wxEVT_UPDATE_VIEWS event. The default OnUpdate, just calls refresh on the display window. Changes in the document need to result in calling OnUpdate for each view. OnUpdate may decide to directly redrawn on the device, or only store the view data locally. In the last case a flag is set to indicate that the view has changed. This flag is checked in idle time, resulting in an update of the device eventually. This is the principle behind calling m_display->Refresh() after changing a document or a view its display data. This will result in a wxPaintEvent, which will redraw the view data.

When the display device is a window, the wxPaintEvent event handled in the window, may request a redraw of certain areas within the view. The view may do this by actually redrawing directly from the document, or in case of local stored data, return/redraw only this locally stored data directly on the window. In some cases the data displayed on the window, is actually stored locally within the window, and the window handles paint events itself, without asking the view to redisplay the damaged areas ( e.g. wxTextCtrl. etc. ). Still the window will need to check if the view or document did change, to keep its contents up to date. The member a2dView::OnDraw( wxDC* ) can be used by the display window, to have the view redraw itself on the window. But of course if not using wxDC based views, any other method can be used. The important thing to understand, is that the Updating of a a2dView can happen at time X, while the display of this updated view can happen at time Y. Therefore several updates on a view might take place before they are actually redisplayed.

For printing the view in a2dView::OnPrint(wxDC *dc), you may use Ondraw to print the contents of a view to a wxDC. For that you should define a way to draw the view its data on a wxDC.

Events which are sent to a2dView:

All events coming from a2dDocviewGlobals->GetEventDistributer() so also DistributeEvent(), since a a2dView is by default Registered to it.

In general all wxWindow events of m_display or the wxFrame containing the a2dView

View specific events.

Definition at line 1960 of file docviewref.h.

Constructor & Destructor Documentation

a2dView::a2dView (  ) 

constructor

the view owns itself until Close() or SetClosed()

Definition at line 1441 of file docviewref.cpp.

Member Function Documentation

bool a2dView::IsClosed (  )  [inline]

A closed flag is set when a view is closed.

This flag is set just before the actual closing will take place. If the close is vetod, it will be reset at the end of the closing action, else it will stay true. The flag is a handy test for associated windows, to see if their view is already closed or not.

Definition at line 1985 of file docviewref.h.

void a2dView::SetClosed (  ) 

sets closed flag to true, and calls Release() view.

Normally Close() should be used, but in cases where a view is used temporarely and without a display window ( e.g using a view for rendering to bitmap ), this can be used to properly close a view without sending extra events.

Definition at line 1738 of file docviewref.cpp.

bool a2dView::Enable ( bool  enable  ) 

returns true if view was enabled/disabled, false if nothing done

Sets the view enabled or disabled, which means that no events will be processed, except wxEVT_ENABLE_VIEW and wxEVT_ENABLE_VIEWS.

The wxEVT_ENABLE_VIEW event is sent to the view and the display window (if available). After that the new state is set.

If the view is already in the requested state, nothing is done.

Definition at line 1521 of file docviewref.cpp.

void a2dView::SetDisplayWindow ( wxWindow *  display  )  [virtual]

Set the display window.

The display window can be used to display the view on a wxWindow. This is not a must, since a view might also be displayed into a bitmap etc. But in that case this needs to be arranged in a derived class. The default is using a display wxWindow.

The window may be set in a derived view class. But often it is better to set it from a specialized a2dViewConnector. If needed in combination with a specialized a2dViewTemplate. This makes it easier to make general view classes, which can be used in several types of applications or display windows.

Remarks:
this function has only effect if the view its eventhandler is enabled. The reason is that some events like a2dCloseViewEvent are set up to the m_display window, during that time the event handler is disabled to prevent looping. But also the m_display should stay constant during that time.

Reimplemented in a2dCanvasView.

Definition at line 1509 of file docviewref.cpp.

a2dDocument* a2dView::GetDocument (  )  const [inline]

get the document of the view

Returns:
NULL if no document is set.

Definition at line 2038 of file docviewref.h.

void a2dView::SetDocument ( a2dDocument *  doc  ) 

Set the document for the view and add it to the document its viewlist.

Normally called by the framework.

If the view already has a document set, the view is first removed from that document, sending a wxEVT_REMOVE_VIEW event to the old document, the same event is distributed application broad via the a2dDocviewGlobals->GetEventDistributer(). See a2dDocumentCommandProcessor::OnRemoveView() where this event is used to reset the last active view.

Next the new document will be set for the view, and added to the viewlist of the new document, sending a wxEVT_ADD_VIEW event to the new document.

At last a a2dViewEvent event of type wxEVT_SET_DOCUMENT is sent to the a2dView. So if extra administrative tasks for the view are needed when setting a view to a document, intercept that event to do it.

Definition at line 1560 of file docviewref.cpp.

wxString a2dView::GetViewTypeName (  )  const [inline]

get type name of the view.

This name is used to couple document types to view types. See a2dViewTemplate.

Definition at line 2064 of file docviewref.h.

a2dViewTemplate* a2dView::GetViewTemplate (  )  const [inline]

get the a2dViewTemplate with which this view was created

See also:
a2dViewTemplate.

Definition at line 2070 of file docviewref.h.

void a2dView::SetViewTypeName ( const wxString &  name  )  [inline]

set type name of the view.

This name is used to couple document types to view types. See a2dViewTemplate.

Definition at line 2080 of file docviewref.h.

virtual void a2dView::OnDraw ( wxDC *  dc  )  [pure virtual]

needs to be implemented to print a view, also so used for simple redrawing of views.

Normal updating the data of a view, is via OnUpdate, called from the changed a2dDocument. Once the view its data is up to data, m_display->Refresh() results in a paint event. This in a2dDocumentViewScrolledWindow and a2dDocumentViewWindow directly leads to OnDraw(), redrawing the data of the view on the display window. In a2dDocumentViewScrolledWindow and a2dDocumentViewWindow the wxPaintEvent is intercepted and by default redirected via its OnDraw() to the view Ondraw() function here. If it is a clever implementation, the above refresh should only refresh the areas in the view which did change. In m_display->GetUpdateRegion() is where you should get those regions, while the paint event is being handled.

A more complicated situation is as follows. Paint events are generated when a wxWindow becomes visible, or when you draw something to it. The regions needing an update, or reported by the Paint event. The view does not need to do a complete re-drawn, only the damaged regions. In such a case you should Handle the paint event Your self in the m_display window, and redirect it to the a2dView. In the a2dView you can iterate over the damaged regions, and only redraw the view its data in those regions.

Implemented in a2dCanvasView.

void a2dView::OnPrint ( wxDC *  dc,
wxObject *  info 
) [virtual]

called from a2dDocumentPrintout when printing a view.

Default calls OnDraw(wxDC *dc)

Definition at line 1820 of file docviewref.cpp.

void a2dView::OnUpdate ( a2dDocumentEvent &  event  ) 

default handler for a2dDocumentEvent wxEVT_UPDATE_VIEWS

Updates the view data ( e.g the data that the view displays has changed in the document). The view may hold/display data which should change when the document(s) changes. Here this data can be updated, the internal data of the view can be updated. When the view will be redisplayed depends on the derived class. One can set a dirty flag after changing the view its data, and do the redisplay in idle time, where this flag is checked. But often there is no need to do this, since the view can directly update its Display window, or tell it that it needs to update itself. Therefore the default here simply calls m_display->Refresh(), which leads to a paint event on the display window, and that might/should call a2dView::Ondraw().

Reimplemented in a2dCanvasView.

Definition at line 1836 of file docviewref.cpp.

void a2dView::OnEnableViews ( a2dDocumentEvent &  event  ) 

default handler for a2dDocumentEvent of type wxEVT_ENABLE_VIEWS

This enable or disables the view by calling Enable( event.GetEnable() ). But only if the a2dDocument from which this document was sent, is the one the a2dView is using. If the view from which the event originated is specified in the event, that view will not process the event, all others will.

Definition at line 1857 of file docviewref.cpp.

void a2dView::OnReport ( a2dDocumentEvent &  event  ) 

handler for the wxEVT_REPORT_VIEWS

The handlers adds this a2dView to the reportlist of the event, if it depends on the document sending the event. The default simply checks that the view its document is the one sending the event, and if so adds it. In case your view displays info of several documents, you should intercept this event to implement this behaviour.

Definition at line 1842 of file docviewref.cpp.

void a2dView::OnChangeFilename ( a2dDocumentEvent &  event  ) 

default handler for file changed event sent from a2dDocument with type wxEVT_CHANGEDFILENAME_DOCUMENT

Creates new event of type wxEVT_CHANGEDFILENAME_VIEW, which also knows the view now. Sends the event to the DisplayWindow, there or in its parent hiearchy it can be intercepted.

Definition at line 1865 of file docviewref.cpp.

void a2dView::OnChangeTitle ( a2dDocumentEvent &  event  ) 

default handler for file changed event sent from a2dDocument with type wxEVT_CHANGEDTITLE_DOCUMENT

Creates new event of type wxEVT_CHANGEDTITLE_VIEW, which also knows the view now. Sends the event to the DisplayWindow, there or in its parent hiearchy it can be intercepted.

Definition at line 1885 of file docviewref.cpp.

bool a2dView::Close ( bool  force = false  )  [virtual]

Close a view and remove the view from its document.

IMPORTANT there are two ways/paths through which a view can be closed.

  1. by closing the frame containing the view(s).
  2. by the docmanager closing a document and this one closing the views on the document.

The first one will destroy the frames, and it must Close the view(s) it contains. The second one must make sure that the frames containing the views will be destroyed. This is why wxEVT_CLOSE_VIEW travels up in the hiearchy of windows, starting at m_display window.

Close() generates a wxEVT_CLOSE_VIEW event, which is first redirected to the a2dDocument, and if not vetod there, to the m_display wxWindow. if not vetod there, the event is sent to a2dView itself.

If not vetod in the wxEVT_CLOSE_VIEW handler of the view, the View Will be removed and released from the document. The view will be set Inactive. The m_display wxWindow will be disabled, to prevent it from sending more events.

When the wxEVT_CLOSE_VIEW is sent to the m_display window, the a2dView itself is disabled for handling events, untill the event is (not)processed by the display and return. So event coming back to the view will not be handled during that time. The wxEVT_CLOSE_VIEW is sent to m_display, but the event is of the type that travels up to the parent window if not handled. So if not handled in the display window, it will go to the parent window. Eventually it arives in the wxFrame holding the windows. The idea is thay you do intercept wxEVT_CLOSE_VIEW event somewhere in the hierarchy of windows, and make sure the a2dView is correctly detached from the windows where it is used. In case the event is not vetod by the display window, it is a good habbit that it sets the display window of this/its view to NULL, this will prevent events coming from this view to the display window for sure.

This is the clue to having view independent frames and windows. A specialized frame or window, can use different types of connectors to deal with different types of attached views.

Always be aware of dangling pointers from the display window, which normally will/should have a pointer to the view. Also other classes having somehow a pointer to this view (which will be closed and released soon), should take care of this by intercepting the wxEVT_CLOSE_VIEW event. Therefore the display window, in such cases should redirect the wxEVT_CLOSE_VIEW event to such classes. Default the event will be redirected to the parent window, if not handled or skipped.

When not vetod Close() the DisplayWindow m_display is set to NULL first. The reason for disabling the display window is to prevent it from sending more events to this view, which will be deleted soon.

In any case the wxEVT_CLOSE_VIEW handler should check whether the view is being deleted forcibly, using a2dCloseViewEvent::CanVeto(). If so it needs to perform the nessecary cleanup. Else it may veto.

Example:

        //the next class interecepts the ::wxEVT_CLOSE_VIEW
        void wxSomeClass::OnCloseView( a2dCloseViewEvent& event )
        {
            //test if the frame or windows where not already deleted
            //
            if ( event.GetForce() && GetViewFrame() )
            {
                event.GetView()->SetDisplayWindow( NULL );
                m_display->Disable();
                m_display->Destroy();
                m_display = NULL;
            }
        }

Closing a view recursive, while its busy closing itself is not a problem. The owning objects may recursively call this function without problem, for that the m_isClosed flag is set at the beginning which prevents closing twice. the view object itself will be released only once in the end. The wxEVT_CLOSE_VIEW will be issued only once.

If the view has a document set, the view is first removed from that document, sending a wxEVT_REMOVE_VIEW event to the old document, the same event is distributed application broad via the a2dDocviewGlobals->GetEventDistributer(). See a2dDocumentCommandProcessor::OnRemoveView() where this event is used to reset the last active view.

Remarks:
a2dView is reference counted and will only be really deleted when it reaches zero

In wxWindows the handler function for wxEVT_CLOSE_WINDOW event is called when the user has tried to close a frame using the window manager (X) or system menu (Windows). The CLOSE_WINDOW event should normally be intercepted, and ask via calling a2dView::Close if it is oke to close the view. In a2dDocumentFrame this arranged.

You may call also a2dView::Close() directly, it will generate the same events.

Returns:
true is view was properly closed and not vetod else false

release of itself

Definition at line 1746 of file docviewref.cpp.

void a2dView::OnCloseView ( a2dCloseViewEvent &  event  ) 

wxEVT_CLOSE_VIEW event handler to do cleanup/veto Close of the view.

The default handler does nothing yet.

The Handler for wxEVT_CLOSE_VIEW, resulting from view close via a2dView:Close() ( either via a2dDocument or a wxFrame containing the view)

One may intercept wxEVT_CLOSE_VIEW event in a derived class to Clean up and Destroy windows used for displaying the view. But it is often better to do this in a wxWindow derived class which contains the view. Therefore the wxEVT_CLOSE_VIEW is first sent to the m_display wxWindow of the a2dView.

The best is to use a a2dViewConnector to create frames and windows to hold a view, and a2dDocumentFrame derived class to handle Closing of a2dView's. It will recieve the wxEVT_CLOSE_VIEW via the wxWindow containing the a2dView which is about to be closed. This makes it easy to use the same view class in other applications.

On closing of a wxFrame, you may decide to Close the window by intercepting EVT_CLOSE, and from there call a2dView::Close. It depends on the application how the views are closed.

In any case Windows should be Destroyed, not really deleted. Destroy only flags for deletion, this means that they will really be deleted in idle time by wxWindows.

Reimplemented in a2dCanvasView.

Definition at line 1704 of file docviewref.cpp.

void a2dView::OnDisConnectView ( a2dDocumentEvent &  event  ) 

handler for wxEVT_DISCONNECT_ALLVIEWS

The wxEVT_DISCONNECT_ALLVIEWS is generated by the a2dDocument when it disconnects all views. This can be when closing the document, or just to attach all views to another document.

Definition at line 1710 of file docviewref.cpp.

bool a2dView::ProcessEvent ( wxEvent &  event  )  [virtual]

Extend event processing to search the view's event table.

Some events are handled within the view as if the view is a window within a window. Therefore the wxWindow containing the view should redirect all its events to its view(s), when the view does not handle the event it will go to the window itself.

Events handled how:

Reimplemented from a2dEvtHandler.

Reimplemented in a2dCanvasView.

Definition at line 1632 of file docviewref.cpp.

void a2dView::Activate ( bool  activate  ) 

is called via ProcessEvent() when the view becomes active

Generates a wxEVT_ACTIVATE_VIEW with active == activate. This event is distributed if m_DoDistributeActivateEvent is true. When recieved by a2dDocumentCommandProcessor::OnActivateView() this way, the last will deactivate its current active view, using this same function.

The event wxEVT_ACTIVATE_VIEW_SENT_FROM_CHILD event is sent to the m_display window or frame. This is the event to catch in order to set the view in the containing frame/windows. For example a2dDocumentFrame use sthis event to set the view to which it will sent window close events.

Can also be called directly to notify the view that it should go (in)active.

See also:
a2dViewEvent.

Definition at line 1591 of file docviewref.cpp.

bool a2dView::GetActive (  )  [inline]

return if the view is active/

a view is in general active when its m_display window has the focus or is selected.

Definition at line 2339 of file docviewref.h.

void a2dView::SetDoDistributeActivateEvent ( bool  doDistributeActivateEvent  )  [inline]

See also:
m_DoDistributeActivateEvent

Definition at line 2342 of file docviewref.h.

wxPrintout * a2dView::OnCreatePrintout ( a2dCommand *  typeOfPrint  )  [virtual]

called from the a2dDocumentCommandProcessor to create a wxPrintout are derived class

for printing a view If the printing framework is enabled in the library, this function returns a wxPrintout object for the purposes of printing. It should create a new object every time it is called; the framework will delete objects it creates. By default, this function returns an instance of wxDocPrintout, which prints and previews one page by calling wxView::OnDraw.

Override to return an instance of a class other than wxDocPrintout.

Parameters:
typeOfPrint When called from a2dDocumentCommandProcessor, the a2dCommand that lead to this call.

Reimplemented in a2dCanvasView.

Definition at line 1906 of file docviewref.cpp.

void a2dView::OnSetFocus ( wxFocusEvent &  event  )  [protected]

called on (de)activating (wxWindow) containing the view.

when a view gets the focus ( when only one view per window

that view gets the focus if the window gets the focus ) Else the window getting the focus should decide which view gets the focus.

Definition at line 1912 of file docviewref.cpp.

void a2dView::OnKillFocus ( wxFocusEvent &  event  )  [protected]

when a view goes out of focus ( when only one view per window

that view goes out of focus if the window goes out of focus ) Else the window getting the focus should decide which view goes out of focus.

Definition at line 1917 of file docviewref.cpp.

Member Data Documentation

bool a2dView::m_DoDistributeActivateEvent [protected]

true if this view does distribute the does Distribute the wxEVT_ACTIVATE_VIEW event.

Normally Activate() sents the a2dViewEvent of type wxEVT_ACTIVATE_VIEW to the a2dEventDistributer. This flag is set false to prevent this. This is needed when you want to prevent this view from being part of the a2DocumentCommandProcessor maintained/controlled active view. A situation like this occurs when a view is used standalone within in its m_display window, and should not influence the current active view inside the a2dDocumentCommandProcessor.

A typical example is: using a wxWindow display windows with a a2dView and its a2dDocument, where the document will never have more views, and used completely standalone as if its is a dialog window. A toolbar like window to show/edit/manipulate some information, is a good example. The view can still distribute and recieve other distributed events.

Definition at line 2410 of file docviewref.h.

bool a2dView::m_viewEnabled [protected]

Is the view enabled?

true if this view is enabled and will process all events. else only wxEVT_ENABLE_VIEW and wxEVT_ENABLE_VIEWS will be processed.

Definition at line 2417 of file docviewref.h.

a2dSmrtPtr<a2dView> a2dView::m_keepalive [protected]

this is used to keep the view alive if no other references are there. This untill the view is closed by calling Close() or SetClosed()

Definition at line 2427 of file docviewref.h.

The documentation for this class was generated from the following files:
a2dView Class Reference -- Tue Aug 31 18:36:31 2010 -- 31 Aug 2010 -- 1.5.5 -- wxArt2D -- . -- Main Page Reference Documentation