layerdlg.cpp

Go to the documentation of this file.

/*! \file editor/src/layerdlg.cpp
    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: layerdlg.cpp,v 1.68 2009/07/04 10:26:39 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include "wx/canvas/canmod.h"
#include "wx/editor/styledialg.h"
#include "wx/editor/doccancom.h"

#include <wx/statline.h>

#include "wx/editor/layerdlg.h"

#if defined(__WXMSW__) && defined(__MEMDEBUG__)
#include <wx/msw/msvcrt.h>
#endif

#define LPD_B_W     20
#define LPD_B_H     20

#ifdef __UNIX__
    #define LPD_PATTERNBOX_W    50
#else
    #define LPD_PATTERNBOX_W    30
#endif 

const int    LAY_BUTTON_HIDE     = wxID_HIGHEST + 4801 ;

const int    LAY_BUTTON_CANCEL   = wxID_HIGHEST + 4802 ;

const int    LAY_BUTTON_VISIBLE   = wxID_HIGHEST + 4803 ;

const int    LAY_BUTTON_OUTLINE   = wxID_HIGHEST + 5961 ;

const int    LAY_BUTTON_READ   = wxID_HIGHEST + 4804 ;

const int    LAY_BUTTON_SELECT = wxID_HIGHEST + 4805 ;

const int    LAY_BUTTON_PREV   = wxID_HIGHEST + 4806 ;

const int    LAY_BUTTON_NEXT   = wxID_HIGHEST + 4807 ;

const int    LAY_EDIT_NAME     = wxID_HIGHEST + 4808 ;

const int    LAY_BUTTON_RESTORE = wxID_HIGHEST + 4812 ;

const int    LAY_BUTTON_SAVETOFILE = wxID_HIGHEST + 4813 ;

const int    LAY_BUTTON_LOADFROMFILE = wxID_HIGHEST + 4814 ;

const int    LAY_BUTTON_SORT = wxID_HIGHEST + 4815 ;

const int    ID_AVAILABLE = wxID_HIGHEST + 5000;
const int    ID_LAYERNAME = wxID_HIGHEST + 5100;
const int    ID_VISIBLE   = wxID_HIGHEST + 5200;
const int    ID_SELECTABLE = wxID_HIGHEST + 5300;
const int    ID_READ       = wxID_HIGHEST + 5400;
const int    ID_OUTLINE    = wxID_HIGHEST + 5450;
const int    ID_LAYERFILLCOLOR  = wxID_HIGHEST + 5500;
const int    ID_LAYERSTROKECOLOR = wxID_HIGHEST + 5600;
const int    ID_LAYERPATTERN   = wxID_HIGHEST + 5700;
const int    ID_INMAP   = wxID_HIGHEST + 5800;
const int    ID_OUTMAP   = wxID_HIGHEST + 5900;
const int    ID_NUMBER = wxID_HIGHEST + 5950;
const int    ID_AvailableTimer = wxID_HIGHEST + 5960;

// check document every 3 seconds
#define CHECKTIME 3000 

BEGIN_EVENT_TABLE(LayerPropertiesDialog, wxDialog)
    EVT_CHANGED_DOCUMENT( LayerPropertiesDialog::OnChangedDocument )

    EVT_TIMER( ID_AvailableTimer, LayerPropertiesDialog::OnTimerAvailable)

    EVT_COM_EVENT( LayerPropertiesDialog::OnComEvent )
    EVT_DO( LayerPropertiesDialog::OnDoEvent )

    EVT_BUTTON    (LAY_BUTTON_SORT, LayerPropertiesDialog::CmSort)

    EVT_BUTTON    (LAY_BUTTON_HIDE, LayerPropertiesDialog::CmHide)

    EVT_BUTTON    (LAY_BUTTON_CANCEL, LayerPropertiesDialog::CmCancel)

    EVT_BUTTON    (LAY_BUTTON_RESTORE, LayerPropertiesDialog::CmRestore)

    EVT_BUTTON    (LAY_BUTTON_SAVETOFILE, LayerPropertiesDialog::CmSaveToFile)

    EVT_BUTTON    (LAY_BUTTON_LOADFROMFILE, LayerPropertiesDialog::CmLoadFromFile)

    EVT_BUTTON    (LAY_BUTTON_VISIBLE, LayerPropertiesDialog::CmVisible)

    EVT_BUTTON    (LAY_BUTTON_READ, LayerPropertiesDialog::CmRead)

    EVT_BUTTON    (LAY_BUTTON_OUTLINE, LayerPropertiesDialog::CmOutLine)

    EVT_BUTTON    (LAY_BUTTON_SELECT, LayerPropertiesDialog::CmSelect)

    EVT_BUTTON    (LAY_BUTTON_PREV, LayerPropertiesDialog::CmPrev)

    EVT_BUTTON    (LAY_BUTTON_NEXT, LayerPropertiesDialog::CmNext)

    EVT_CUSTOM_RANGE(wxEVT_COMMAND_TEXT_ENTER, ID_LAYERNAME, ID_LAYERNAME + 9, LayerPropertiesDialog::Cm_LayerName )

    EVT_CUSTOM_RANGE(wxEVT_COMMAND_BUTTON_CLICKED, ID_NUMBER, ID_NUMBER + 9, LayerPropertiesDialog::Cm_NumberBox )

    EVT_CUSTOM_RANGE(wxEVT_COMMAND_CHECKBOX_CLICKED  , ID_VISIBLE, ID_VISIBLE + 9, LayerPropertiesDialog::Cm_VisibleBox )
    EVT_CUSTOM_RANGE(wxEVT_COMMAND_CHECKBOX_CLICKED  , ID_SELECTABLE, ID_SELECTABLE + 9, LayerPropertiesDialog::Cm_SelectBox)
    EVT_CUSTOM_RANGE(wxEVT_COMMAND_CHECKBOX_CLICKED  , ID_READ, ID_READ + 9, LayerPropertiesDialog::Cm_ReadBox)
    EVT_CUSTOM_RANGE(wxEVT_COMMAND_CHECKBOX_CLICKED  , ID_OUTLINE, ID_OUTLINE + 9, LayerPropertiesDialog::Cm_OutLineBox)

    EVT_CUSTOM_RANGE(wxEVT_COMMAND_BUTTON_CLICKED, ID_LAYERFILLCOLOR, ID_LAYERFILLCOLOR + 9, LayerPropertiesDialog::Cm_F_BitB)
    EVT_CUSTOM_RANGE(wxEVT_COMMAND_BUTTON_CLICKED, ID_LAYERSTROKECOLOR, ID_LAYERSTROKECOLOR + 9, LayerPropertiesDialog::Cm_B_BitB)
    EVT_CUSTOM_RANGE(wxEVT_COMMAND_BUTTON_CLICKED, ID_LAYERPATTERN, ID_LAYERPATTERN + 9, LayerPropertiesDialog::Cm_P_BitB)

    EVT_CUSTOM_RANGE(wxEVT_COMMAND_TEXT_ENTER , ID_INMAP, ID_INMAP + 9, LayerPropertiesDialog::Cm_InMap)
    EVT_CUSTOM_RANGE(wxEVT_COMMAND_TEXT_ENTER , ID_OUTMAP, ID_OUTMAP + 9, LayerPropertiesDialog::Cm_OutMap)

    EVT_CHAR(LayerPropertiesDialog::OnChar)
    EVT_CHAR_HOOK(LayerPropertiesDialog::OnCharHook)

    EVT_CLOSE(LayerPropertiesDialog::OnCloseWindow)

END_EVENT_TABLE()


//****** IMPLEMENTATION OF THE LAYER PROPERTIES DIALOG CLASS ******

a2dLayerInfo* LayerPropertiesDialog::GetLocalLayerInfo( int i )
{ 
    if ( m_onorder )
        return m_controlslayersetup->GetOrderIndex()[i];
    else
        return m_controlslayersetup->GetLayerIndex()[i];
}

a2dLayerInfo* LayerPropertiesDialog::GetDocLayerInfo( int i )
{ 
    if ( m_onorder )
        return m_layersetup->GetOrderIndex()[i];
    else
        return m_layersetup->GetLayerIndex()[i];
}



// Constructor
LayerPropertiesDialog::LayerPropertiesDialog( wxFrame* parent, a2dLayers* layersetup, const wxString& title, long style, const wxString& name ):
    wxDialog(parent,-1,title,wxDefaultPosition,wxDefaultSize,style,name)
        
{
    SetExtraStyle(GetExtraStyle()|wxWS_EX_BLOCK_EVENTS);

    m_dialogLastUpdate = wxDateTime::Now();
    m_timerAvailable = new wxTimer( this, ID_AvailableTimer );
    m_timerAvailable->Start( CHECKTIME, wxTIMER_CONTINUOUS );

    a2dDocviewGlobals->GetEventDistributer()->Register( this );

    m_fillpatterns = new FillPatterns();

    m_parent = parent;

    m_brush = new wxBrush(); // must be done.
    m_onorder = false;

    // no standard colours
    // set extra part of dialog true
    m_cdata     = new wxColourData();
    m_cdata->SetChooseFull(true);

    long style_noresize;
    #ifdef __UNIX__
    style_noresize = (wxCAPTION);
    #else
    style_noresize = (wxSYSTEM_MENU | wxCAPTION);
    #endif

    // make colour dialog
    m_cd = new wxColourDialog( this, m_cdata );

    wxFlexGridSizer *alllayerline = new wxFlexGridSizer( 11 );
    alllayerline->AddGrowableCol(1);
    wxSizer *all = new wxBoxSizer( wxVERTICAL );  
    all->Add( alllayerline, 0, wxGROW );

    m_numberlabel       = new wxStaticText(this,-1,  _T("Nr") );
    alllayerline->Add( m_numberlabel, 0, wxALIGN_CENTRE );
    m_namelabel         = new wxStaticText(this,-1,  _T("Name"));
    alllayerline->Add( m_namelabel, 0, wxALIGN_CENTRE|wxALL, 2 );
    m_visiblelabel      = new wxStaticText(this,-1,  _T("Vis"));
    alllayerline->Add( m_visiblelabel, 0, wxALIGN_CENTRE|wxALL, 2 );
    m_selectablelabel   = new wxStaticText(this,-1,  _T("Sel"));
    alllayerline->Add( m_selectablelabel, 0, wxALIGN_CENTRE|wxALL, 2 );
    m_outlinelabel  = new wxStaticText(this,-1,  _T("OutL"));
    alllayerline->Add( m_outlinelabel, 0, wxALIGN_CENTRE|wxALL, 2 );
    m_readlayerlabel    = new wxStaticText(this,-1,  _T("Read"));
    alllayerline->Add( m_readlayerlabel, 0, wxALIGN_CENTRE|wxALL, 2 );
    m_filllabel         = new wxStaticText(this,-1,  _T("Fill"));
    alllayerline->Add( m_filllabel, 0, wxALIGN_CENTRE|wxALL, 2 );
    m_borderlabel       = new wxStaticText(this,-1,  _T("Stroke"));
    alllayerline->Add( m_borderlabel, 0, wxALIGN_CENTRE|wxALL, 2 );
    m_patternlabel      = new wxStaticText(this,-1,  _T("Pattern"));
    alllayerline->Add( m_patternlabel, 0, wxALIGN_CENTRE|wxALL, 2 );
    m_mappinglabel      = new wxStaticText(this,-1,  _T("inMap"));
    alllayerline->Add( m_mappinglabel, 0, wxALIGN_CENTRE|wxALL, 2 );
    m_mappinglabel      = new wxStaticText(this,-1,  _T("outMap"));
    alllayerline->Add( m_mappinglabel, 0, wxALIGN_CENTRE|wxALL, 2 );

    // make the controls
    for (int i = 0; i < 10; i++)
    {
        wxString nrbuf;

        nrbuf.Printf( _T("%03d"),i+1 );

        m_numberbox[i] = new wxButton( this, ID_NUMBER + i, nrbuf, wxDefaultPosition, wxSize(25,20), wxBU_EXACTFIT );
        alllayerline->Add( m_numberbox[i], 0, wxALIGN_CENTER_VERTICAL |wxALIGN_CENTRE|wxGROW );

        m_namebox[i] = new wxTextCtrl( this, ID_LAYERNAME + i, _T(""), wxDefaultPosition, wxSize(50,20), wxTE_PROCESS_ENTER );
        alllayerline->Add( m_namebox[i], 0, wxALIGN_CENTRE|wxALL|wxGROW, 0 );
        m_namebox[i]->SetToolTip(_("Layer name"));

        m_visiblebox[i] = new wxCheckBox( this, ID_VISIBLE + i, _T(""), wxDefaultPosition, wxDefaultSize, 0 );
        alllayerline->Add( m_visiblebox[i], 0, wxALIGN_CENTRE|wxALL, 1 );

        m_selectablebox[i] = new wxCheckBox( this, ID_SELECTABLE + i, _T(""), wxDefaultPosition, wxDefaultSize, 0 );
        alllayerline->Add( m_selectablebox[i], 0, wxALIGN_CENTRE|wxALL, 1 );

        m_outlinebox[i] = new wxCheckBox( this, ID_OUTLINE + i, _T(""), wxDefaultPosition, wxDefaultSize, 0 );
        alllayerline->Add( m_outlinebox[i], 0, wxALIGN_CENTRE|wxALL, 1 );

        m_readlayerbox[i] = new wxCheckBox( this, ID_READ + i, _T(""), wxDefaultPosition, wxDefaultSize, 0 );
        alllayerline->Add( m_readlayerbox[i], 0, wxALIGN_CENTRE|wxALL, 1 );

        m_fillbut[i] = new wxButton( this, ID_LAYERFILLCOLOR + i, _T(""), wxDefaultPosition, wxSize(20,20),wxSIMPLE_BORDER  );
        alllayerline->Add( m_fillbut[i], 0, wxALIGN_CENTRE|wxALL, 1 );

        m_borderbut[i] = new wxButton( this, ID_LAYERSTROKECOLOR + i, _T(""), wxDefaultPosition, wxSize(20,20),wxSIMPLE_BORDER  );
        alllayerline->Add( m_borderbut[i], 0, wxALIGN_CENTRE|wxALL, 1 );

        m_p_bitm[i]     = new wxBitmap(LPD_PATTERNBOX_W,LPD_B_H,-1);
        m_patternbut[i] = new wxBitmapButton( this, ID_LAYERPATTERN + i, *m_p_bitm[i], wxDefaultPosition, wxSize(40,20),wxSIMPLE_BORDER  );
        alllayerline->Add( m_patternbut[i], 0, wxALIGN_CENTRE|wxALL, 1 );
        m_patterns[i] = 0;

        m_gdsinmap[i] = new wxTextCtrl( this, ID_INMAP + i, _T(""), wxDefaultPosition, wxSize(30,-1),wxTE_PROCESS_ENTER );
        alllayerline->Add( m_gdsinmap[i], 0, wxALIGN_CENTRE|wxALL, 1 );

        m_gdsoutmap[i] = new wxTextCtrl( this, ID_OUTMAP + i, _T(""), wxDefaultPosition, wxSize(30,-1),wxTE_PROCESS_ENTER );
        alllayerline->Add( m_gdsoutmap[i], 0, wxALIGN_CENTRE|wxALL, 1 );
    }

    wxStaticBox *item1 = new wxStaticBox( this, -1, _T("") );
    wxSizer *botline = new wxStaticBoxSizer( item1, wxVERTICAL );  

    wxSizer *botline1 = new wxBoxSizer( wxHORIZONTAL );  
    botline->Add( botline1 );

    m_buttonSORT  = new wxButton(this,LAY_BUTTON_SORT,  _T("Sort Order"),wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT );
    botline1->Add( m_buttonSORT, 0, wxALIGN_CENTRE|wxALL, 0 );

    m_buttonVISIBLE  = new wxButton(this,LAY_BUTTON_VISIBLE,  _T("Hide All"),wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT );
    botline1->Add( m_buttonVISIBLE, 0, wxALIGN_CENTRE|wxALL, 0 );
    m_buttonSELECT  = new wxButton(this,LAY_BUTTON_SELECT,  _T("None Selectable"),wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT );
    botline1->Add( m_buttonSELECT, 0, wxALIGN_CENTRE|wxALL, 0 );
    m_buttonREAD    = new wxButton(this,LAY_BUTTON_READ,    _T("Read Non"),wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT );
    botline1->Add( m_buttonREAD, 0, wxALIGN_CENTRE|wxALL, 0 );
    m_buttonOutLine = new wxButton(this,LAY_BUTTON_OUTLINE, _T("OutLine"),wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT );
    botline1->Add( m_buttonOutLine, 0, wxALIGN_CENTRE|wxALL, 0 );

    botline->Add( new wxStaticLine( this, -1, wxDefaultPosition, wxSize(200,2), wxLI_HORIZONTAL ) , 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT|wxALL, 2);

    wxSizer *botline2 = new wxBoxSizer( wxHORIZONTAL );  
    botline->Add( botline2 );

    m_buttonHIDE     = new wxButton(this,LAY_BUTTON_HIDE,  _T("Hide"),wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT );
    botline2->Add( m_buttonHIDE, 0, wxALIGN_CENTRE|wxALL, 0 );
    m_buttonCANCEL  = new wxButton(this,LAY_BUTTON_CANCEL, _T("Cancel"),wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT);
    botline2->Add( m_buttonCANCEL, 0, wxALIGN_CENTRE|wxALL, 0 );

    botline2->Add( new wxStaticLine( this, -1, wxDefaultPosition, wxSize(2,20), wxLI_VERTICAL ) , 0, wxALIGN_CENTRE|wxALL, 2);

    m_buttonPREV    = new wxButton(this,LAY_BUTTON_PREV, _T("< Previous"), wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT);
    botline2->Add( m_buttonPREV, 0, wxALIGN_CENTRE|wxALL, 0 );
    m_buttonNEXT        = new wxButton(this,LAY_BUTTON_NEXT, _T("Next >"), wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT);
    botline2->Add( m_buttonNEXT, 0, wxALIGN_CENTRE|wxALL, 0 );
    m_buttonRESTORE = new wxButton(this,LAY_BUTTON_RESTORE, _T("Restore"), wxDefaultPosition,wxDefaultSize,wxBU_EXACTFIT);

    wxSizer *botline3 = new wxBoxSizer( wxHORIZONTAL );  
    botline->Add( botline3 );
    botline3->Add( m_buttonRESTORE, 0, wxALIGN_CENTRE|wxALL, 0 );
    m_buttonSAVETOFILE = new wxButton(this,LAY_BUTTON_SAVETOFILE, _T("Save File"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
    botline3->Add( m_buttonSAVETOFILE, 0, wxALIGN_CENTRE|wxALL, 0 );
    m_buttonLOADFROMFILE = new wxButton(this,LAY_BUTTON_LOADFROMFILE, _T("Load File"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
    botline3->Add( m_buttonLOADFROMFILE, 0, wxALIGN_CENTRE|wxALL, 0 );

    all->Add( botline );

    SetSizer( all );

    all->Fit( this );
    SetAutoLayout( true );

    all->SetSizeHints( this );

    m_startvalue = 0;

    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();
    if ( doc && layersetup )
        layersetup->SetAvailable( doc );

    if ( layersetup )
        Init( layersetup );
    else 
        Init( a2dCanvasGlobals->GetLayerSetup() );

    Centre(wxBOTH);
    Layout();

}

LayerPropertiesDialog::~LayerPropertiesDialog()
{
    a2dDocviewGlobals->GetEventDistributer()->Unregister( this );

    delete m_fillpatterns;
    delete m_brush;

    delete m_cdata;
    delete m_cd;
    
    delete m_timerAvailable;

    for (int i = 0; i < 10; i++)
    {
        delete m_p_bitm[i]; 
    }
}

void LayerPropertiesDialog::OnTimerAvailable( wxTimerEvent &event )
{
    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();
    if ( doc && doc->IsModified() && doc->GetInternalChangedTime() > m_dialogLastUpdate )
    {
        m_controlslayersetup->SetAvailable( doc->GetLayerSetup() );
        m_dialogLastUpdate = wxDateTime::Now();
    }
}

void LayerPropertiesDialog::OnChangedDocument( a2dCommandEvent& event )
{
    a2dCanvasDocument* doc = (a2dCanvasDocument*) event.GetDocument();
    if ( doc && doc->GetLayerSetup() != m_layersetup )
    {
        doc->GetLayerSetup()->SetAvailable( doc );
        Init( doc->GetLayerSetup() );
    }
}

void LayerPropertiesDialog::Init( a2dLayers* layersetup )
{
    m_backuplayersetup = wxStaticCast( layersetup->Clone(a2dObject::clone_deep) , a2dLayers );
    m_controlslayersetup = wxStaticCast( layersetup->Clone(a2dObject::clone_deep) , a2dLayers );
    m_layersetup = layersetup;

    m_buttonPREV->Enable();
    m_buttonNEXT->Enable();

    if (m_startvalue <= 0)
        m_buttonPREV->Disable();

    if (m_startvalue + 10 >= wxMAXLAYER-1)
        m_buttonNEXT->Disable();

    FillControls(m_startvalue);
}

void LayerPropertiesDialog::OnComEvent( a2dComEvent& event )
{
    if ( GetEvtHandlerEnabled() )
    {
        a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();

        if ( !doc )
            return;

        int layer = a2dGetCmdh()->GetLayer();
        a2dLayerInfo* layerinfo = GetLocalLayerInfo(layer);

        if ( event.GetEventComId() == &a2dComEvent::sm_changedProperty )
        {
            a2dNamedProperty *property = event.GetProperty();
            a2dObject *object = property->GetRefObjectNA();

            if ( 0 != wxDynamicCast( property, a2dStrokeProperty ) )
            {
                a2dStroke stroke = ((a2dStrokeProperty*)property)->GetValue();
                if ( layerinfo->GetStroke() != stroke )
                    layerinfo->SetStroke( stroke );
                FillControls(m_startvalue);
            }
            else if ( 0 != wxDynamicCast( property, a2dFillProperty ) )
            {
                a2dFill fill = ((a2dFillProperty*)property)->GetValue();
                if ( layerinfo->GetFill() != fill )
                    layerinfo->SetFill( fill );
                FillControls(m_startvalue);
            }
            else if ( property->GetId() == a2dCanvasObject::PROPID_Layer )
            {
                layerinfo->SetLayer( property->GetUint16() );
                FillControls(m_startvalue);
            }
            else
                event.Skip();
        }
        else if ( event.GetEventComId() == &a2dCanvasView::sm_changedLayers )
        {
            Init( doc->GetLayerSetup() );
        }
        else if ( event.GetEventComId() == &a2dCanvasDocument::sm_layersetupChanged ) 
        {
            Init( doc->GetLayerSetup() );
        }

    }
}

void LayerPropertiesDialog::OnDoEvent( a2dCommandProcessorEvent& event )
{
    if ( GetEvtHandlerEnabled() )
    {
        a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();

        if ( !doc )
            return;

        if ( event.GetCommand()->GetCommandId() == &a2dCommand_SetLayer::Id )
        {
            FillControls(m_startvalue);
        }
    }
}

void LayerPropertiesDialog::FillControls(int start)
{
    wxColour kleurtje;
    wxColour kleurtje2;

    int All_Hided = true;
    int All_Read = true;
    int All_Outline = true;

    int currentInsertLayer = a2dGetCmdh()->GetLayer();

    for (int i = start; i < start+10; i++)
    {
        wxString buf;
        int x = i - m_startvalue;

        a2dLayerInfo* layerinfo = GetLocalLayerInfo(i);

        bool available = layerinfo->GetAvailable(); 

        buf.Printf( wxT("%i"), layerinfo->GetLayer() );
        m_numberbox[x]->SetBackgroundColour( currentInsertLayer == i ? wxColour(184,232,241) : wxColour(255,255,255) );
        m_numberbox[x]->SetForegroundColour( available ? wxColour(255,0,0) : wxColour(0,0,0) );
        m_numberbox[x]->SetLabel(buf);

        m_namebox[x]->SetBackgroundColour( currentInsertLayer == i ? wxColour(184,232,241) : wxColour(255,255,255) );
        m_namebox[x]->SetForegroundColour( available ? wxColour(255,0,0) : wxColour(0,0,0) );
        m_namebox[x]->SetValue( layerinfo->GetName() );
        m_namebox[x]->SetToolTip( layerinfo->GetFeature() );

        if (layerinfo->GetVisible())
            All_Hided = false;

        m_visiblebox[x]->SetValue( layerinfo->GetVisible() ? true : false);
        m_selectablebox[x]->SetValue( layerinfo->GetSelectable() ? true : false );

        if ( !layerinfo->GetFill().GetFilling() )
            All_Outline = false;
        m_outlinebox[x]->SetValue( !layerinfo->GetFill().GetFilling() ? true : false );

        if (! layerinfo->GetRead())
            m_readlayerbox[x]->SetValue(false);
        else
        {
            All_Read = false;
            m_readlayerbox[x]->SetValue(true);
        }

        // fill of polygons rect
        kleurtje = layerinfo->GetFillColour();
        m_fillbut[x]->SetBackgroundColour(kleurtje);

        // stroke of polygons rect
        kleurtje = layerinfo->GetStrokeColour();
        m_borderbut[x]->SetBackgroundColour(kleurtje);

        {
            //update the bitmap to show fill and stroke properties
            int w = m_patternbut[x]->GetBitmapLabel().GetWidth();
            int h = m_patternbut[x]->GetBitmapLabel().GetHeight();
            a2dMemDcDrawer* drawer = new a2dMemDcDrawer( w, h );
            drawer->BeginDraw();
            drawer->SetDrawerFill( layerinfo->GetFill() );
            drawer->SetDrawerStroke( layerinfo->GetStroke() );
            drawer->DrawRoundedRectangle( 0, 0, w, h, 0 );
            drawer->EndDraw();
            m_patternbut[x]->SetBitmapLabel( drawer->GetBuffer() );
            m_patternbut[x]->Refresh(true);
            delete drawer;

        }

        buf.Printf( wxT("%i"), layerinfo->GetInMapping() );
        m_gdsinmap[x]->SetValue(buf);

        buf.Printf( wxT("%i"), layerinfo->GetOutMapping() );
        m_gdsoutmap[x]->SetValue(buf);

        m_fillbut[x]->Refresh();
        m_borderbut[x]->Refresh();
        m_patternbut[x]->Refresh();
    }

    if (All_Hided)
    {
        m_buttonVISIBLE->SetLabel( _T("Show All"));
        m_buttonSELECT->SetLabel( _T("All Selectable"));
    }

    if (m_onorder)
        m_buttonSORT->SetLabel( _T("Sort Layer"));
    else
        m_buttonSORT->SetLabel( _T("Sort Order"));

    if (All_Outline)
        m_buttonOutLine->SetLabel(_T("Outline All"));
    else
        m_buttonOutLine->SetLabel(_T("Outline Non"));

    if (All_Read)
        m_buttonREAD->SetLabel(_T("Read All"));

    //will update dialog and all its (bitmap)buttons
    Refresh(true);
}

void LayerPropertiesDialog::StoreControls( unsigned int start, unsigned int nrLayers )
{
    bool changed = false;

    SetEvtHandlerEnabled( false ); 

    //first take over control settings into the local layer setup
    //via command activate the changed settings.
    unsigned int i;
    for ( i = start; i < start + nrLayers; i++)
    {
        int x = i - m_startvalue;

        a2dLayerInfo* layerinfo = GetLocalLayerInfo(i);

        layerinfo->SetName( m_namebox[x]->GetValue() );
        layerinfo->SetVisible((bool)m_visiblebox[x]->GetValue() );
        layerinfo->SetSelectable((bool)m_selectablebox[x]->GetValue() );
        layerinfo->SetRead((bool)(m_readlayerbox[x]->GetValue()));
        layerinfo->SetStrokeColour( m_borderbut[x]->GetBackgroundColour() );
        layerinfo->SetFillColour( m_fillbut[x]->GetBackgroundColour() );

        // if pattern is not full or non, use pattern fill
        if ( m_patterns[x] != 0 && m_patterns[x] != 1 )
        {
            a2dFill pfill = layerinfo->GetFill();
            pfill.SetStipple( *(m_fillpatterns->GetPattern( m_patterns[x] )) );
            pfill.SetColour( m_fillbut[x]->GetBackgroundColour() );
            pfill.SetColour2( m_fillbut[x]->GetBackgroundColour() );
        }
        else 
        {
            a2dFill fill = a2dFill( m_fillbut[x]->GetBackgroundColour() );
            layerinfo->SetFill( fill );
        }

        long t;
        m_gdsinmap[x]->GetValue().ToLong( &t );
        layerinfo->SetInMapping( t );
        m_gdsoutmap[x]->GetValue().ToLong( &t );
        layerinfo->SetOutMapping( t );


        a2dLayerInfo* layerinfodoc = GetDocLayerInfo(i);

        //better give layer as part of command to keep insertion layer the same.
        if ( layerinfo->GetName() != layerinfodoc->GetName() )
        {
            changed = true;
            if ( a2dGetCmdh()->GetDocCmdh() )
                a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_layerName, layerinfo->GetName().c_str() ));
            else
                a2dLayerInfo::PROPID_layerName->SetPropertyToObject( layerinfodoc, layerinfo->GetName().c_str() );
        }

        if ( layerinfo->GetVisible() != layerinfodoc->GetVisible())
        {
            changed = true;
            if ( a2dGetCmdh()->GetDocCmdh() )
                a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_layerVisible, layerinfo->GetVisible() ));
            else
                a2dLayerInfo::PROPID_layerVisible->SetPropertyToObject( layerinfodoc, layerinfo->GetVisible() );
        }

        if ( layerinfo->GetSelectable() != layerinfodoc->GetSelectable())
        {
            changed = true;
            if ( a2dGetCmdh()->GetDocCmdh() )
                a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_layerSelectable, layerinfo->GetSelectable()));
            else
                a2dLayerInfo::PROPID_layerSelectable->SetPropertyToObject( layerinfodoc, layerinfo->GetSelectable() );
        }

        if ( layerinfo->GetRead() != layerinfodoc->GetRead())
        {
            changed = true;
            a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_readlayer, layerinfo->GetRead() ));
        }

        if ( layerinfo->GetStroke().GetColour() != layerinfodoc->GetStroke().GetColour() )
        {
            changed = true;
            if ( a2dGetCmdh()->GetDocCmdh() )
                a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_StrokeColour, layerinfo->GetStroke().GetColour() ));
            else
                a2dLayerInfo::PROPID_StrokeColour->SetPropertyToObject( layerinfodoc, layerinfo->GetStroke().GetColour() );
        }
        if ( layerinfo->GetFill().GetColour() != layerinfodoc->GetFill().GetColour() )
        {
            changed = true;
            if ( a2dGetCmdh()->GetDocCmdh() )
                a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_FillColour, layerinfo->GetFill().GetColour() ));
            else
                a2dLayerInfo::PROPID_FillColour->SetPropertyToObject( layerinfodoc, layerinfo->GetFill().GetColour() );
            //layerinfodoc->GetFill()->SetColour( layerinfo->GetFill()->GetColour() );
        }

        if ( &layerinfo->GetFill().GetStipple() != &layerinfodoc->GetFill().GetStipple() )
        {
            changed = true;
            //if ( a2dGetCmdh()->GetDocCmdh() )
            //    a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_Fill, layerinfo->GetFill() ));
            //else
                a2dLayerInfo::PROPID_Fill->SetPropertyToObject( layerinfodoc, layerinfo->GetFill());
        }

        if ( layerinfo->GetInMapping() != layerinfodoc->GetInMapping() )
        {
            changed = true;
            if ( a2dGetCmdh()->GetDocCmdh() )
                a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_inmap, layerinfo->GetInMapping() ));
            else
                a2dLayerInfo::PROPID_inmap->SetPropertyToObject( layerinfodoc, layerinfo->GetInMapping() );
        }

        if ( layerinfo->GetOutMapping() != layerinfodoc->GetOutMapping() )
        {
            changed = true;
            if ( a2dGetCmdh()->GetDocCmdh() )
                a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_outmap, layerinfo->GetOutMapping() ));
            else
                a2dLayerInfo::PROPID_outmap->SetPropertyToObject( layerinfodoc, layerinfo->GetOutMapping() );
        }
    }


    if ( changed )
    {
        a2dComEvent changedlayer( m_layersetup->GetCanvasDocument(), m_layersetup ,&a2dCanvasDocument::sm_layersetupChanged );
        a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( changedlayer );
    }

    SetEvtHandlerEnabled( true );
}

void LayerPropertiesDialog::CmHide(wxCommandEvent &)
{
    Show(false);

    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();
    if ( doc && doc->GetLayerSetup() )
        doc->GetLayerSetup()->SetPending( true );
}

void LayerPropertiesDialog::CmCancel( wxCommandEvent& event)
{
    m_layersetup = wxStaticCast( m_backuplayersetup->Clone(a2dObject::clone_deep) , a2dLayers );
    m_controlslayersetup = wxStaticCast( m_backuplayersetup->Clone(a2dObject::clone_deep) , a2dLayers );
   
    FillControls(m_startvalue);
    StoreControls( m_startvalue, m_startvalue + 10 );

    CmHide( event );
}

void LayerPropertiesDialog::CmRestore( wxCommandEvent& WXUNUSED(event) )
{
    m_layersetup = wxStaticCast( m_backuplayersetup->Clone(a2dObject::clone_deep) , a2dLayers );
    m_controlslayersetup = wxStaticCast( m_backuplayersetup->Clone(a2dObject::clone_deep) , a2dLayers );

    FillControls(m_startvalue);
    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();

    if ( !doc )
        return;

    SetEvtHandlerEnabled( false ); //prevent OnComEvent on this one.
    doc->SetLayerSetup( m_layersetup );
    SetEvtHandlerEnabled( true ); 
}

void LayerPropertiesDialog::CmSaveToFile( wxCommandEvent& WXUNUSED(event) )
{
    wxString fullname = _( "Mywxart2dlayers.cvg" );

    wxString* layerfiledir = a2dGeneralGlobals->GetVariablesHash().GetVariableString( wxT("lastLayerFileSavePath") );

    if ( !layerfiledir )
        layerfiledir = a2dDocviewGlobals->GetVariablesHash().GetVariableString(  wxT("layerFileSavePath") );

    wxFileDialog fileDialog( this,
            _("Choose layer file to load"),
            layerfiledir ? *layerfiledir: wxT(""),
            fullname,
            wxT("*.cvg"),
            wxFD_SAVE | wxFD_OVERWRITE_PROMPT
             );

    if ( fileDialog.ShowModal() != wxID_OK )
        return;

    fullname = fileDialog.GetPath();

    a2dGeneralGlobals->GetVariablesHash().SetVariableString( wxT("lastLayerFileSavePath"), wxPathOnly(fullname) );

    SetEvtHandlerEnabled( false ); //prevent OnComEvent on this one.

    SetCursor( wxCURSOR_WAIT );        
    m_layersetup->SaveLayers( fullname );
   
    SetEvtHandlerEnabled( true ); 
    SetCursor( wxCURSOR_ARROW );        
}

void LayerPropertiesDialog::CmLoadFromFile( wxCommandEvent& WXUNUSED(event) )
{
    wxString fullname;

    wxString* path = a2dGeneralGlobals->GetVariablesHash().GetVariableString( wxT("lastLayerFileSavePath") );

    wxFileDialog fileDialog( this,
            _("Choose layer file to load"),
            path ? *path: wxT(""),
            fullname,
            wxT("*.cvg"),
            wxFD_OPEN | wxFD_FILE_MUST_EXIST
             );

    if ( fileDialog.ShowModal() != wxID_OK )
        return;

    fullname = fileDialog.GetPath();

    a2dGeneralGlobals->GetVariablesHash().SetVariableString( wxT("lastLayerFileSavePath"), wxPathOnly(fullname) );

    SetCursor( wxCURSOR_WAIT );        
#if wxART2D_USE_CVGIO

    a2dLayers* layersetup = new a2dLayers();
    layersetup->LoadLayers( fullname );
    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();
    if ( !doc )
        return;
    doc->SetLayerSetup( layersetup );
#else
        wxFAIL_MSG( wxT("wxART2D_USE_CVGIO is needed to load object from a file CVG file") );
#endif //wxART2D_USE_CVGIO
    

    SetEvtHandlerEnabled( false ); //prevent OnComEvent on this one.
    Init( layersetup);
    SetEvtHandlerEnabled( true ); //prevent OnComEvent on this one.
    FillControls(m_startvalue);
    SetCursor( wxCURSOR_ARROW );        
}


void LayerPropertiesDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event) )
{
    Show(false);

    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();
    if ( doc && doc->GetLayerSetup() )
        doc->GetLayerSetup()->SetPending( true );
}

void LayerPropertiesDialog::CmSort( wxCommandEvent& )
{
    wxString buf;
    buf = m_buttonSORT->GetLabel();
    if ( buf == wxT("Sort Layer") )
        m_onorder = false;
    else
        m_onorder = true;

    FillControls(m_startvalue);
}

void LayerPropertiesDialog::CmVisible( wxCommandEvent& )
{
    wxString buf;
    bool onoff = false;
    buf = m_buttonVISIBLE->GetLabel();
    if ( buf == wxT("Hide All") )
    {
        onoff = false;
        m_buttonVISIBLE->SetLabel( wxT("Show All") );
    }
    else
    {
        onoff = true;
        m_buttonVISIBLE->SetLabel(wxT("Hide All"));
    }

    m_controlslayersetup->SetAll_Layers_Visible( onoff );
    
    a2dCommand_SetLayersProperty* command = new a2dCommand_SetLayersProperty( onoff, a2dCommand_SetLayersProperty::visible );
    a2dGetCmdh()->Submit( command );

    FillControls(m_startvalue);
}

void LayerPropertiesDialog::CmRead(wxCommandEvent &)
{
    wxString buf;
    bool onoff = false;
    buf = m_buttonREAD->GetLabel();
    if ( buf == wxT("Read Non") )
    {
        onoff = false;
        m_buttonREAD->SetLabel(_T("Read All"));
    }
    else
    {
        onoff = true;
        m_buttonREAD->SetLabel(wxT("Read Non"));
    }

    m_controlslayersetup->SetAll_Layers_Read( onoff );

    a2dCommand_SetLayersProperty* command = new a2dCommand_SetLayersProperty( onoff, a2dCommand_SetLayersProperty::readable );
    a2dGetCmdh()->Submit( command );

    FillControls(m_startvalue);
}

void LayerPropertiesDialog::CmOutLine(wxCommandEvent &)
{
    wxString buf;
    bool onoff = false;
    buf = m_buttonOutLine->GetLabel();
    if ( buf == wxT("Outline Non") )
    {
        onoff = false;
        m_buttonOutLine->SetLabel(_T("Outline All"));
    }
    else
    {
        onoff = true;
        m_buttonOutLine->SetLabel(wxT("Outline Non"));
    }

    m_controlslayersetup->SetAll_Layers_Outline( onoff );

    a2dCommand_SetLayersProperty* command = new a2dCommand_SetLayersProperty( !onoff, a2dCommand_SetLayersProperty::filling );
    a2dGetCmdh()->Submit( command );

    FillControls(m_startvalue);
}

void LayerPropertiesDialog::CmSelect(wxCommandEvent &)
{
    wxString buf;
    bool onoff = false;
    buf = m_buttonSELECT->GetLabel();
    if ( buf == wxT("All Selectable") )
    {
        onoff = true;
        m_buttonSELECT->SetLabel(_T("None Selectable"));
    }
    else
    {
        onoff = false;
        m_buttonSELECT->SetLabel(_T("All Selectable"));
    }

    m_controlslayersetup->SetAll_Layers_Selectable( onoff );

    a2dCommand_SetLayersProperty* command = new a2dCommand_SetLayersProperty( onoff, a2dCommand_SetLayersProperty::selectable );
    a2dGetCmdh()->Submit( command );

    FillControls(m_startvalue);
}

void LayerPropertiesDialog::CmPrev(wxCommandEvent &)
{
    m_buttonNEXT->Enable();
    if (m_startvalue - 10 >= 0)
    {
        m_startvalue -= 10;
        FillControls(m_startvalue);
    }

    if (m_startvalue <= 0)
        m_buttonPREV->Disable();
   SetFocus();
   Show(true);
   Refresh();
}

void LayerPropertiesDialog::CmNext( wxCommandEvent& )
{
    m_buttonPREV->Enable();
    if (m_startvalue + 10 < wxMAXLAYER )
    {
        m_startvalue += 10;
        FillControls(m_startvalue);
    }

    if (m_startvalue + 10 >= wxMAXLAYER-1)
        m_buttonNEXT->Disable();
   SetFocus();
   Show(true);
   Refresh();
}

void LayerPropertiesDialog::Cm_F_BitB(wxEvent& event)
{
   if (m_cd->ShowModal()==wxID_OK)
   {
        wxColour col;
        *m_cdata = m_cd->GetColourData();
        col = m_cdata->GetColour();
        int x = event.GetId() - ID_LAYERFILLCOLOR;
        int i = x + m_startvalue;

        a2dLayerInfo* layerinfo = GetLocalLayerInfo(i);
        a2dLayerInfo* layerinfodoc = GetDocLayerInfo(i);

        layerinfo->SetFillColour( col );

        if ( layerinfo->GetFill().GetColour() != layerinfodoc->GetFill().GetColour() )
        {
            if ( a2dGetCmdh()->GetDocCmdh() )
                a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_FillColour, layerinfo->GetFill().GetColour() ));
            else
                a2dLayerInfo::PROPID_FillColour->SetPropertyToObject( layerinfodoc, layerinfo->GetFill().GetColour() );
        }
        FillControls(m_startvalue);
   }
   SetFocus();
   Show(true);
   Refresh(true);
}

void LayerPropertiesDialog::Cm_B_BitB(wxEvent& event)
{
   if (m_cd->ShowModal()==wxID_OK)
   {
        wxColour col;
        *m_cdata = m_cd->GetColourData();
        col = m_cdata->GetColour();

        int x = event.GetId() - ID_LAYERSTROKECOLOR;
        int i = x + m_startvalue;

        a2dLayerInfo* layerinfo = GetLocalLayerInfo(i);
        a2dLayerInfo* layerinfodoc = GetDocLayerInfo(i);
        layerinfo->SetStrokeColour( col );
        if ( layerinfo->GetStroke().GetColour() != layerinfodoc->GetStroke().GetColour() )
        {
            if ( a2dGetCmdh()->GetDocCmdh() )
                a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_StrokeColour, layerinfo->GetStroke().GetColour() ));
            else
                a2dLayerInfo::PROPID_StrokeColour->SetPropertyToObject( layerinfodoc, layerinfo->GetStroke().GetColour() );
        }
        FillControls(m_startvalue);
   }
   SetFocus();
   Show(true);
   Refresh();
}

void LayerPropertiesDialog::Cm_P_BitB(wxEvent& event)
{
    //the button pressed given indirect the layer
    int x = event.GetId() - ID_LAYERPATTERN;
    int i = x + m_startvalue;

    PatternDialog patternDialog(this,m_fillpatterns, wxT("Patterns"),(wxSYSTEM_MENU | wxCAPTION));
    int choosen = patternDialog.ShowModal();
    patternDialog.Close();

    wxBitmap pat = *(m_fillpatterns->GetPattern( choosen ));

    a2dLayerInfo* layerinfo = GetLocalLayerInfo(i);
    a2dLayerInfo* layerinfodoc = GetDocLayerInfo(i);

    // if pattern is not full or non, use pattern fill
    if ( choosen != 0 && choosen != 1 )
    {
        a2dFillStyle style = layerinfo->GetFill().GetStyle();
        a2dFill pfill = a2dFill( pat );

        if ( style != a2dFILL_STIPPLE_MASK_OPAQUE &&
             style != a2dFILL_STIPPLE_MASK_OPAQUE_TRANSPARENT &&
             style != a2dFILL_STIPPLE )
            //the default is transparent
            pfill.SetStyle( a2dFILL_STIPPLE_MASK_OPAQUE_TRANSPARENT );
        else if ( style == a2dFILL_STIPPLE )
            pfill.SetStyle( a2dFILL_STIPPLE_MASK_OPAQUE_TRANSPARENT );
        else
            pfill.SetStyle( style );
        pfill.SetColour( layerinfo->GetFill().GetColour() );
        pfill.SetColour2( layerinfo->GetFill().GetColour2() );
        layerinfo->SetFill( pfill );    
    }
    else 
    {
        if ( choosen == 0 )
        {
            a2dFill fill = a2dFill( layerinfo->GetFill().GetColour(), a2dFILL_TRANSPARENT );
            layerinfo->SetFill( fill );
        }
        else
        {
            a2dFill fill = a2dFill( layerinfo->GetFill().GetColour(), a2dFILL_SOLID );
            layerinfo->SetFill( fill );
        }
    }


    //if ( a2dGetCmdh()->GetDocCmdh() )
    //  a2dGetCmdh()->GetDocCmdh()->Submit( new a2dCommand_SetProperty( layerinfodoc, a2dLayerInfo::PROPID_Fill, layerinfo->GetFill() ));
    //else
        //a2dLayerInfo::PROPID_Fill->SetPropertyToObject( layerinfodoc, layerinfo->GetFill() );
    layerinfodoc->SetFill( layerinfo->GetFill() );
    FillControls(m_startvalue);

    SetFocus();
    Show(true);
    Refresh();
}

void LayerPropertiesDialog::Cm_LayerName(wxEvent& event )
{
    int x = event.GetId() - ID_LAYERNAME;
    int i = x + m_startvalue;
    a2dLayerInfo* layerinfo = GetLocalLayerInfo(i);
    a2dLayerInfo* layerinfodoc = GetDocLayerInfo(i);
    layerinfo->SetName( m_namebox[x]->GetValue() );
    layerinfodoc->SetName( m_namebox[x]->GetValue() );
}

void LayerPropertiesDialog::Cm_InMap(wxEvent& event )
{
    int x = event.GetId() - ID_INMAP;
    int i = x + m_startvalue;
    a2dLayerInfo* layerinfo = GetLocalLayerInfo(i);
    a2dLayerInfo* layerinfodoc = GetDocLayerInfo(i);
    long t;
    m_gdsinmap[x]->GetValue().ToLong( &t );
    layerinfo->SetInMapping( t );
    layerinfodoc->SetInMapping( t );
}

void LayerPropertiesDialog::Cm_OutMap(wxEvent& event )
{
    int x = event.GetId() - ID_OUTMAP;
    int i = x + m_startvalue;
    long t;
    m_gdsoutmap[x]->GetValue().ToLong( &t );
    a2dLayerInfo* layerinfo = GetLocalLayerInfo(i);
    a2dLayerInfo* layerinfodoc = GetDocLayerInfo(i);
    layerinfo->SetOutMapping( t );
    layerinfodoc->SetOutMapping( t );
}

void LayerPropertiesDialog::Cm_NumberBox(wxEvent& event)
{
    //the button pressed given indirect the layer
    int dlayer = event.GetId() - ID_NUMBER; //which button

    int currentInsertLayer = a2dGetCmdh()->GetLayer();

    if ( currentInsertLayer != m_startvalue + dlayer )
    {
        a2dGetCmdh()->Submit( new a2dCommand_SetLayer( m_startvalue + dlayer, true ) );

        m_numberbox[ dlayer ]->SetBackgroundColour(  wxColour(184,232,241) );
        m_namebox[ dlayer ]->SetBackgroundColour( wxColour(184,232,241) );
        m_numberbox[ dlayer ]->Refresh();
        m_namebox[ dlayer ]->Refresh();
    }
}

void LayerPropertiesDialog::Cm_VisibleBox(wxEvent& event)
{
    int x = event.GetId() - ID_VISIBLE; //which button
    int i = x + m_startvalue;

    a2dLayerInfo* layerinfo = GetLocalLayerInfo(i);
    layerinfo->SetVisible( (bool)m_visiblebox[ x ]->GetValue() );

    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();
    if ( !doc )
        return;
    a2dLayers* layers = doc->GetLayerSetup();
    if ( !layers )
        return;
    a2dLayerInfo* layerinfodoc = layers->GetLayerIndex()[ i ];

    a2dCommand_SetCanvasProperty* command = new a2dCommand_SetCanvasProperty( layerinfodoc, a2dLayerInfo::PROPID_layerVisible, layerinfo->GetVisible() );
    a2dGetCmdh()->Submit( command );
}

void LayerPropertiesDialog::Cm_OutLineBox(wxEvent& event)
{
    //the button pressed given indirect the layer
    int x = event.GetId() - ID_OUTLINE; //which button
    int i = m_startvalue + x;

    a2dLayerInfo* layerinfo = GetDocLayerInfo(i);
    a2dFill fill = layerinfo->GetFill();
    fill.SetFilling( ! (bool)m_outlinebox[ x ]->GetValue() );
    layerinfo->SetFill( fill );

    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();
    if ( !doc )
        return;
    a2dLayers* layers = doc->GetLayerSetup();
    if ( !layers )
        return;
    a2dLayerInfo* layerinfodoc = layers->GetLayerIndex()[ i ];

    layerinfodoc->SetFill( fill );

    //a2dCommand_SetCanvasProperty* command = new a2dCommand_SetCanvasProperty( layerinfodoc, a2dLayerInfo::PROPID_filling, fill.GetFilling() );
    //a2dGetCmdh()->Submit( command );
}

void LayerPropertiesDialog::Cm_SelectBox(wxEvent& event)
{
    //the button pressed given indirect the layer
    int x = event.GetId() - ID_SELECTABLE; //which button
    int i = m_startvalue + x;

    a2dLayerInfo* layerinfo = GetDocLayerInfo(i);
    layerinfo->SetSelectable( (bool)m_selectablebox[ x ]->GetValue() );

    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();
    if ( !doc )
        return;
    a2dLayers* layers = doc->GetLayerSetup();
    if ( !layers )
        return;
    a2dLayerInfo* layerinfodoc = layers->GetLayerIndex()[ i ];

    a2dCommand_SetCanvasProperty* command = new a2dCommand_SetCanvasProperty( layerinfodoc, a2dLayerInfo::PROPID_layerSelectable, layerinfo->GetSelectable() );
    a2dGetCmdh()->Submit( command );
}

void LayerPropertiesDialog::Cm_ReadBox(wxEvent& event)
{
    //the button pressed given indirect the layer
    int x = event.GetId() - ID_READ; //which button
    int i = m_startvalue + x;

    a2dLayerInfo* layerinfo = GetDocLayerInfo(i);
    layerinfo->SetRead( (bool)m_readlayerbox[ x ]->GetValue() );

    a2dCanvasDocument* doc = (a2dCanvasDocument*) a2dDocviewGlobals->GetDocviewCommandProcessor()->GetCurrentDocument();
    if ( !doc )
        return;
    a2dLayers* layers = doc->GetLayerSetup();
    if ( !layers )
        return;
    a2dLayerInfo* layerinfodoc = layers->GetLayerIndex()[ i ];

    a2dCommand_SetCanvasProperty* command = new a2dCommand_SetCanvasProperty( layerinfodoc, a2dLayerInfo::PROPID_readlayer, layerinfo->GetRead() );
    a2dGetCmdh()->Submit( command );
}

void LayerPropertiesDialog::OnChar( wxKeyEvent& event )
{
    if ( event.GetKeyCode() == WXK_RETURN )
    {
    }
    else if ( event.GetKeyCode() == WXK_PAGEDOWN)
    {
        wxCommandEvent eventc; 
        CmNext( eventc );
    }
    else if ( event.GetKeyCode() == WXK_PAGEUP)
    {
        wxCommandEvent eventc; 
        CmPrev( eventc );
    } 
    else
    {
        // key code is within legal range. we call event.Skip() so the
        // event can be processed either in the base wxWindows class
        // or the native control.

        event.Skip();
    }
}

void LayerPropertiesDialog::OnCharHook(wxKeyEvent& event)
{
    if ( event.GetKeyCode() == WXK_RETURN )
    {
        event.Skip();
    }
    else if ( event.GetKeyCode() == WXK_PAGEDOWN)
    {
        wxCommandEvent eventc; 
        CmNext( eventc );
    }
    else if ( event.GetKeyCode() == WXK_PAGEUP)
    {
        wxCommandEvent eventc; 
        CmPrev( eventc );
    } 
    else
    {
        // key code is within legal range. we call event.Skip() so the
        // event can be processed either in the base wxWindows class
        // or the native control.
 
        event.Skip();
    }
}

layerdlg.cpp Source File -- Tue Aug 31 17:56:32 2010 -- 31 Aug 2010 -- 1.5.5 -- wxArt2D -- . -- Reference Documentation