api_pcb_enums.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2024 Jon Evans <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <import_export.h>
#include <api/api_enums.h>
#include <api/board/board.pb.h>
#include <api/board/board_rules.pb.h>
#include <api/board/board_types.pb.h>
#include <api/board/board_commands.pb.h>
#include <api/board/board_jobs.pb.h>
#include <api/common/types/enums.pb.h>
#include <wx/wx.h>
#include <widgets/report_severity.h>
 
#include <board_stackup_manager/board_stackup.h>
#include <constraints/pcb_constraint.h>
#include <drc/drc_item.h>
#include <padstack.h>
#include <pcb_dimension.h>
#include <pcb_track.h>
#include <jobs/job_export_pcb_3d.h>
#include <jobs/job_export_pcb_dxf.h>
#include <jobs/job_export_pcb_drill.h>
#include <jobs/job_export_pcb_idf.h>
#include <jobs/job_export_pcb_ipc2581.h>
#include <jobs/job_export_pcb_odb.h>
#include <jobs/job_export_pcb_pdf.h>
#include <jobs/job_export_pcb_pos.h>
#include <jobs/job_export_pcb_ps.h>
#include <jobs/job_export_pcb_stats.h>
#include <jobs/job_export_pcb_svg.h>
#include <jobs/job_export_pcb_png.h>
#include <jobs/job_pcb_render.h>
#include <drc/drc_rule.h>
#include <plotprint_opts.h>
#include <zones.h>
#include <zone_settings.h>
#include <project/board_project_settings.h>
#include <generators/pcb_tuning_pattern.h>
#include <generators/pcb_via_stack.h>
#include <generators/pcb_via_stitch.h>
 
// Adding something new here?  Add it to test_api_enums.cpp!
 
using namespace kiapi::board;
using namespace kiapi::board::commands;
using namespace kiapi::board::jobs;
 
template<>
types::PadType ToProtoEnum( PAD_ATTRIB aValue )
{
    switch( aValue )
    {
    case PAD_ATTRIB::PTH:   return types::PadType::PT_PTH;
    case PAD_ATTRIB::SMD:   return types::PadType::PT_SMD;
    case PAD_ATTRIB::CONN:  return types::PadType::PT_EDGE_CONNECTOR;
    case PAD_ATTRIB::NPTH:  return types::PadType::PT_NPTH;
 
    default:
        wxCHECK_MSG( false, types::PadType::PT_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PAD_ATTRIB>");
    }
}
 
 
template<>
PAD_ATTRIB FromProtoEnum( types::PadType aValue )
{
    switch( aValue )
    {
    case types::PadType::PT_UNKNOWN:
    case types::PadType::PT_PTH:            return PAD_ATTRIB::PTH;
    case types::PadType::PT_SMD:            return PAD_ATTRIB::SMD;
    case types::PadType::PT_EDGE_CONNECTOR: return PAD_ATTRIB::CONN;
    case types::PadType::PT_NPTH:           return PAD_ATTRIB::NPTH;
 
    default:
        wxCHECK_MSG( false,  PAD_ATTRIB::PTH,
                     "Unhandled case in FromProtoEnum<types::PadType>" );
    }
}
 
template<>
types::DrillShape ToProtoEnum( PAD_DRILL_SHAPE aValue )
{
    switch( aValue )
    {
    case PAD_DRILL_SHAPE::CIRCLE:    return types::DrillShape::DS_CIRCLE;
    case PAD_DRILL_SHAPE::OBLONG:    return types::DrillShape::DS_OBLONG;
    case PAD_DRILL_SHAPE::UNDEFINED: return types::DrillShape::DS_UNDEFINED;
    default:
        wxCHECK_MSG( false, types::DrillShape::DS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PAD_DRILL_SHAPE>");
    }
}
 
template<>
PAD_DRILL_SHAPE FromProtoEnum( types::DrillShape aValue )
{
    switch( aValue )
    {
    case types::DrillShape::DS_CIRCLE:      return PAD_DRILL_SHAPE::CIRCLE;
    case types::DrillShape::DS_OBLONG:      return PAD_DRILL_SHAPE::OBLONG;
    case types::DrillShape::DS_UNKNOWN:
    case types::DrillShape::DS_UNDEFINED:   return PAD_DRILL_SHAPE::UNDEFINED;
    default:
        wxCHECK_MSG( false, PAD_DRILL_SHAPE::UNDEFINED,
                     "Unhandled case in FromProtoEnum<types::DrillShape>" );
    }
}
 
template<>
types::PadStackShape ToProtoEnum( PAD_SHAPE aValue )
{
    switch( aValue )
    {
    case PAD_SHAPE::CIRCLE:         return types::PadStackShape::PSS_CIRCLE;
    case PAD_SHAPE::RECTANGLE:      return types::PadStackShape::PSS_RECTANGLE;
    case PAD_SHAPE::OVAL:           return types::PadStackShape::PSS_OVAL;
    case PAD_SHAPE::TRAPEZOID:      return types::PadStackShape::PSS_TRAPEZOID;
    case PAD_SHAPE::ROUNDRECT:      return types::PadStackShape::PSS_ROUNDRECT;
    case PAD_SHAPE::CHAMFERED_RECT: return types::PadStackShape::PSS_CHAMFEREDRECT;
    case PAD_SHAPE::CUSTOM:         return types::PadStackShape::PSS_CUSTOM;
 
    default:
        wxCHECK_MSG( false, types::PadStackShape::PSS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PAD_SHAPE>");
    }
}
 
 
template<>
PAD_SHAPE FromProtoEnum( types::PadStackShape aValue )
{
    switch( aValue )
    {
    case types::PadStackShape::PSS_UNKNOWN:
    case types::PadStackShape::PSS_CIRCLE:         return PAD_SHAPE::CIRCLE;
    case types::PadStackShape::PSS_RECTANGLE:      return PAD_SHAPE::RECTANGLE;
    case types::PadStackShape::PSS_OVAL:           return PAD_SHAPE::OVAL;
    case types::PadStackShape::PSS_TRAPEZOID:      return PAD_SHAPE::TRAPEZOID;
    case types::PadStackShape::PSS_ROUNDRECT:      return PAD_SHAPE::ROUNDRECT;
    case types::PadStackShape::PSS_CHAMFEREDRECT:  return PAD_SHAPE::CHAMFERED_RECT;
    case types::PadStackShape::PSS_CUSTOM:         return PAD_SHAPE::CUSTOM;
 
    default:
        wxCHECK_MSG( false, PAD_SHAPE::CIRCLE,
                     "Unhandled case in FromProtoEnum<types::PadStackShape>" );
    }
}
 
 
template<>
types::PadStackType ToProtoEnum( PADSTACK::MODE aValue )
{
    switch( aValue )
    {
    case PADSTACK::MODE::NORMAL:           return types::PadStackType::PST_NORMAL;
    case PADSTACK::MODE::FRONT_INNER_BACK: return types::PadStackType::PST_FRONT_INNER_BACK;
    case PADSTACK::MODE::CUSTOM:           return types::PadStackType::PST_CUSTOM;
 
    default:
        wxCHECK_MSG( false, types::PadStackType::PST_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PADSTACK::MODE>");
    }
}
 
 
template<>
PADSTACK::MODE FromProtoEnum( types::PadStackType aValue )
{
    switch( aValue )
    {
    case types::PadStackType::PST_UNKNOWN:
    case types::PadStackType::PST_NORMAL:           return PADSTACK::MODE::NORMAL;
    case types::PadStackType::PST_FRONT_INNER_BACK: return PADSTACK::MODE::FRONT_INNER_BACK;
    case types::PadStackType::PST_CUSTOM:           return PADSTACK::MODE::CUSTOM;
 
    default:
        wxCHECK_MSG( false, PADSTACK::MODE::NORMAL,
                     "Unhandled case in FromProtoEnum<types::PadStackType>" );
    }
}
 
 
template<>
PAD_PROP FromProtoEnum( types::PadFabricationProperty aValue )
{
    switch( aValue )
    {
    case types::PadFabricationProperty::PFP_UNKNOWN:
    case types::PadFabricationProperty::PFP_NONE:            return PAD_PROP::NONE;
    case types::PadFabricationProperty::PFP_BGA:             return PAD_PROP::BGA;
    case types::PadFabricationProperty::PFP_FIDUCIAL_GLOBAL: return PAD_PROP::FIDUCIAL_GLBL;
    case types::PadFabricationProperty::PFP_FIDUCIAL_LOCAL:  return PAD_PROP::FIDUCIAL_LOCAL;
    case types::PadFabricationProperty::PFP_TESTPOINT:       return PAD_PROP::TESTPOINT;
    case types::PadFabricationProperty::PFP_HEATSINK:        return PAD_PROP::HEATSINK;
    case types::PadFabricationProperty::PFP_CASTELLATED:     return PAD_PROP::CASTELLATED;
    case types::PadFabricationProperty::PFP_MECHANICAL:      return PAD_PROP::MECHANICAL;
    case types::PadFabricationProperty::PFP_PRESSFIT:        return PAD_PROP::PRESSFIT;
 
    default:
        wxCHECK_MSG( false, PAD_PROP::NONE,
                     "Unhandled case in FromProtoEnum<types::PadFabricationProperty>" );
    }
}
 
 
template<>
types::PadFabricationProperty ToProtoEnum( PAD_PROP aValue )
{
    switch( aValue )
    {
    case PAD_PROP::NONE:           return types::PadFabricationProperty::PFP_NONE;
    case PAD_PROP::BGA:            return types::PadFabricationProperty::PFP_BGA;
    case PAD_PROP::FIDUCIAL_GLBL:  return types::PadFabricationProperty::PFP_FIDUCIAL_GLOBAL;
    case PAD_PROP::FIDUCIAL_LOCAL: return types::PadFabricationProperty::PFP_FIDUCIAL_LOCAL;
    case PAD_PROP::TESTPOINT:      return types::PadFabricationProperty::PFP_TESTPOINT;
    case PAD_PROP::HEATSINK:       return types::PadFabricationProperty::PFP_HEATSINK;
    case PAD_PROP::CASTELLATED:    return types::PadFabricationProperty::PFP_CASTELLATED;
    case PAD_PROP::MECHANICAL:     return types::PadFabricationProperty::PFP_MECHANICAL;
    case PAD_PROP::PRESSFIT:       return types::PadFabricationProperty::PFP_PRESSFIT;
 
    default:
        wxCHECK_MSG( false, types::PadFabricationProperty::PFP_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PAD_PROP>" );
    }
}
 
 
template<>
types::ViaType ToProtoEnum( VIATYPE aValue )
{
    switch( aValue )
    {
    case VIATYPE::THROUGH:      return types::ViaType::VT_THROUGH;
    case VIATYPE::BLIND:        return types::ViaType::VT_BLIND; // Since V10
    case VIATYPE::BURIED:       return types::ViaType::VT_BURIED;
    case VIATYPE::MICROVIA:     return types::ViaType::VT_MICRO;
 
    default:
        wxCHECK_MSG( false, types::ViaType::VT_UNKNOWN,
                     "Unhandled case in ToProtoEnum<VIATYPE>");
    }
}
 
 
template<>
VIATYPE FromProtoEnum( types::ViaType aValue )
{
    switch( aValue )
    {
    case types::ViaType::VT_UNKNOWN:
    case types::ViaType::VT_THROUGH:      return VIATYPE::THROUGH;
    case types::ViaType::VT_BLIND_BURIED: return VIATYPE::BLIND;
    case types::ViaType::VT_BLIND:        return VIATYPE::BLIND;    // Since V10
    case types::ViaType::VT_BURIED:       return VIATYPE::BURIED;
    case types::ViaType::VT_MICRO:        return VIATYPE::MICROVIA;
 
    default:
        wxCHECK_MSG( false, VIATYPE::THROUGH,
                     "Unhandled case in FromProtoEnum<types::ViaType>" );
    }
}
 
 
template<>
types::ZoneConnectionStyle ToProtoEnum( ZONE_CONNECTION aValue )
{
    switch( aValue )
    {
    case ZONE_CONNECTION::INHERITED:    return types::ZoneConnectionStyle::ZCS_INHERITED;
    case ZONE_CONNECTION::NONE:         return types::ZoneConnectionStyle::ZCS_NONE;
    case ZONE_CONNECTION::THERMAL:      return types::ZoneConnectionStyle::ZCS_THERMAL;
    case ZONE_CONNECTION::FULL:         return types::ZoneConnectionStyle::ZCS_FULL;
    case ZONE_CONNECTION::THT_THERMAL:  return types::ZoneConnectionStyle::ZCS_PTH_THERMAL;
 
    default:
        wxCHECK_MSG( false, types::ZoneConnectionStyle::ZCS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<ZONE_CONNECTION>");
    }
}
 
 
template<>
ZONE_CONNECTION FromProtoEnum( types::ZoneConnectionStyle aValue )
{
    switch( aValue )
    {
    case types::ZoneConnectionStyle::ZCS_UNKNOWN:      return ZONE_CONNECTION::INHERITED;
    case types::ZoneConnectionStyle::ZCS_INHERITED:    return ZONE_CONNECTION::INHERITED;
    case types::ZoneConnectionStyle::ZCS_NONE:         return ZONE_CONNECTION::NONE;
    case types::ZoneConnectionStyle::ZCS_THERMAL:      return ZONE_CONNECTION::THERMAL;
    case types::ZoneConnectionStyle::ZCS_FULL:         return ZONE_CONNECTION::FULL;
    case types::ZoneConnectionStyle::ZCS_PTH_THERMAL:  return ZONE_CONNECTION::THT_THERMAL;
 
    default:
        wxCHECK_MSG( false, ZONE_CONNECTION::INHERITED,
                     "Unhandled case in FromProtoEnum<types::ZoneConnectionStyle>" );
    }
}
 
 
template<>
CustomRuleConstraintType ToProtoEnum( DRC_CONSTRAINT_T aValue )
{
    switch( aValue )
    {
    case NULL_CONSTRAINT:                 return CustomRuleConstraintType::CRCT_UNKNOWN;
    case CLEARANCE_CONSTRAINT:            return CustomRuleConstraintType::CRCT_CLEARANCE;
    case CREEPAGE_CONSTRAINT:             return CustomRuleConstraintType::CRCT_CREEPAGE;
    case HOLE_CLEARANCE_CONSTRAINT:       return CustomRuleConstraintType::CRCT_HOLE_CLEARANCE;
    case HOLE_TO_HOLE_CONSTRAINT:         return CustomRuleConstraintType::CRCT_HOLE_TO_HOLE;
    case EDGE_CLEARANCE_CONSTRAINT:       return CustomRuleConstraintType::CRCT_EDGE_CLEARANCE;
    case HOLE_SIZE_CONSTRAINT:            return CustomRuleConstraintType::CRCT_HOLE_SIZE;
    case COURTYARD_CLEARANCE_CONSTRAINT:  return CustomRuleConstraintType::CRCT_COURTYARD_CLEARANCE;
    case SILK_CLEARANCE_CONSTRAINT:       return CustomRuleConstraintType::CRCT_SILK_CLEARANCE;
    case TEXT_HEIGHT_CONSTRAINT:          return CustomRuleConstraintType::CRCT_TEXT_HEIGHT;
    case TEXT_THICKNESS_CONSTRAINT:       return CustomRuleConstraintType::CRCT_TEXT_THICKNESS;
    case TRACK_WIDTH_CONSTRAINT:          return CustomRuleConstraintType::CRCT_TRACK_WIDTH;
    case TRACK_SEGMENT_LENGTH_CONSTRAINT: return CustomRuleConstraintType::CRCT_TRACK_SEGMENT_LENGTH;
    case ANNULAR_WIDTH_CONSTRAINT:        return CustomRuleConstraintType::CRCT_ANNULAR_WIDTH;
    case ZONE_CONNECTION_CONSTRAINT:      return CustomRuleConstraintType::CRCT_ZONE_CONNECTION;
    case THERMAL_RELIEF_GAP_CONSTRAINT:   return CustomRuleConstraintType::CRCT_THERMAL_RELIEF_GAP;
    case THERMAL_SPOKE_WIDTH_CONSTRAINT:  return CustomRuleConstraintType::CRCT_THERMAL_SPOKE_WIDTH;
    case MIN_RESOLVED_SPOKES_CONSTRAINT:  return CustomRuleConstraintType::CRCT_MIN_RESOLVED_SPOKES;
    case MICROVIA_STACK_DEPTH_CONSTRAINT: return CustomRuleConstraintType::CRCT_MICROVIA_STACK_DEPTH;
    case MICROVIA_ASPECT_RATIO_CONSTRAINT: return CustomRuleConstraintType::CRCT_MICROVIA_ASPECT_RATIO;
    case SOLDER_MASK_EXPANSION_CONSTRAINT:return CustomRuleConstraintType::CRCT_SOLDER_MASK_EXPANSION;
    case SOLDER_PASTE_ABS_MARGIN_CONSTRAINT:return CustomRuleConstraintType::CRCT_SOLDER_PASTE_ABS_MARGIN;
    case SOLDER_PASTE_REL_MARGIN_CONSTRAINT:return CustomRuleConstraintType::CRCT_SOLDER_PASTE_REL_MARGIN;
    case DISALLOW_CONSTRAINT:             return CustomRuleConstraintType::CRCT_DISALLOW;
    case VIA_DIAMETER_CONSTRAINT:         return CustomRuleConstraintType::CRCT_VIA_DIAMETER;
    case LENGTH_CONSTRAINT:               return CustomRuleConstraintType::CRCT_LENGTH;
    case SKEW_CONSTRAINT:                 return CustomRuleConstraintType::CRCT_SKEW;
    case DIFF_PAIR_GAP_CONSTRAINT:        return CustomRuleConstraintType::CRCT_DIFF_PAIR_GAP;
    case MAX_UNCOUPLED_CONSTRAINT:        return CustomRuleConstraintType::CRCT_MAX_UNCOUPLED;
    case DIFF_PAIR_INTRA_SKEW_CONSTRAINT: return CustomRuleConstraintType::CRCT_DIFF_PAIR_INTRA_SKEW;
    case VIA_COUNT_CONSTRAINT:            return CustomRuleConstraintType::CRCT_VIA_COUNT;
    case PHYSICAL_CLEARANCE_CONSTRAINT:   return CustomRuleConstraintType::CRCT_PHYSICAL_CLEARANCE;
    case PHYSICAL_HOLE_CLEARANCE_CONSTRAINT:return CustomRuleConstraintType::CRCT_PHYSICAL_HOLE_CLEARANCE;
    case ASSERTION_CONSTRAINT:            return CustomRuleConstraintType::CRCT_ASSERTION;
    case CONNECTION_WIDTH_CONSTRAINT:     return CustomRuleConstraintType::CRCT_CONNECTION_WIDTH;
    case TRACK_ANGLE_CONSTRAINT:          return CustomRuleConstraintType::CRCT_TRACK_ANGLE;
    case VIA_DANGLING_CONSTRAINT:         return CustomRuleConstraintType::CRCT_VIA_DANGLING;
    case BRIDGED_MASK_CONSTRAINT:         return CustomRuleConstraintType::CRCT_BRIDGED_MASK;
    case SOLDER_MASK_SLIVER_CONSTRAINT:   return CustomRuleConstraintType::CRCT_SOLDER_MASK_SLIVER;
    case NET_CHAIN_LENGTH_CONSTRAINT:        return CustomRuleConstraintType::CRCT_NET_CHAIN_LENGTH;
    case NET_CHAIN_STUB_LENGTH_CONSTRAINT:
        return CustomRuleConstraintType::CRCT_NET_CHAIN_STUB_LENGTH;
    case NET_CHAIN_RETURN_PATH_CONSTRAINT:
        return CustomRuleConstraintType::CRCT_NET_CHAIN_RETURN_PATH;
 
    default:
        wxCHECK_MSG( false, CustomRuleConstraintType::CRCT_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DRC_CONSTRAINT_T>" );
    }
}
 
 
template<>
DRC_CONSTRAINT_T FromProtoEnum( CustomRuleConstraintType aValue )
{
    switch( aValue )
    {
    case CustomRuleConstraintType::CRCT_UNKNOWN:               return NULL_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_CLEARANCE:             return CLEARANCE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_CREEPAGE:              return CREEPAGE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_HOLE_CLEARANCE:        return HOLE_CLEARANCE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_HOLE_TO_HOLE:          return HOLE_TO_HOLE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_EDGE_CLEARANCE:        return EDGE_CLEARANCE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_HOLE_SIZE:             return HOLE_SIZE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_COURTYARD_CLEARANCE:   return COURTYARD_CLEARANCE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_SILK_CLEARANCE:        return SILK_CLEARANCE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_TEXT_HEIGHT:           return TEXT_HEIGHT_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_TEXT_THICKNESS:        return TEXT_THICKNESS_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_TRACK_WIDTH:           return TRACK_WIDTH_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_TRACK_SEGMENT_LENGTH:  return TRACK_SEGMENT_LENGTH_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_ANNULAR_WIDTH:         return ANNULAR_WIDTH_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_ZONE_CONNECTION:       return ZONE_CONNECTION_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_THERMAL_RELIEF_GAP:    return THERMAL_RELIEF_GAP_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_THERMAL_SPOKE_WIDTH:   return THERMAL_SPOKE_WIDTH_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_MIN_RESOLVED_SPOKES:   return MIN_RESOLVED_SPOKES_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_MICROVIA_STACK_DEPTH:  return MICROVIA_STACK_DEPTH_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_MICROVIA_ASPECT_RATIO: return MICROVIA_ASPECT_RATIO_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_SOLDER_MASK_EXPANSION: return SOLDER_MASK_EXPANSION_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_SOLDER_PASTE_ABS_MARGIN:return SOLDER_PASTE_ABS_MARGIN_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_SOLDER_PASTE_REL_MARGIN:return SOLDER_PASTE_REL_MARGIN_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_DISALLOW:              return DISALLOW_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_VIA_DIAMETER:          return VIA_DIAMETER_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_LENGTH:                return LENGTH_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_SKEW:                  return SKEW_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_DIFF_PAIR_GAP:         return DIFF_PAIR_GAP_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_MAX_UNCOUPLED:         return MAX_UNCOUPLED_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_DIFF_PAIR_INTRA_SKEW:  return DIFF_PAIR_INTRA_SKEW_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_VIA_COUNT:             return VIA_COUNT_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_PHYSICAL_CLEARANCE:    return PHYSICAL_CLEARANCE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_PHYSICAL_HOLE_CLEARANCE:return PHYSICAL_HOLE_CLEARANCE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_ASSERTION:             return ASSERTION_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_CONNECTION_WIDTH:      return CONNECTION_WIDTH_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_TRACK_ANGLE:           return TRACK_ANGLE_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_VIA_DANGLING:          return VIA_DANGLING_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_BRIDGED_MASK:          return BRIDGED_MASK_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_SOLDER_MASK_SLIVER:    return SOLDER_MASK_SLIVER_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_NET_CHAIN_LENGTH:         return NET_CHAIN_LENGTH_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_NET_CHAIN_STUB_LENGTH: return NET_CHAIN_STUB_LENGTH_CONSTRAINT;
    case CustomRuleConstraintType::CRCT_NET_CHAIN_RETURN_PATH: return NET_CHAIN_RETURN_PATH_CONSTRAINT;
 
    default:
        wxCHECK_MSG( false, NULL_CONSTRAINT,
                     "Unhandled case in FromProtoEnum<CustomRuleConstraintType>" );
    }
}
 
 
template<>
CustomRuleConstraintOption ToProtoEnum( DRC_CONSTRAINT::OPTIONS aValue )
{
    switch( aValue )
    {
    case DRC_CONSTRAINT::OPTIONS::SKEW_WITHIN_DIFF_PAIRS: return CustomRuleConstraintOption::CRCO_SKEW_WITHIN_DIFF_PAIRS;
    case DRC_CONSTRAINT::OPTIONS::SPACE_DOMAIN:           return CustomRuleConstraintOption::CRCO_SPACE_DOMAIN;
    case DRC_CONSTRAINT::OPTIONS::TIME_DOMAIN:            return CustomRuleConstraintOption::CRCO_TIME_DOMAIN;
 
    default:
        wxCHECK_MSG( false, CustomRuleConstraintOption::CRCO_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DRC_CONSTRAINT::OPTIONS>" );
    }
}
 
 
template<>
DRC_CONSTRAINT::OPTIONS FromProtoEnum( CustomRuleConstraintOption aValue )
{
    switch( aValue )
    {
    case CustomRuleConstraintOption::CRCO_SKEW_WITHIN_DIFF_PAIRS:
        return DRC_CONSTRAINT::OPTIONS::SKEW_WITHIN_DIFF_PAIRS;
 
    case CustomRuleConstraintOption::CRCO_SPACE_DOMAIN:
        return DRC_CONSTRAINT::OPTIONS::SPACE_DOMAIN;
 
    case CustomRuleConstraintOption::CRCO_TIME_DOMAIN:
        return DRC_CONSTRAINT::OPTIONS::TIME_DOMAIN;
 
    case CustomRuleConstraintOption::CRCO_UNKNOWN:
    default:
        wxCHECK_MSG( false, DRC_CONSTRAINT::OPTIONS::SKEW_WITHIN_DIFF_PAIRS,
                     "Unhandled case in FromProtoEnum<CustomRuleConstraintOption>" );
    }
}
 
 
template<>
CustomRuleDisallowType ToProtoEnum( DRC_DISALLOW_T aValue )
{
    switch( aValue )
    {
    case DRC_DISALLOW_THROUGH_VIAS: return CustomRuleDisallowType::CRDT_THROUGH_VIAS;
    case DRC_DISALLOW_MICRO_VIAS:   return CustomRuleDisallowType::CRDT_MICRO_VIAS;
    case DRC_DISALLOW_BLIND_VIAS:   return CustomRuleDisallowType::CRDT_BLIND_VIAS;
    case DRC_DISALLOW_BURIED_VIAS:  return CustomRuleDisallowType::CRDT_BURIED_VIAS;
    case DRC_DISALLOW_TRACKS:       return CustomRuleDisallowType::CRDT_TRACKS;
    case DRC_DISALLOW_PADS:         return CustomRuleDisallowType::CRDT_PADS;
    case DRC_DISALLOW_ZONES:        return CustomRuleDisallowType::CRDT_ZONES;
    case DRC_DISALLOW_TEXTS:        return CustomRuleDisallowType::CRDT_TEXTS;
    case DRC_DISALLOW_GRAPHICS:     return CustomRuleDisallowType::CRDT_GRAPHICS;
    case DRC_DISALLOW_HOLES:        return CustomRuleDisallowType::CRDT_HOLES;
    case DRC_DISALLOW_FOOTPRINTS:   return CustomRuleDisallowType::CRDT_FOOTPRINTS;
 
    default:
        wxCHECK_MSG( false, CustomRuleDisallowType::CRDT_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DRC_DISALLOW_T>" );
    }
}
 
 
template<>
DRC_DISALLOW_T FromProtoEnum( CustomRuleDisallowType aValue )
{
    switch( aValue )
    {
    case CustomRuleDisallowType::CRDT_THROUGH_VIAS: return DRC_DISALLOW_THROUGH_VIAS;
    case CustomRuleDisallowType::CRDT_MICRO_VIAS:   return DRC_DISALLOW_MICRO_VIAS;
    case CustomRuleDisallowType::CRDT_BLIND_VIAS:   return DRC_DISALLOW_BLIND_VIAS;
    case CustomRuleDisallowType::CRDT_BURIED_VIAS:  return DRC_DISALLOW_BURIED_VIAS;
    case CustomRuleDisallowType::CRDT_TRACKS:       return DRC_DISALLOW_TRACKS;
    case CustomRuleDisallowType::CRDT_PADS:         return DRC_DISALLOW_PADS;
    case CustomRuleDisallowType::CRDT_ZONES:        return DRC_DISALLOW_ZONES;
    case CustomRuleDisallowType::CRDT_TEXTS:        return DRC_DISALLOW_TEXTS;
    case CustomRuleDisallowType::CRDT_GRAPHICS:     return DRC_DISALLOW_GRAPHICS;
    case CustomRuleDisallowType::CRDT_HOLES:        return DRC_DISALLOW_HOLES;
    case CustomRuleDisallowType::CRDT_FOOTPRINTS:   return DRC_DISALLOW_FOOTPRINTS;
 
    case CustomRuleDisallowType::CRDT_UNKNOWN:
    default:
        wxCHECK_MSG( false, DRC_DISALLOW_THROUGH_VIAS,
                     "Unhandled case in FromProtoEnum<CustomRuleDisallowType>" );
    }
}
 
 
template<>
types::UnconnectedLayerRemoval ToProtoEnum( UNCONNECTED_LAYER_MODE aValue )
{
    switch( aValue )
    {
    case UNCONNECTED_LAYER_MODE::KEEP_ALL:
        return types::UnconnectedLayerRemoval::ULR_KEEP;
 
    case UNCONNECTED_LAYER_MODE::REMOVE_ALL:
        return types::UnconnectedLayerRemoval::ULR_REMOVE;
 
    case UNCONNECTED_LAYER_MODE::REMOVE_EXCEPT_START_AND_END:
        return types::UnconnectedLayerRemoval::ULR_REMOVE_EXCEPT_START_AND_END;
 
    case UNCONNECTED_LAYER_MODE::START_END_ONLY:
        return types::UnconnectedLayerRemoval::ULR_START_END_ONLY;
 
    default:
        wxCHECK_MSG( false, types::UnconnectedLayerRemoval::ULR_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PADSTACK::UNCONNECTED_LAYER_MODE>");
    }
}
 
 
template<>
UNCONNECTED_LAYER_MODE FromProtoEnum( types::UnconnectedLayerRemoval aValue )
{
    switch( aValue )
    {
    case types::UnconnectedLayerRemoval::ULR_UNKNOWN:
    case types::UnconnectedLayerRemoval::ULR_KEEP:
        return UNCONNECTED_LAYER_MODE::KEEP_ALL;
 
    case types::UnconnectedLayerRemoval::ULR_REMOVE:
        return UNCONNECTED_LAYER_MODE::REMOVE_ALL;
 
    case types::UnconnectedLayerRemoval::ULR_REMOVE_EXCEPT_START_AND_END:
        return UNCONNECTED_LAYER_MODE::REMOVE_EXCEPT_START_AND_END;
 
    case types::UnconnectedLayerRemoval::ULR_START_END_ONLY:
        return UNCONNECTED_LAYER_MODE::START_END_ONLY;
 
    default:
        wxCHECK_MSG( false, UNCONNECTED_LAYER_MODE::KEEP_ALL,
                     "Unhandled case in FromProtoEnum<types::UnconnectedLayerRemoval>");
    }
}
 
 
template<>
types::IslandRemovalMode ToProtoEnum( ISLAND_REMOVAL_MODE aValue )
{
    switch( aValue )
    {
    case ISLAND_REMOVAL_MODE::ALWAYS:   return types::IslandRemovalMode::IRM_ALWAYS;
    case ISLAND_REMOVAL_MODE::NEVER:    return types::IslandRemovalMode::IRM_NEVER;
    case ISLAND_REMOVAL_MODE::AREA:     return types::IslandRemovalMode::IRM_AREA;
 
    default:
        wxCHECK_MSG( false, types::IslandRemovalMode::IRM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<ISLAND_REMOVAL_MODE>");
    }
}
 
 
template<>
ISLAND_REMOVAL_MODE FromProtoEnum( types::IslandRemovalMode aValue )
{
    switch( aValue )
    {
    case types::IslandRemovalMode::IRM_UNKNOWN:
    case types::IslandRemovalMode::IRM_ALWAYS:  return ISLAND_REMOVAL_MODE::ALWAYS;
    case types::IslandRemovalMode::IRM_NEVER:   return ISLAND_REMOVAL_MODE::NEVER;
    case types::IslandRemovalMode::IRM_AREA:    return ISLAND_REMOVAL_MODE::AREA;
 
    default:
        wxCHECK_MSG( false, ISLAND_REMOVAL_MODE::ALWAYS,
                     "Unhandled case in FromProtoEnum<types::IslandRemovalMode>" );
    }
}
 
 
template<>
types::ZoneFillMode ToProtoEnum( ZONE_FILL_MODE aValue )
{
    switch( aValue )
    {
    case ZONE_FILL_MODE::POLYGONS:        return types::ZoneFillMode::ZFM_SOLID;
    case ZONE_FILL_MODE::HATCH_PATTERN:   return types::ZoneFillMode::ZFM_HATCHED;
    case ZONE_FILL_MODE::COPPER_THIEVING: return types::ZoneFillMode::ZFM_COPPER_THIEVING;
 
    default:
        wxCHECK_MSG( false, types::ZoneFillMode::ZFM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<ZONE_FILL_MODE>");
    }
}
 
 
template<>
ZONE_FILL_MODE FromProtoEnum( types::ZoneFillMode aValue )
{
    switch( aValue )
    {
    case types::ZoneFillMode::ZFM_UNKNOWN:
    case types::ZoneFillMode::ZFM_SOLID:           return ZONE_FILL_MODE::POLYGONS;
    case types::ZoneFillMode::ZFM_HATCHED:         return ZONE_FILL_MODE::HATCH_PATTERN;
    case types::ZoneFillMode::ZFM_COPPER_THIEVING: return ZONE_FILL_MODE::COPPER_THIEVING;
 
    default:
        wxCHECK_MSG( false, ZONE_FILL_MODE::POLYGONS,
                     "Unhandled case in FromProtoEnum<types::ZoneFillMode>" );
    }
}
 
 
template<>
types::ZoneCornerSmoothingMode ToProtoEnum( ZONE_SETTINGS::CORNER_SMOOTHING aValue )
{
    switch( aValue )
    {
    case ZONE_SETTINGS::CORNER_SMOOTHING::NO_SMOOTHING:    return types::ZoneCornerSmoothingMode::ZCSM_NONE;
    case ZONE_SETTINGS::CORNER_SMOOTHING::CHAMFER: return types::ZoneCornerSmoothingMode::ZCSM_CHAMFER;
    case ZONE_SETTINGS::CORNER_SMOOTHING::FILLET:  return types::ZoneCornerSmoothingMode::ZCSM_FILLET;
 
    default:
        wxCHECK_MSG( false, types::ZoneCornerSmoothingMode::ZCSM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<ZONE_SETTINGS::CORNER_SMOOTHING>" );
    }
}
 
 
template<>
ZONE_SETTINGS::CORNER_SMOOTHING FromProtoEnum( types::ZoneCornerSmoothingMode aValue )
{
    switch( aValue )
    {
    case types::ZoneCornerSmoothingMode::ZCSM_UNKNOWN:
    case types::ZoneCornerSmoothingMode::ZCSM_NONE:     return ZONE_SETTINGS::CORNER_SMOOTHING::NO_SMOOTHING;
    case types::ZoneCornerSmoothingMode::ZCSM_CHAMFER:  return ZONE_SETTINGS::CORNER_SMOOTHING::CHAMFER;
    case types::ZoneCornerSmoothingMode::ZCSM_FILLET:   return ZONE_SETTINGS::CORNER_SMOOTHING::FILLET;
 
    default:
        wxCHECK_MSG( false, ZONE_SETTINGS::CORNER_SMOOTHING::NO_SMOOTHING,
                     "Unhandled case in FromProtoEnum<ZoneCornerSmoothingMode>" );
    }
}
 
 
template<>
types::ThievingPattern ToProtoEnum( THIEVING_PATTERN aValue )
{
    switch( aValue )
    {
    case THIEVING_PATTERN::DOTS:       return types::ThievingPattern::TP_DOTS;
    case THIEVING_PATTERN::SQUARES:    return types::ThievingPattern::TP_SQUARES;
    case THIEVING_PATTERN::HATCH: return types::ThievingPattern::TP_CROSSHATCH;
 
    default:
        wxCHECK_MSG( false, types::ThievingPattern::TP_UNKNOWN,
                     "Unhandled case in ToProtoEnum<THIEVING_PATTERN>" );
    }
}
 
 
template<>
THIEVING_PATTERN FromProtoEnum( types::ThievingPattern aValue )
{
    switch( aValue )
    {
    case types::ThievingPattern::TP_UNKNOWN:
    case types::ThievingPattern::TP_DOTS:       return THIEVING_PATTERN::DOTS;
    case types::ThievingPattern::TP_SQUARES:    return THIEVING_PATTERN::SQUARES;
    case types::ThievingPattern::TP_CROSSHATCH: return THIEVING_PATTERN::HATCH;
 
    default:
        wxCHECK_MSG( false, THIEVING_PATTERN::DOTS,
                     "Unhandled case in FromProtoEnum<types::ThievingPattern>" );
    }
}
 
 
template<>
types::ZoneBorderStyle ToProtoEnum( ZONE_BORDER_DISPLAY_STYLE aValue )
{
    switch( aValue )
    {
    case ZONE_BORDER_DISPLAY_STYLE::NO_HATCH:         return types::ZoneBorderStyle::ZBS_SOLID;
    case ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_FULL:    return types::ZoneBorderStyle::ZBS_DIAGONAL_FULL;
    case ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE:    return types::ZoneBorderStyle::ZBS_DIAGONAL_EDGE;
    case ZONE_BORDER_DISPLAY_STYLE::INVISIBLE_BORDER: return types::ZoneBorderStyle::ZBS_INVISIBLE;
 
    default:
        wxCHECK_MSG( false, types::ZoneBorderStyle::ZBS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<ZONE_BORDER_DISPLAY_STYLE>");
    }
}
 
 
template<>
ZONE_BORDER_DISPLAY_STYLE FromProtoEnum( types::ZoneBorderStyle aValue )
{
    switch( aValue )
    {
    case types::ZoneBorderStyle::ZBS_SOLID:         return ZONE_BORDER_DISPLAY_STYLE::NO_HATCH;
    case types::ZoneBorderStyle::ZBS_DIAGONAL_FULL: return ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_FULL;
    case types::ZoneBorderStyle::ZBS_UNKNOWN:
    case types::ZoneBorderStyle::ZBS_DIAGONAL_EDGE: return ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE;
    case types::ZoneBorderStyle::ZBS_INVISIBLE:     return ZONE_BORDER_DISPLAY_STYLE::INVISIBLE_BORDER;
 
    default:
        wxCHECK_MSG( false, ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
                     "Unhandled case in FromProtoEnum<types::ZoneHatchBorderMode>" );
    }
}
 
 
template<>
types::PlacementRuleSourceType ToProtoEnum( PLACEMENT_SOURCE_T aValue )
{
    switch( aValue )
    {
    case PLACEMENT_SOURCE_T::SHEETNAME:
        return types::PlacementRuleSourceType::PRST_SHEET_NAME;
 
    case PLACEMENT_SOURCE_T::COMPONENT_CLASS:
        return types::PlacementRuleSourceType::PRST_COMPONENT_CLASS;
 
    case PLACEMENT_SOURCE_T::GROUP_PLACEMENT:
        return types::PlacementRuleSourceType::PRST_GROUP;
 
    case PLACEMENT_SOURCE_T::DESIGN_BLOCK:
        return types::PlacementRuleSourceType::PRST_DESIGN_BLOCK;
 
    default:
        wxCHECK_MSG( false, types::PlacementRuleSourceType::PRST_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PLACEMENT_SOURCE_T>");
    }
}
 
 
template<>
PLACEMENT_SOURCE_T FromProtoEnum( types::PlacementRuleSourceType aValue )
{
    switch( aValue )
    {
    case types::PlacementRuleSourceType::PRST_UNKNOWN:
    case types::PlacementRuleSourceType::PRST_SHEET_NAME:
        return PLACEMENT_SOURCE_T::SHEETNAME;
 
    case types::PlacementRuleSourceType::PRST_COMPONENT_CLASS:
        return PLACEMENT_SOURCE_T::COMPONENT_CLASS;
 
    case types::PlacementRuleSourceType::PRST_GROUP:
        return PLACEMENT_SOURCE_T::GROUP_PLACEMENT;
 
    case types::PlacementRuleSourceType::PRST_DESIGN_BLOCK:
        return PLACEMENT_SOURCE_T::DESIGN_BLOCK;
 
    default:
        wxCHECK_MSG( false, PLACEMENT_SOURCE_T::SHEETNAME,
                     "Unhandled case in FromProtoEnum<types::PlacementRuleSourceType>" );
    }
}
 
 
template<>
types::ZoneTeardropType ToProtoEnum( TEARDROP_TYPE aValue )
{
    switch( aValue )
    {
    case TEARDROP_TYPE::TD_NONE:        return types::ZoneTeardropType::ZTDT_NONE;
    case TEARDROP_TYPE::TD_UNSPECIFIED: return types::ZoneTeardropType::ZTDT_UNSPECIFIED;
    case TEARDROP_TYPE::TD_VIAPAD:      return types::ZoneTeardropType::ZTDT_VIA_PAD;
    case TEARDROP_TYPE::TD_TRACKEND:    return types::ZoneTeardropType::ZTDT_TRACK_END;
 
    default:
        wxCHECK_MSG( false, types::ZoneTeardropType::ZTDT_UNKNOWN,
                     "Unhandled case in ToProtoEnum<TEARDROP_TYPE>");
    }
}
 
 
template<>
TEARDROP_TYPE FromProtoEnum( types::ZoneTeardropType aValue )
{
    switch( aValue )
    {
    case types::ZoneTeardropType::ZTDT_UNKNOWN:
    case types::ZoneTeardropType::ZTDT_NONE:         return TEARDROP_TYPE::TD_NONE;
    case types::ZoneTeardropType::ZTDT_UNSPECIFIED:  return TEARDROP_TYPE::TD_UNSPECIFIED;
    case types::ZoneTeardropType::ZTDT_VIA_PAD:      return TEARDROP_TYPE::TD_VIAPAD;
    case types::ZoneTeardropType::ZTDT_TRACK_END:    return TEARDROP_TYPE::TD_TRACKEND;
 
    default:
        wxCHECK_MSG( false, TEARDROP_TYPE::TD_NONE,
                     "Unhandled case in FromProtoEnum<types::ZoneTeardropType>" );
    }
}
 
 
template<>
kiapi::board::TeardropTarget ToProtoEnum( TARGET_TD aValue )
{
    switch( aValue )
    {
    case TARGET_ROUND: return kiapi::board::TeardropTarget::TDT_ROUND;
    case TARGET_RECT:  return kiapi::board::TeardropTarget::TDT_RECT;
    case TARGET_TRACK: return kiapi::board::TeardropTarget::TDT_TRACK;
 
    default:
        wxCHECK_MSG( false, kiapi::board::TeardropTarget::TDT_UNKNOWN,
                     "Unhandled case in ToProtoEnum<TARGET_TD>" );
    }
}
 
 
template<>
TARGET_TD FromProtoEnum( kiapi::board::TeardropTarget aValue )
{
    switch( aValue )
    {
    case kiapi::board::TeardropTarget::TDT_ROUND: return TARGET_ROUND;
    case kiapi::board::TeardropTarget::TDT_RECT:  return TARGET_RECT;
    case kiapi::board::TeardropTarget::TDT_TRACK: return TARGET_TRACK;
 
    case kiapi::board::TeardropTarget::TDT_UNKNOWN:
    default:
        return TARGET_UNKNOWN;
    }
}
 
 
template<>
types::DimensionTextBorderStyle ToProtoEnum( DIM_TEXT_BORDER aValue )
{
    switch( aValue )
    {
    case DIM_TEXT_BORDER::NONE:         return types::DimensionTextBorderStyle::DTBS_NONE;
    case DIM_TEXT_BORDER::RECTANGLE:    return types::DimensionTextBorderStyle::DTBS_RECTANGLE;
    case DIM_TEXT_BORDER::CIRCLE:       return types::DimensionTextBorderStyle::DTBS_CIRCLE;
    case DIM_TEXT_BORDER::ROUNDRECT:    return types::DimensionTextBorderStyle::DTBS_ROUNDRECT;
 
    default:
        wxCHECK_MSG( false, types::DimensionTextBorderStyle::DTBS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DIM_TEXT_BORDER>");
    }
}
 
 
template<>
DIM_TEXT_BORDER FromProtoEnum( types::DimensionTextBorderStyle aValue )
{
    switch( aValue )
    {
    case types::DimensionTextBorderStyle::DTBS_UNKNOWN:
    case types::DimensionTextBorderStyle::DTBS_NONE:        return DIM_TEXT_BORDER::NONE;
    case types::DimensionTextBorderStyle::DTBS_RECTANGLE:   return DIM_TEXT_BORDER::RECTANGLE;
    case types::DimensionTextBorderStyle::DTBS_CIRCLE:      return DIM_TEXT_BORDER::CIRCLE;
    case types::DimensionTextBorderStyle::DTBS_ROUNDRECT:   return DIM_TEXT_BORDER::ROUNDRECT;
 
    default:
        wxCHECK_MSG( false,  DIM_TEXT_BORDER::NONE,
                     "Unhandled case in FromProtoEnum<types::DimensionTextBorderStyle>" );
    }
}
 
 
template<>
types::DimensionUnitFormat ToProtoEnum( DIM_UNITS_FORMAT aValue )
{
    switch( aValue )
    {
    case DIM_UNITS_FORMAT::NO_SUFFIX:       return types::DimensionUnitFormat::DUF_NO_SUFFIX;
    case DIM_UNITS_FORMAT::BARE_SUFFIX:     return types::DimensionUnitFormat::DUF_BARE_SUFFIX;
    case DIM_UNITS_FORMAT::PAREN_SUFFIX:    return types::DimensionUnitFormat::DUF_PAREN_SUFFIX;
 
    default:
        wxCHECK_MSG( false, types::DimensionUnitFormat::DUF_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DIM_UNITS_FORMAT>");
    }
}
 
 
template<>
DIM_UNITS_FORMAT FromProtoEnum( types::DimensionUnitFormat aValue )
{
    switch( aValue )
    {
    case types::DimensionUnitFormat::DUF_UNKNOWN:
    case types::DimensionUnitFormat::DUF_NO_SUFFIX:     return DIM_UNITS_FORMAT::NO_SUFFIX;
    case types::DimensionUnitFormat::DUF_BARE_SUFFIX:   return DIM_UNITS_FORMAT::BARE_SUFFIX;
    case types::DimensionUnitFormat::DUF_PAREN_SUFFIX:  return DIM_UNITS_FORMAT::PAREN_SUFFIX;
 
    default:
        wxCHECK_MSG( false,  DIM_UNITS_FORMAT::NO_SUFFIX,
                     "Unhandled case in FromProtoEnum<types::DimensionUnitFormat>" );
    }
}
 
 
template<>
types::DimensionArrowDirection ToProtoEnum( DIM_ARROW_DIRECTION aValue )
{
    switch( aValue )
    {
    case DIM_ARROW_DIRECTION::INWARD:   return types::DimensionArrowDirection::DAD_INWARD;
    case DIM_ARROW_DIRECTION::OUTWARD:  return types::DimensionArrowDirection::DAD_OUTWARD;
 
    default:
        wxCHECK_MSG( false, types::DimensionArrowDirection::DAD_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DIM_ARROW_DIRECTION>");
    }
}
 
 
template<>
DIM_ARROW_DIRECTION FromProtoEnum( types::DimensionArrowDirection aValue )
{
    switch( aValue )
    {
    case types::DimensionArrowDirection::DAD_INWARD:    return DIM_ARROW_DIRECTION::INWARD;
    case types::DimensionArrowDirection::DAD_UNKNOWN:
    case types::DimensionArrowDirection::DAD_OUTWARD:   return DIM_ARROW_DIRECTION::OUTWARD;
 
    default:
        wxCHECK_MSG( false,  DIM_ARROW_DIRECTION::OUTWARD,
                     "Unhandled case in FromProtoEnum<types::DimensionArrowDirection>" );
    }
}
 
 
template<>
types::DimensionPrecision ToProtoEnum( DIM_PRECISION aValue )
{
    switch( aValue )
    {
    case DIM_PRECISION::X:          return types::DimensionPrecision::DP_FIXED_0;
    case DIM_PRECISION::X_X:        return types::DimensionPrecision::DP_FIXED_1;
    case DIM_PRECISION::X_XX:       return types::DimensionPrecision::DP_FIXED_2;
    case DIM_PRECISION::X_XXX:      return types::DimensionPrecision::DP_FIXED_3;
    case DIM_PRECISION::X_XXXX:     return types::DimensionPrecision::DP_FIXED_4;
    case DIM_PRECISION::X_XXXXX:    return types::DimensionPrecision::DP_FIXED_5;
    case DIM_PRECISION::V_VV:       return types::DimensionPrecision::DP_SCALED_IN_2;
    case DIM_PRECISION::V_VVV:      return types::DimensionPrecision::DP_SCALED_IN_3;
    case DIM_PRECISION::V_VVVV:     return types::DimensionPrecision::DP_SCALED_IN_4;
    case DIM_PRECISION::V_VVVVV:    return types::DimensionPrecision::DP_SCALED_IN_5;
 
    default:
        wxCHECK_MSG( false, types::DimensionPrecision::DP_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DIM_PRECISION>");
    }
}
 
 
template<>
DIM_PRECISION FromProtoEnum( types::DimensionPrecision aValue )
{
    switch( aValue )
    {
    case types::DimensionPrecision::DP_FIXED_0:     return DIM_PRECISION::X;
    case types::DimensionPrecision::DP_FIXED_1:     return DIM_PRECISION::X_X;
    case types::DimensionPrecision::DP_FIXED_2:     return DIM_PRECISION::X_XX;
    case types::DimensionPrecision::DP_FIXED_3:     return DIM_PRECISION::X_XXX;
    case types::DimensionPrecision::DP_FIXED_4:     return DIM_PRECISION::X_XXXX;
    case types::DimensionPrecision::DP_FIXED_5:     return DIM_PRECISION::X_XXXXX;
    case types::DimensionPrecision::DP_UNKNOWN:
    case types::DimensionPrecision::DP_SCALED_IN_2: return DIM_PRECISION::V_VV;
    case types::DimensionPrecision::DP_SCALED_IN_3: return DIM_PRECISION::V_VVV;
    case types::DimensionPrecision::DP_SCALED_IN_4: return DIM_PRECISION::V_VVVV;
    case types::DimensionPrecision::DP_SCALED_IN_5: return DIM_PRECISION::V_VVVVV;
 
    default:
        wxCHECK_MSG( false,  DIM_PRECISION::V_VV,
                     "Unhandled case in FromProtoEnum<types::DimensionPrecision>" );
    }
}
 
 
template<>
types::DimensionTextPosition ToProtoEnum( DIM_TEXT_POSITION aValue )
{
    switch( aValue )
    {
    case DIM_TEXT_POSITION::OUTSIDE:    return types::DimensionTextPosition::DTP_OUTSIDE;
    case DIM_TEXT_POSITION::INLINE:     return types::DimensionTextPosition::DTP_INLINE;
    case DIM_TEXT_POSITION::MANUAL:     return types::DimensionTextPosition::DTP_MANUAL;
 
    default:
        wxCHECK_MSG( false, types::DimensionTextPosition::DTP_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DIM_TEXT_POSITION>");
    }
}
 
 
template<>
DIM_TEXT_POSITION FromProtoEnum( types::DimensionTextPosition aValue )
{
    switch( aValue )
    {
    case types::DimensionTextPosition::DTP_UNKNOWN:
    case types::DimensionTextPosition::DTP_OUTSIDE: return DIM_TEXT_POSITION::OUTSIDE;
    case types::DimensionTextPosition::DTP_INLINE:  return DIM_TEXT_POSITION::INLINE;
    case types::DimensionTextPosition::DTP_MANUAL:  return DIM_TEXT_POSITION::MANUAL;
 
    default:
        wxCHECK_MSG( false,  DIM_TEXT_POSITION::OUTSIDE,
                     "Unhandled case in FromProtoEnum<types::DimensionTextPosition>" );
    }
}
 
 
template<>
types::DimensionUnit ToProtoEnum( DIM_UNITS_MODE aValue )
{
    switch( aValue )
    {
    case DIM_UNITS_MODE::INCH:      return types::DimensionUnit::DU_INCHES;
    case DIM_UNITS_MODE::MILS:      return types::DimensionUnit::DU_MILS;
    case DIM_UNITS_MODE::MM:        return types::DimensionUnit::DU_MILLIMETERS;
    case DIM_UNITS_MODE::AUTOMATIC: return types::DimensionUnit::DU_AUTOMATIC;
 
    default:
        wxCHECK_MSG( false, types::DimensionUnit::DU_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DIM_UNITS_MODE>");
    }
}
 
 
template<>
DIM_UNITS_MODE FromProtoEnum( types::DimensionUnit aValue )
{
    switch( aValue )
    {
    case types::DimensionUnit::DU_INCHES:       return DIM_UNITS_MODE::INCH;
    case types::DimensionUnit::DU_MILS:         return DIM_UNITS_MODE::MILS;
    case types::DimensionUnit::DU_MILLIMETERS:  return DIM_UNITS_MODE::MM;
    case types::DimensionUnit::DU_UNKNOWN:
    case types::DimensionUnit::DU_AUTOMATIC:    return DIM_UNITS_MODE::AUTOMATIC;
 
    default:
        wxCHECK_MSG( false,  DIM_UNITS_MODE::AUTOMATIC,
                     "Unhandled case in FromProtoEnum<types::DimensionUnit>" );
    }
}
 
 
template<>
commands::InactiveLayerDisplayMode ToProtoEnum( HIGH_CONTRAST_MODE aValue )
{
    switch( aValue )
    {
    case HIGH_CONTRAST_MODE::NORMAL:    return commands::InactiveLayerDisplayMode::ILDM_NORMAL;
    case HIGH_CONTRAST_MODE::DIMMED:    return commands::InactiveLayerDisplayMode::ILDM_DIMMED;
    case HIGH_CONTRAST_MODE::HIDDEN:    return commands::InactiveLayerDisplayMode::ILDM_HIDDEN;
 
    default:
        wxCHECK_MSG( false, commands::InactiveLayerDisplayMode::ILDM_NORMAL,
                     "Unhandled case in ToProtoEnum<HIGH_CONTRAST_MODE>");
    }
}
 
 
template<>
HIGH_CONTRAST_MODE FromProtoEnum( commands::InactiveLayerDisplayMode aValue )
{
    switch( aValue )
    {
    case commands::InactiveLayerDisplayMode::ILDM_DIMMED:   return HIGH_CONTRAST_MODE::DIMMED;
    case commands::InactiveLayerDisplayMode::ILDM_HIDDEN:   return HIGH_CONTRAST_MODE::HIDDEN;
    case commands::InactiveLayerDisplayMode::ILDM_UNKNOWN:
    case commands::InactiveLayerDisplayMode::ILDM_NORMAL:   return HIGH_CONTRAST_MODE::NORMAL;
 
    default:
        wxCHECK_MSG( false, HIGH_CONTRAST_MODE::NORMAL,
                     "Unhandled case in FromProtoEnum<commands::InactiveLayerDisplayMode>" );
    }
}
 
 
template<>
commands::NetColorDisplayMode ToProtoEnum( NET_COLOR_MODE aValue )
{
    switch( aValue )
    {
    case NET_COLOR_MODE::ALL:       return commands::NetColorDisplayMode::NCDM_ALL;
    case NET_COLOR_MODE::RATSNEST:  return commands::NetColorDisplayMode::NCDM_RATSNEST;
    case NET_COLOR_MODE::OFF:       return commands::NetColorDisplayMode::NCDM_OFF;
 
    default:
        wxCHECK_MSG( false, commands::NetColorDisplayMode::NCDM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<NET_COLOR_MODE>");
    }
}
 
 
template<>
NET_COLOR_MODE FromProtoEnum( commands::NetColorDisplayMode aValue )
{
    switch( aValue )
    {
    case commands::NetColorDisplayMode::NCDM_ALL:       return NET_COLOR_MODE::ALL;
    case commands::NetColorDisplayMode::NCDM_OFF:       return NET_COLOR_MODE::OFF;
    case commands::NetColorDisplayMode::NCDM_UNKNOWN:
    case commands::NetColorDisplayMode::NCDM_RATSNEST:  return NET_COLOR_MODE::RATSNEST;
 
    default:
        wxCHECK_MSG( false, NET_COLOR_MODE::RATSNEST,
                     "Unhandled case in FromProtoEnum<commands::NetColorDisplayMode>" );
    }
}
 
 
template<>
commands::RatsnestDisplayMode ToProtoEnum( RATSNEST_MODE aValue )
{
    switch( aValue )
    {
    case RATSNEST_MODE::ALL:        return commands::RatsnestDisplayMode::RDM_ALL_LAYERS;
    case RATSNEST_MODE::VISIBLE:    return commands::RatsnestDisplayMode::RDM_VISIBLE_LAYERS;
 
    default:
        wxCHECK_MSG( false, commands::RatsnestDisplayMode::RDM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<RATSNEST_MODE>");
    }
}
 
 
template<>
RATSNEST_MODE FromProtoEnum( commands::RatsnestDisplayMode aValue )
{
    switch( aValue )
    {
    case commands::RatsnestDisplayMode::RDM_VISIBLE_LAYERS: return RATSNEST_MODE::VISIBLE;
    case commands::RatsnestDisplayMode::RDM_UNKNOWN:
    case commands::RatsnestDisplayMode::RDM_ALL_LAYERS:     return RATSNEST_MODE::ALL;
 
    default:
        wxCHECK_MSG( false, RATSNEST_MODE::ALL,
                     "Unhandled case in FromProtoEnum<commands::RatsnestDisplayMode>" );
    }
}
 
 
template<>
BoardStackupLayerType ToProtoEnum( BOARD_STACKUP_ITEM_TYPE aValue )
{
    switch( aValue )
    {
    case BS_ITEM_TYPE_UNDEFINED:    return BoardStackupLayerType::BSLT_UNDEFINED;
    case BS_ITEM_TYPE_COPPER:       return BoardStackupLayerType::BSLT_COPPER;
    case BS_ITEM_TYPE_DIELECTRIC:   return BoardStackupLayerType::BSLT_DIELECTRIC;
    case BS_ITEM_TYPE_SOLDERPASTE:  return BoardStackupLayerType::BSLT_SOLDERPASTE;
    case BS_ITEM_TYPE_SOLDERMASK:   return BoardStackupLayerType::BSLT_SOLDERMASK;
    case BS_ITEM_TYPE_SILKSCREEN:   return BoardStackupLayerType::BSLT_SILKSCREEN;
 
    default:
        wxCHECK_MSG( false, BoardStackupLayerType::BSLT_UNKNOWN,
                     "Unhandled case in ToProtoEnum<BOARD_STACKUP_ITEM_TYPE>");
    }
}
 
 
template<>
BOARD_STACKUP_ITEM_TYPE FromProtoEnum( BoardStackupLayerType aValue )
{
    switch( aValue )
    {
    case BoardStackupLayerType::BSLT_UNDEFINED:    return BS_ITEM_TYPE_UNDEFINED;
    case BoardStackupLayerType::BSLT_COPPER:       return BS_ITEM_TYPE_COPPER;
    case BoardStackupLayerType::BSLT_DIELECTRIC:   return BS_ITEM_TYPE_DIELECTRIC;
    case BoardStackupLayerType::BSLT_SOLDERPASTE:  return BS_ITEM_TYPE_SOLDERPASTE;
    case BoardStackupLayerType::BSLT_SOLDERMASK:   return BS_ITEM_TYPE_SOLDERMASK;
    case BoardStackupLayerType::BSLT_SILKSCREEN:   return BS_ITEM_TYPE_SILKSCREEN;
 
    default:
        wxCHECK_MSG( false, BS_ITEM_TYPE_UNDEFINED,
                     "Unhandled case in FromProtoEnum<BoardStackupLayerType>" );
    }
}
 
 
template<>
DielectricModel ToProtoEnum( DIELECTRIC_MODEL aValue )
{
    switch( aValue )
    {
    case DIELECTRIC_MODEL::CONSTANT:          return DielectricModel::DM_CONSTANT;
    case DIELECTRIC_MODEL::DJORDJEVIC_SARKAR: return DielectricModel::DM_DJORDJEVIC_SARKAR;
 
    default:
        wxCHECK_MSG( false, DielectricModel::DM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DIELECTRIC_MODEL>" );
    }
}
 
 
template<>
DIELECTRIC_MODEL FromProtoEnum( DielectricModel aValue )
{
    switch( aValue )
    {
    case DielectricModel::DM_CONSTANT:          return DIELECTRIC_MODEL::CONSTANT;
    case DielectricModel::DM_DJORDJEVIC_SARKAR: return DIELECTRIC_MODEL::DJORDJEVIC_SARKAR;
 
    default:
        wxCHECK_MSG( false, DIELECTRIC_MODEL::CONSTANT,
                     "Unhandled case in FromProtoEnum<DielectricModel>" );
    }
}
 
 
template<>
BoardEdgeConnectorType ToProtoEnum( BS_EDGE_CONNECTOR_CONSTRAINTS aValue )
{
    switch( aValue )
    {
    case BS_EDGE_CONNECTOR_NONE:     return BoardEdgeConnectorType::BECT_NONE;
    case BS_EDGE_CONNECTOR_IN_USE:   return BoardEdgeConnectorType::BECT_PLAIN;
    case BS_EDGE_CONNECTOR_BEVELLED: return BoardEdgeConnectorType::BECT_BEVELED;
 
    default:
        wxCHECK_MSG( false, BoardEdgeConnectorType::BECT_UNKNOWN,
                     "Unhandled case in ToProtoEnum<BS_EDGE_CONNECTOR_CONSTRAINTS>" );
    }
}
 
 
template<>
BS_EDGE_CONNECTOR_CONSTRAINTS FromProtoEnum( BoardEdgeConnectorType aValue )
{
    switch( aValue )
    {
    case BoardEdgeConnectorType::BECT_NONE:    return BS_EDGE_CONNECTOR_NONE;
    case BoardEdgeConnectorType::BECT_PLAIN:   return BS_EDGE_CONNECTOR_IN_USE;
    case BoardEdgeConnectorType::BECT_BEVELED: return BS_EDGE_CONNECTOR_BEVELLED;
 
    default:
        wxCHECK_MSG( false, BS_EDGE_CONNECTOR_NONE,
                     "Unhandled case in FromProtoEnum<BoardEdgeConnectorType>" );
    }
}
 
 
template<>
DrcSeverity ToProtoEnum( SEVERITY aValue )
{
    switch( aValue )
    {
    case RPT_SEVERITY_WARNING:   return DrcSeverity::DRS_WARNING;
    case RPT_SEVERITY_ERROR:     return DrcSeverity::DRS_ERROR;
    case RPT_SEVERITY_EXCLUSION: return DrcSeverity::DRS_EXCLUSION;
    case RPT_SEVERITY_IGNORE:    return DrcSeverity::DRS_IGNORE;
    case RPT_SEVERITY_INFO:      return DrcSeverity::DRS_INFO;
    case RPT_SEVERITY_ACTION:    return DrcSeverity::DRS_ACTION;
    case RPT_SEVERITY_DEBUG:     return DrcSeverity::DRS_DEBUG;
    case RPT_SEVERITY_UNDEFINED: return DrcSeverity::DRS_UNDEFINED;
    default:
        wxCHECK_MSG( false, DrcSeverity::DRS_UNDEFINED,
                     "Unhandled case in ToProtoEnum<SEVERITY>");
    }
}
 
 
template<>
SEVERITY FromProtoEnum( DrcSeverity aValue )
{
    switch( aValue )
    {
    case DrcSeverity::DRS_WARNING:   return RPT_SEVERITY_WARNING;
    case DrcSeverity::DRS_ERROR:     return RPT_SEVERITY_ERROR;
    case DrcSeverity::DRS_EXCLUSION: return RPT_SEVERITY_EXCLUSION;
    case DrcSeverity::DRS_IGNORE:    return RPT_SEVERITY_IGNORE;
    case DrcSeverity::DRS_INFO:      return RPT_SEVERITY_INFO;
    case DrcSeverity::DRS_ACTION:    return RPT_SEVERITY_ACTION;
    case DrcSeverity::DRS_DEBUG:     return RPT_SEVERITY_DEBUG;
    case DrcSeverity::DRS_UNKNOWN:
    default:
        return RPT_SEVERITY_UNDEFINED;
    }
}
 
 
template<>
PlotDrillMarks ToProtoEnum( DRILL_MARKS aValue )
{
    switch( aValue )
    {
    case DRILL_MARKS::NO_DRILL_SHAPE:    return PlotDrillMarks::PDM_NONE;
    case DRILL_MARKS::SMALL_DRILL_SHAPE: return PlotDrillMarks::PDM_SMALL;
    case DRILL_MARKS::FULL_DRILL_SHAPE:  return PlotDrillMarks::PDM_FULL;
    default:
        wxCHECK_MSG( false, PlotDrillMarks::PDM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<DRILL_MARKS>" );
    }
}
 
 
template<>
DRILL_MARKS FromProtoEnum( PlotDrillMarks aValue )
{
    switch( aValue )
    {
    case PlotDrillMarks::PDM_NONE:    return DRILL_MARKS::NO_DRILL_SHAPE;
    case PlotDrillMarks::PDM_SMALL:   return DRILL_MARKS::SMALL_DRILL_SHAPE;
    case PlotDrillMarks::PDM_FULL:    return DRILL_MARKS::FULL_DRILL_SHAPE;
    case PlotDrillMarks::PDM_UNKNOWN:
    default:
        return DRILL_MARKS::NO_DRILL_SHAPE;
    }
}
 
 
template<>
Board3DFormat ToProtoEnum( JOB_EXPORT_PCB_3D::FORMAT aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_3D::FORMAT::STEP:    return Board3DFormat::B3D_STEP;
    case JOB_EXPORT_PCB_3D::FORMAT::STEPZ:   return Board3DFormat::B3D_STEPZ;
    case JOB_EXPORT_PCB_3D::FORMAT::BREP:    return Board3DFormat::B3D_BREP;
    case JOB_EXPORT_PCB_3D::FORMAT::XAO:     return Board3DFormat::B3D_XAO;
    case JOB_EXPORT_PCB_3D::FORMAT::GLB:     return Board3DFormat::B3D_GLB;
    case JOB_EXPORT_PCB_3D::FORMAT::VRML:    return Board3DFormat::B3D_VRML;
    case JOB_EXPORT_PCB_3D::FORMAT::PLY:     return Board3DFormat::B3D_PLY;
    case JOB_EXPORT_PCB_3D::FORMAT::STL:     return Board3DFormat::B3D_STL;
    case JOB_EXPORT_PCB_3D::FORMAT::U3D:     return Board3DFormat::B3D_U3D;
    case JOB_EXPORT_PCB_3D::FORMAT::PDF:     return Board3DFormat::B3D_PDF;
    default:
        wxCHECK_MSG( false, Board3DFormat::B3D_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_3D::FORMAT>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_3D::FORMAT FromProtoEnum( Board3DFormat aValue )
{
    switch( aValue )
    {
    case Board3DFormat::B3D_STEP:  return JOB_EXPORT_PCB_3D::FORMAT::STEP;
    case Board3DFormat::B3D_STEPZ: return JOB_EXPORT_PCB_3D::FORMAT::STEPZ;
    case Board3DFormat::B3D_BREP:  return JOB_EXPORT_PCB_3D::FORMAT::BREP;
    case Board3DFormat::B3D_XAO:   return JOB_EXPORT_PCB_3D::FORMAT::XAO;
    case Board3DFormat::B3D_GLB:   return JOB_EXPORT_PCB_3D::FORMAT::GLB;
    case Board3DFormat::B3D_VRML:  return JOB_EXPORT_PCB_3D::FORMAT::VRML;
    case Board3DFormat::B3D_PLY:   return JOB_EXPORT_PCB_3D::FORMAT::PLY;
    case Board3DFormat::B3D_STL:   return JOB_EXPORT_PCB_3D::FORMAT::STL;
    case Board3DFormat::B3D_U3D:   return JOB_EXPORT_PCB_3D::FORMAT::U3D;
    case Board3DFormat::B3D_PDF:   return JOB_EXPORT_PCB_3D::FORMAT::PDF;
    case Board3DFormat::B3D_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_3D::FORMAT::UNKNOWN;
    }
}
 
 
template<>
kiapi::common::types::Units ToProtoEnum( JOB_EXPORT_PCB_3D::VRML_UNITS aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_3D::VRML_UNITS::INCH:   return kiapi::common::types::Units::U_INCH;
    case JOB_EXPORT_PCB_3D::VRML_UNITS::MM:     return kiapi::common::types::Units::U_MM;
    case JOB_EXPORT_PCB_3D::VRML_UNITS::METERS: return kiapi::common::types::Units::U_METERS;
    case JOB_EXPORT_PCB_3D::VRML_UNITS::TENTHS: return kiapi::common::types::Units::U_TENTHS;
    default:
        wxCHECK_MSG( false, kiapi::common::types::Units::U_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_3D::VRML_UNITS>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_3D::VRML_UNITS FromProtoEnum( kiapi::common::types::Units aValue )
{
    switch( aValue )
    {
    case kiapi::common::types::Units::U_INCH:   return JOB_EXPORT_PCB_3D::VRML_UNITS::INCH;
    case kiapi::common::types::Units::U_MM:     return JOB_EXPORT_PCB_3D::VRML_UNITS::MM;
    case kiapi::common::types::Units::U_METERS: return JOB_EXPORT_PCB_3D::VRML_UNITS::METERS;
    case kiapi::common::types::Units::U_TENTHS: return JOB_EXPORT_PCB_3D::VRML_UNITS::TENTHS;
    case kiapi::common::types::Units::U_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_3D::VRML_UNITS::METERS;
    }
}
 
 
template<>
RenderFormat ToProtoEnum( JOB_PCB_RENDER::FORMAT aValue )
{
    switch( aValue )
    {
    case JOB_PCB_RENDER::FORMAT::PNG:  return RenderFormat::RF_PNG;
    case JOB_PCB_RENDER::FORMAT::JPEG: return RenderFormat::RF_JPEG;
    default:
        wxCHECK_MSG( false, RenderFormat::RF_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_PCB_RENDER::FORMAT>" );
    }
}
 
 
template<>
JOB_PCB_RENDER::FORMAT FromProtoEnum( RenderFormat aValue )
{
    switch( aValue )
    {
    case RenderFormat::RF_PNG: return JOB_PCB_RENDER::FORMAT::PNG;
    case RenderFormat::RF_JPEG:return JOB_PCB_RENDER::FORMAT::JPEG;
    case RenderFormat::RF_UNKNOWN:
    default:
        return JOB_PCB_RENDER::FORMAT::PNG;
    }
}
 
 
template<>
RenderQuality ToProtoEnum( JOB_PCB_RENDER::QUALITY aValue )
{
    switch( aValue )
    {
    case JOB_PCB_RENDER::QUALITY::BASIC:        return RenderQuality::RQ_BASIC;
    case JOB_PCB_RENDER::QUALITY::HIGH:         return RenderQuality::RQ_HIGH;
    case JOB_PCB_RENDER::QUALITY::USER:         return RenderQuality::RQ_USER;
    case JOB_PCB_RENDER::QUALITY::JOB_SETTINGS: return RenderQuality::RQ_JOB_SETTINGS;
    default:
        wxCHECK_MSG( false, RenderQuality::RQ_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_PCB_RENDER::QUALITY>" );
    }
}
 
 
template<>
JOB_PCB_RENDER::QUALITY FromProtoEnum( RenderQuality aValue )
{
    switch( aValue )
    {
    case RenderQuality::RQ_BASIC:        return JOB_PCB_RENDER::QUALITY::BASIC;
    case RenderQuality::RQ_HIGH:         return JOB_PCB_RENDER::QUALITY::HIGH;
    case RenderQuality::RQ_USER:         return JOB_PCB_RENDER::QUALITY::USER;
    case RenderQuality::RQ_JOB_SETTINGS: return JOB_PCB_RENDER::QUALITY::JOB_SETTINGS;
    case RenderQuality::RQ_UNKNOWN:
    default:
        return JOB_PCB_RENDER::QUALITY::BASIC;
    }
}
 
 
template<>
RenderBackgroundStyle ToProtoEnum( JOB_PCB_RENDER::BG_STYLE aValue )
{
    switch( aValue )
    {
    case JOB_PCB_RENDER::BG_STYLE::DEFAULT:     return RenderBackgroundStyle::RBS_DEFAULT;
    case JOB_PCB_RENDER::BG_STYLE::TRANSPARENT: return RenderBackgroundStyle::RBS_TRANSPARENT;
    case JOB_PCB_RENDER::BG_STYLE::OPAQUE:      return RenderBackgroundStyle::RBS_OPAQUE;
    default:
        wxCHECK_MSG( false, RenderBackgroundStyle::RBS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_PCB_RENDER::BG_STYLE>" );
    }
}
 
 
template<>
JOB_PCB_RENDER::BG_STYLE FromProtoEnum( RenderBackgroundStyle aValue )
{
    switch( aValue )
    {
    case RenderBackgroundStyle::RBS_DEFAULT:     return JOB_PCB_RENDER::BG_STYLE::DEFAULT;
    case RenderBackgroundStyle::RBS_TRANSPARENT: return JOB_PCB_RENDER::BG_STYLE::TRANSPARENT;
    case RenderBackgroundStyle::RBS_OPAQUE:      return JOB_PCB_RENDER::BG_STYLE::OPAQUE;
    case RenderBackgroundStyle::RBS_UNKNOWN:
    default:
        return JOB_PCB_RENDER::BG_STYLE::DEFAULT;
    }
}
 
 
template<>
RenderSide ToProtoEnum( JOB_PCB_RENDER::SIDE aValue )
{
    switch( aValue )
    {
    case JOB_PCB_RENDER::SIDE::TOP:    return RenderSide::RS_TOP;
    case JOB_PCB_RENDER::SIDE::BOTTOM: return RenderSide::RS_BOTTOM;
    case JOB_PCB_RENDER::SIDE::LEFT:   return RenderSide::RS_LEFT;
    case JOB_PCB_RENDER::SIDE::RIGHT:  return RenderSide::RS_RIGHT;
    case JOB_PCB_RENDER::SIDE::FRONT:  return RenderSide::RS_FRONT;
    case JOB_PCB_RENDER::SIDE::BACK:   return RenderSide::RS_BACK;
    default:
        wxCHECK_MSG( false, RenderSide::RS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_PCB_RENDER::SIDE>" );
    }
}
 
 
template<>
JOB_PCB_RENDER::SIDE FromProtoEnum( RenderSide aValue )
{
    switch( aValue )
    {
    case RenderSide::RS_TOP:    return JOB_PCB_RENDER::SIDE::TOP;
    case RenderSide::RS_BOTTOM: return JOB_PCB_RENDER::SIDE::BOTTOM;
    case RenderSide::RS_LEFT:   return JOB_PCB_RENDER::SIDE::LEFT;
    case RenderSide::RS_RIGHT:  return JOB_PCB_RENDER::SIDE::RIGHT;
    case RenderSide::RS_FRONT:  return JOB_PCB_RENDER::SIDE::FRONT;
    case RenderSide::RS_BACK:   return JOB_PCB_RENDER::SIDE::BACK;
    case RenderSide::RS_UNKNOWN:
    default:
        return JOB_PCB_RENDER::SIDE::TOP;
    }
}
 
 
template<>
BoardJobPaginationMode ToProtoEnum( JOB_EXPORT_PCB_SVG::GEN_MODE aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_SVG::GEN_MODE::SINGLE: return BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE;
    case JOB_EXPORT_PCB_SVG::GEN_MODE::MULTI:  return BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE;
    default:
        wxCHECK_MSG( false, BoardJobPaginationMode::BJPM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_SVG::GEN_MODE>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_SVG::GEN_MODE FromProtoEnum( BoardJobPaginationMode aValue )
{
    switch( aValue )
    {
    case BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE:
        return JOB_EXPORT_PCB_SVG::GEN_MODE::SINGLE;
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE:
        return JOB_EXPORT_PCB_SVG::GEN_MODE::MULTI;
    case BoardJobPaginationMode::BJPM_UNKNOWN:
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_PAGE:
    default:
        return JOB_EXPORT_PCB_SVG::GEN_MODE::SINGLE;
    }
}
 
 
template<>
BoardJobPaginationMode ToProtoEnum( JOB_EXPORT_PCB_DXF::GEN_MODE aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_DXF::GEN_MODE::SINGLE: return BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE;
    case JOB_EXPORT_PCB_DXF::GEN_MODE::MULTI:  return BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE;
    default:
        wxCHECK_MSG( false, BoardJobPaginationMode::BJPM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_DXF::GEN_MODE>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_DXF::GEN_MODE FromProtoEnum( BoardJobPaginationMode aValue )
{
    switch( aValue )
    {
    case BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE:
        return JOB_EXPORT_PCB_DXF::GEN_MODE::SINGLE;
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE:
        return JOB_EXPORT_PCB_DXF::GEN_MODE::MULTI;
    case BoardJobPaginationMode::BJPM_UNKNOWN:
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_PAGE:
    default:
        return JOB_EXPORT_PCB_DXF::GEN_MODE::SINGLE;
    }
}
 
 
template<>
BoardJobPaginationMode ToProtoEnum( JOB_EXPORT_PCB_PDF::GEN_MODE aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_PDF::GEN_MODE::ALL_LAYERS_ONE_FILE:
        return BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE;
    case JOB_EXPORT_PCB_PDF::GEN_MODE::ONE_PAGE_PER_LAYER_ONE_FILE:
        return BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_PAGE;
    case JOB_EXPORT_PCB_PDF::GEN_MODE::ALL_LAYERS_SEPARATE_FILE:
        return BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE;
    default:
        wxCHECK_MSG( false, BoardJobPaginationMode::BJPM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_PDF::GEN_MODE>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_PDF::GEN_MODE FromProtoEnum( BoardJobPaginationMode aValue )
{
    switch( aValue )
    {
    case BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE:
        return JOB_EXPORT_PCB_PDF::GEN_MODE::ALL_LAYERS_ONE_FILE;
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_PAGE:
        return JOB_EXPORT_PCB_PDF::GEN_MODE::ONE_PAGE_PER_LAYER_ONE_FILE;
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE:
        return JOB_EXPORT_PCB_PDF::GEN_MODE::ALL_LAYERS_SEPARATE_FILE;
    case BoardJobPaginationMode::BJPM_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_PDF::GEN_MODE::ALL_LAYERS_ONE_FILE;
    }
}
 
 
template<>
BoardJobPaginationMode ToProtoEnum( JOB_EXPORT_PCB_PS::GEN_MODE aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_PS::GEN_MODE::SINGLE: return BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE;
    case JOB_EXPORT_PCB_PS::GEN_MODE::MULTI:  return BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE;
    default:
        wxCHECK_MSG( false, BoardJobPaginationMode::BJPM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_PS::GEN_MODE>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_PS::GEN_MODE FromProtoEnum( BoardJobPaginationMode aValue )
{
    switch( aValue )
    {
    case BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE:
        return JOB_EXPORT_PCB_PS::GEN_MODE::SINGLE;
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE:
        return JOB_EXPORT_PCB_PS::GEN_MODE::MULTI;
    case BoardJobPaginationMode::BJPM_UNKNOWN:
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_PAGE:
    default:
        return JOB_EXPORT_PCB_PS::GEN_MODE::SINGLE;
    }
}
 
 
template<>
BoardJobPaginationMode ToProtoEnum( JOB_EXPORT_PCB_PNG::GEN_MODE aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_PNG::GEN_MODE::SINGLE: return BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE;
    case JOB_EXPORT_PCB_PNG::GEN_MODE::MULTI:  return BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE;
    default:
        wxCHECK_MSG( false, BoardJobPaginationMode::BJPM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_PNG::GEN_MODE>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_PNG::GEN_MODE FromProtoEnum( BoardJobPaginationMode aValue )
{
    switch( aValue )
    {
    case BoardJobPaginationMode::BJPM_ALL_LAYERS_ONE_PAGE:
        return JOB_EXPORT_PCB_PNG::GEN_MODE::SINGLE;
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_FILE:
        return JOB_EXPORT_PCB_PNG::GEN_MODE::MULTI;
    case BoardJobPaginationMode::BJPM_UNKNOWN:
    case BoardJobPaginationMode::BJPM_EACH_LAYER_OWN_PAGE:
    default:
        return JOB_EXPORT_PCB_PNG::GEN_MODE::MULTI;
    }
}
 
 
template<>
DrillFormat ToProtoEnum( JOB_EXPORT_PCB_DRILL::DRILL_FORMAT aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::EXCELLON: return DrillFormat::DF_EXCELLON;
    case JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::GERBER:   return DrillFormat::DF_GERBER;
    default:
        wxCHECK_MSG( false, DrillFormat::DF_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_DRILL::DRILL_FORMAT>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_DRILL::DRILL_FORMAT FromProtoEnum( DrillFormat aValue )
{
    switch( aValue )
    {
    case DrillFormat::DF_EXCELLON: return JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::EXCELLON;
    case DrillFormat::DF_GERBER:   return JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::GERBER;
    case DrillFormat::DF_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::EXCELLON;
    }
}
 
 
template<>
DrillOrigin ToProtoEnum( JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN::ABS:  return DrillOrigin::DO_ABSOLUTE;
    case JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN::PLOT: return DrillOrigin::DO_PLOT;
    default:
        wxCHECK_MSG( false, DrillOrigin::DO_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN FromProtoEnum( DrillOrigin aValue )
{
    switch( aValue )
    {
    case DrillOrigin::DO_ABSOLUTE: return JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN::ABS;
    case DrillOrigin::DO_PLOT:     return JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN::PLOT;
    case DrillOrigin::DO_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN::ABS;
    }
}
 
 
template<>
DrillZerosFormat ToProtoEnum( JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::DECIMAL:
        return DrillZerosFormat::DZF_DECIMAL;
    case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_LEADING:
        return DrillZerosFormat::DZF_SUPPRESS_LEADING;
    case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_TRAILING:
        return DrillZerosFormat::DZF_SUPPRESS_TRAILING;
    case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::KEEP_ZEROS:
        return DrillZerosFormat::DZF_KEEP_ZEROS;
    default:
        wxCHECK_MSG( false, DrillZerosFormat::DZF_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT FromProtoEnum( DrillZerosFormat aValue )
{
    switch( aValue )
    {
    case DrillZerosFormat::DZF_DECIMAL:
        return JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::DECIMAL;
    case DrillZerosFormat::DZF_SUPPRESS_LEADING:
        return JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_LEADING;
    case DrillZerosFormat::DZF_SUPPRESS_TRAILING:
        return JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_TRAILING;
    case DrillZerosFormat::DZF_KEEP_ZEROS:
        return JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::KEEP_ZEROS;
    case DrillZerosFormat::DZF_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::DECIMAL;
    }
}
 
 
template<>
DrillMapFormat ToProtoEnum( JOB_EXPORT_PCB_DRILL::MAP_FORMAT aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::POSTSCRIPT:
        return DrillMapFormat::DMF_POSTSCRIPT;
    case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::GERBER_X2:
        return DrillMapFormat::DMF_GERBER_X2;
    case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::DXF:
        return DrillMapFormat::DMF_DXF;
    case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::SVG:
        return DrillMapFormat::DMF_SVG;
    case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::PDF:
        return DrillMapFormat::DMF_PDF;
    default:
        wxCHECK_MSG( false, DrillMapFormat::DMF_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_DRILL::MAP_FORMAT>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_DRILL::MAP_FORMAT FromProtoEnum( DrillMapFormat aValue )
{
    switch( aValue )
    {
    case DrillMapFormat::DMF_POSTSCRIPT:
        return JOB_EXPORT_PCB_DRILL::MAP_FORMAT::POSTSCRIPT;
    case DrillMapFormat::DMF_GERBER_X2:
        return JOB_EXPORT_PCB_DRILL::MAP_FORMAT::GERBER_X2;
    case DrillMapFormat::DMF_DXF:
        return JOB_EXPORT_PCB_DRILL::MAP_FORMAT::DXF;
    case DrillMapFormat::DMF_SVG:
        return JOB_EXPORT_PCB_DRILL::MAP_FORMAT::SVG;
    case DrillMapFormat::DMF_PDF:
        return JOB_EXPORT_PCB_DRILL::MAP_FORMAT::PDF;
    case DrillMapFormat::DMF_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_DRILL::MAP_FORMAT::PDF;
    }
}
 
 
template<>
kiapi::common::types::Units ToProtoEnum( JOB_EXPORT_PCB_DRILL::DRILL_UNITS aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_DRILL::DRILL_UNITS::INCH: return kiapi::common::types::Units::U_INCH;
    case JOB_EXPORT_PCB_DRILL::DRILL_UNITS::MM:   return kiapi::common::types::Units::U_MM;
    default:
        wxCHECK_MSG( false, kiapi::common::types::Units::U_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_DRILL::DRILL_UNITS>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_DRILL::DRILL_UNITS FromProtoEnum( kiapi::common::types::Units aValue )
{
    switch( aValue )
    {
    case kiapi::common::types::Units::U_INCH: return JOB_EXPORT_PCB_DRILL::DRILL_UNITS::INCH;
    case kiapi::common::types::Units::U_MM:   return JOB_EXPORT_PCB_DRILL::DRILL_UNITS::MM;
    case kiapi::common::types::Units::U_UNKNOWN:
    case kiapi::common::types::Units::U_METERS:
    case kiapi::common::types::Units::U_TENTHS:
    default:
        return JOB_EXPORT_PCB_DRILL::DRILL_UNITS::INCH;
    }
}
 
 
template<>
PositionSide ToProtoEnum( JOB_EXPORT_PCB_POS::SIDE aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_POS::SIDE::FRONT: return PositionSide::PS_FRONT;
    case JOB_EXPORT_PCB_POS::SIDE::BACK:  return PositionSide::PS_BACK;
    case JOB_EXPORT_PCB_POS::SIDE::BOTH:  return PositionSide::PS_BOTH;
    default:
        wxCHECK_MSG( false, PositionSide::PS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_POS::SIDE>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_POS::SIDE FromProtoEnum( PositionSide aValue )
{
    switch( aValue )
    {
    case PositionSide::PS_FRONT: return JOB_EXPORT_PCB_POS::SIDE::FRONT;
    case PositionSide::PS_BACK:  return JOB_EXPORT_PCB_POS::SIDE::BACK;
    case PositionSide::PS_BOTH:  return JOB_EXPORT_PCB_POS::SIDE::BOTH;
    case PositionSide::PS_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_POS::SIDE::BOTH;
    }
}
 
 
template<>
PositionFormat ToProtoEnum( JOB_EXPORT_PCB_POS::FORMAT aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_POS::FORMAT::ASCII:  return PositionFormat::PF_ASCII;
    case JOB_EXPORT_PCB_POS::FORMAT::CSV:    return PositionFormat::PF_CSV;
    case JOB_EXPORT_PCB_POS::FORMAT::GERBER: return PositionFormat::PF_GERBER;
    default:
        wxCHECK_MSG( false, PositionFormat::PF_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_POS::FORMAT>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_POS::FORMAT FromProtoEnum( PositionFormat aValue )
{
    switch( aValue )
    {
    case PositionFormat::PF_ASCII:  return JOB_EXPORT_PCB_POS::FORMAT::ASCII;
    case PositionFormat::PF_CSV:    return JOB_EXPORT_PCB_POS::FORMAT::CSV;
    case PositionFormat::PF_GERBER: return JOB_EXPORT_PCB_POS::FORMAT::GERBER;
    case PositionFormat::PF_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_POS::FORMAT::ASCII;
    }
}
 
 
template<>
Ipc2581Version ToProtoEnum( JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION::B: return Ipc2581Version::IPC2581V_B;
    case JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION::C: return Ipc2581Version::IPC2581V_C;
    default:
        wxCHECK_MSG( false, Ipc2581Version::IPC2581V_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION FromProtoEnum( Ipc2581Version aValue )
{
    switch( aValue )
    {
    case Ipc2581Version::IPC2581V_B: return JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION::B;
    case Ipc2581Version::IPC2581V_C: return JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION::C;
    case Ipc2581Version::IPC2581V_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION::C;
    }
}
 
 
template<>
OdbCompression ToProtoEnum( JOB_EXPORT_PCB_ODB::ODB_COMPRESSION aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::NONE: return OdbCompression::ODBC_NONE;
    case JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::ZIP:  return OdbCompression::ODBC_ZIP;
    case JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::TGZ:  return OdbCompression::ODBC_TGZ;
    default:
        wxCHECK_MSG( false, OdbCompression::ODBC_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_ODB::ODB_COMPRESSION>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_ODB::ODB_COMPRESSION FromProtoEnum( OdbCompression aValue )
{
    switch( aValue )
    {
    case OdbCompression::ODBC_NONE: return JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::NONE;
    case OdbCompression::ODBC_ZIP:  return JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::ZIP;
    case OdbCompression::ODBC_TGZ:  return JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::TGZ;
    case OdbCompression::ODBC_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::ZIP;
    }
}
 
 
template<>
OdbVariantPackaging ToProtoEnum( JOB_EXPORT_PCB_ODB::VARIANT_PACKAGING aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_ODB::VARIANT_PACKAGING::SEPARATE: return OdbVariantPackaging::ODBVP_SEPARATE;
    case JOB_EXPORT_PCB_ODB::VARIANT_PACKAGING::COMBINED: return OdbVariantPackaging::ODBVP_COMBINED;
    default:
        wxCHECK_MSG( false, OdbVariantPackaging::ODBVP_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_ODB::VARIANT_PACKAGING>" );
    }
}
 
 
template <>
OdbOrigin ToProtoEnum( JOB_EXPORT_PCB_ODB::ORIGIN aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_ODB::ORIGIN::ABSOLUTE_COORDS: return OdbOrigin::ODBO_ABSOLUTE;
    case JOB_EXPORT_PCB_ODB::ORIGIN::AUX: return OdbOrigin::ODBO_AUX;
    case JOB_EXPORT_PCB_ODB::ORIGIN::GRID: return OdbOrigin::ODBO_GRID;
    default: wxCHECK_MSG( false, OdbOrigin::ODBO_UNKNOWN, "Unhandled ODB++ origin" );
    }
}
 
 
template <>
JOB_EXPORT_PCB_ODB::ORIGIN FromProtoEnum( OdbOrigin aValue )
{
    switch( aValue )
    {
    case OdbOrigin::ODBO_AUX: return JOB_EXPORT_PCB_ODB::ORIGIN::AUX;
    case OdbOrigin::ODBO_GRID: return JOB_EXPORT_PCB_ODB::ORIGIN::GRID;
    case OdbOrigin::ODBO_ABSOLUTE:
    case OdbOrigin::ODBO_UNKNOWN:
    default: return JOB_EXPORT_PCB_ODB::ORIGIN::ABSOLUTE_COORDS;
    }
}
 
 
template <>
FabDataSet ToProtoEnum( JOB_EXPORT_PCB_FAB::DATA_SET aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_FAB::DATA_SET::USERDEF: return FabDataSet::FDS_USERDEF;
    case JOB_EXPORT_PCB_FAB::DATA_SET::BOM: return FabDataSet::FDS_BOM;
    case JOB_EXPORT_PCB_FAB::DATA_SET::STACKUP: return FabDataSet::FDS_STACKUP;
    case JOB_EXPORT_PCB_FAB::DATA_SET::FABRICATION: return FabDataSet::FDS_FABRICATION;
    case JOB_EXPORT_PCB_FAB::DATA_SET::ASSEMBLY: return FabDataSet::FDS_ASSEMBLY;
    case JOB_EXPORT_PCB_FAB::DATA_SET::TEST: return FabDataSet::FDS_TEST;
    case JOB_EXPORT_PCB_FAB::DATA_SET::STENCIL: return FabDataSet::FDS_STENCIL;
    case JOB_EXPORT_PCB_FAB::DATA_SET::DFX: return FabDataSet::FDS_DFX;
    default: wxCHECK_MSG( false, FabDataSet::FDS_UNKNOWN, "Unhandled fabrication data set" );
    }
}
 
 
template <>
JOB_EXPORT_PCB_FAB::DATA_SET FromProtoEnum( FabDataSet aValue )
{
    switch( aValue )
    {
    case FabDataSet::FDS_BOM: return JOB_EXPORT_PCB_FAB::DATA_SET::BOM;
    case FabDataSet::FDS_STACKUP: return JOB_EXPORT_PCB_FAB::DATA_SET::STACKUP;
    case FabDataSet::FDS_FABRICATION: return JOB_EXPORT_PCB_FAB::DATA_SET::FABRICATION;
    case FabDataSet::FDS_ASSEMBLY: return JOB_EXPORT_PCB_FAB::DATA_SET::ASSEMBLY;
    case FabDataSet::FDS_TEST: return JOB_EXPORT_PCB_FAB::DATA_SET::TEST;
    case FabDataSet::FDS_STENCIL: return JOB_EXPORT_PCB_FAB::DATA_SET::STENCIL;
    case FabDataSet::FDS_DFX: return JOB_EXPORT_PCB_FAB::DATA_SET::DFX;
    case FabDataSet::FDS_USERDEF:
    case FabDataSet::FDS_UNKNOWN: return JOB_EXPORT_PCB_FAB::DATA_SET::USERDEF;
 
    // A value from a newer client must not turn into the broadest data set
    default: return JOB_EXPORT_PCB_FAB::DATA_SET::COUNT;
    }
}
 
 
template <>
FabNetNamePolicy ToProtoEnum( JOB_EXPORT_PCB_FAB::NET_NAMES aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_FAB::NET_NAMES::INCLUDE: return FabNetNamePolicy::FNNP_INCLUDE;
    case JOB_EXPORT_PCB_FAB::NET_NAMES::ANONYMIZE: return FabNetNamePolicy::FNNP_ANONYMIZE;
    default: wxCHECK_MSG( false, FabNetNamePolicy::FNNP_UNKNOWN, "Unhandled net name policy" );
    }
}
 
 
template <>
JOB_EXPORT_PCB_FAB::NET_NAMES FromProtoEnum( FabNetNamePolicy aValue )
{
    switch( aValue )
    {
    case FabNetNamePolicy::FNNP_ANONYMIZE: return JOB_EXPORT_PCB_FAB::NET_NAMES::ANONYMIZE;
    case FabNetNamePolicy::FNNP_INCLUDE:
    case FabNetNamePolicy::FNNP_UNKNOWN:
    default: return JOB_EXPORT_PCB_FAB::NET_NAMES::INCLUDE;
    }
}
 
 
template <>
Ipc2581RefDes ToProtoEnum( JOB_EXPORT_PCB_IPC2581::REF_DES aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_IPC2581::REF_DES::INCLUDE: return Ipc2581RefDes::IPC2581RD_INCLUDE;
    case JOB_EXPORT_PCB_IPC2581::REF_DES::OMIT: return Ipc2581RefDes::IPC2581RD_OMIT;
    default: wxCHECK_MSG( false, Ipc2581RefDes::IPC2581RD_UNKNOWN, "Unhandled reference designator policy" );
    }
}
 
 
template <>
JOB_EXPORT_PCB_IPC2581::REF_DES FromProtoEnum( Ipc2581RefDes aValue )
{
    switch( aValue )
    {
    case Ipc2581RefDes::IPC2581RD_OMIT: return JOB_EXPORT_PCB_IPC2581::REF_DES::OMIT;
    case Ipc2581RefDes::IPC2581RD_INCLUDE:
    case Ipc2581RefDes::IPC2581RD_UNKNOWN:
    default: return JOB_EXPORT_PCB_IPC2581::REF_DES::INCLUDE;
    }
}
 
 
template<>
JOB_EXPORT_PCB_ODB::VARIANT_PACKAGING FromProtoEnum( OdbVariantPackaging aValue )
{
    switch( aValue )
    {
    case OdbVariantPackaging::ODBVP_COMBINED: return JOB_EXPORT_PCB_ODB::VARIANT_PACKAGING::COMBINED;
    case OdbVariantPackaging::ODBVP_SEPARATE:
    case OdbVariantPackaging::ODBVP_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_ODB::VARIANT_PACKAGING::SEPARATE;
    }
}
 
 
template<>
StatsOutputFormat ToProtoEnum( JOB_EXPORT_PCB_STATS::OUTPUT_FORMAT aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_STATS::OUTPUT_FORMAT::REPORT: return StatsOutputFormat::SOF_REPORT;
    case JOB_EXPORT_PCB_STATS::OUTPUT_FORMAT::JSON:   return StatsOutputFormat::SOF_JSON;
    default:
        wxCHECK_MSG( false, StatsOutputFormat::SOF_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_STATS::OUTPUT_FORMAT>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_STATS::OUTPUT_FORMAT FromProtoEnum( StatsOutputFormat aValue )
{
    switch( aValue )
    {
    case StatsOutputFormat::SOF_REPORT: return JOB_EXPORT_PCB_STATS::OUTPUT_FORMAT::REPORT;
    case StatsOutputFormat::SOF_JSON:   return JOB_EXPORT_PCB_STATS::OUTPUT_FORMAT::JSON;
    case StatsOutputFormat::SOF_UNKNOWN:
    default:
        return JOB_EXPORT_PCB_STATS::OUTPUT_FORMAT::REPORT;
    }
}
 
 
template<>
kiapi::common::types::Units ToProtoEnum( JOB_EXPORT_PCB_DXF::DXF_UNITS aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_DXF::DXF_UNITS::INCH: return kiapi::common::types::Units::U_INCH;
    case JOB_EXPORT_PCB_DXF::DXF_UNITS::MM:   return kiapi::common::types::Units::U_MM;
    default:
        wxCHECK_MSG( false, kiapi::common::types::Units::U_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_DXF::DXF_UNITS>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_DXF::DXF_UNITS FromProtoEnum( kiapi::common::types::Units aValue )
{
    switch( aValue )
    {
    case kiapi::common::types::Units::U_INCH: return JOB_EXPORT_PCB_DXF::DXF_UNITS::INCH;
    case kiapi::common::types::Units::U_MM:   return JOB_EXPORT_PCB_DXF::DXF_UNITS::MM;
    case kiapi::common::types::Units::U_UNKNOWN:
    case kiapi::common::types::Units::U_METERS:
    case kiapi::common::types::Units::U_TENTHS:
    default:
        return JOB_EXPORT_PCB_DXF::DXF_UNITS::INCH;
    }
}
 
 
template<>
kiapi::common::types::Units ToProtoEnum( JOB_EXPORT_PCB_POS::UNITS aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_POS::UNITS::INCH: return kiapi::common::types::Units::U_INCH;
    case JOB_EXPORT_PCB_POS::UNITS::MM:   return kiapi::common::types::Units::U_MM;
    default:
        wxCHECK_MSG( false, kiapi::common::types::Units::U_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_POS::UNITS>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_POS::UNITS FromProtoEnum( kiapi::common::types::Units aValue )
{
    switch( aValue )
    {
    case kiapi::common::types::Units::U_INCH: return JOB_EXPORT_PCB_POS::UNITS::INCH;
    case kiapi::common::types::Units::U_MM:   return JOB_EXPORT_PCB_POS::UNITS::MM;
    case kiapi::common::types::Units::U_UNKNOWN:
    case kiapi::common::types::Units::U_METERS:
    case kiapi::common::types::Units::U_TENTHS:
    default:
        return JOB_EXPORT_PCB_POS::UNITS::MM;
    }
}
 
 
template<>
kiapi::common::types::Units ToProtoEnum( JOB_EXPORT_PCB_FAB::UNITS aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_FAB::UNITS::INCH: return kiapi::common::types::Units::U_INCH;
    case JOB_EXPORT_PCB_FAB::UNITS::MM:   return kiapi::common::types::Units::U_MM;
    default:
        wxCHECK_MSG( false, kiapi::common::types::Units::U_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_FAB::UNITS>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_FAB::UNITS FromProtoEnum( kiapi::common::types::Units aValue )
{
    switch( aValue )
    {
    case kiapi::common::types::Units::U_INCH: return JOB_EXPORT_PCB_FAB::UNITS::INCH;
    case kiapi::common::types::Units::U_MM:   return JOB_EXPORT_PCB_FAB::UNITS::MM;
    case kiapi::common::types::Units::U_UNKNOWN:
    case kiapi::common::types::Units::U_METERS:
    case kiapi::common::types::Units::U_TENTHS:
    default:
        return JOB_EXPORT_PCB_FAB::UNITS::MM;
    }
}
 
 
template<>
kiapi::common::types::Units ToProtoEnum( IDF_SETTINGS::UNITS aValue )
{
    switch( aValue )
    {
    case IDF_SETTINGS::UNITS::MILS: return kiapi::common::types::Units::U_MILS;
    case IDF_SETTINGS::UNITS::MM:   return kiapi::common::types::Units::U_MM;
    default:
        wxCHECK_MSG( false, kiapi::common::types::Units::U_UNKNOWN,
                     "Unhandled case in ToProtoEnum<IDF_SETTINGS::UNITS>" );
    }
}
 
 
template<>
IDF_SETTINGS::UNITS FromProtoEnum( kiapi::common::types::Units aValue )
{
    switch( aValue )
    {
    case kiapi::common::types::Units::U_MILS: return IDF_SETTINGS::UNITS::MILS;
    case kiapi::common::types::Units::U_MM:   return IDF_SETTINGS::UNITS::MM;
    case kiapi::common::types::Units::U_UNKNOWN:
    case kiapi::common::types::Units::U_INCH:
    case kiapi::common::types::Units::U_METERS:
    case kiapi::common::types::Units::U_TENTHS:
    default:
        return IDF_SETTINGS::UNITS::MM;
    }
}
 
 
template<>
IdfOriginMode ToProtoEnum( IDF_SETTINGS::COORD_ORIGIN aValue )
{
    switch( aValue )
    {
    case IDF_SETTINGS::COORD_ORIGIN::CENTER: return IdfOriginMode::IOM_BOARD_CENTER;
    case IDF_SETTINGS::COORD_ORIGIN::GRID:   return IdfOriginMode::IOM_GRID_ORIGIN;
    case IDF_SETTINGS::COORD_ORIGIN::DRILL:  return IdfOriginMode::IOM_DRILL_ORIGIN;
    case IDF_SETTINGS::COORD_ORIGIN::USER:   return IdfOriginMode::IOM_USER;
    default:
        wxCHECK_MSG( false, IdfOriginMode::IOM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<IDF_SETTINGS::COORD_ORIGIN>" );
    }
}
 
 
template<>
IDF_SETTINGS::COORD_ORIGIN FromProtoEnum( IdfOriginMode aValue )
{
    switch( aValue )
    {
    case IdfOriginMode::IOM_BOARD_CENTER: return IDF_SETTINGS::COORD_ORIGIN::CENTER;
    case IdfOriginMode::IOM_GRID_ORIGIN:  return IDF_SETTINGS::COORD_ORIGIN::GRID;
    case IdfOriginMode::IOM_DRILL_ORIGIN: return IDF_SETTINGS::COORD_ORIGIN::DRILL;
    case IdfOriginMode::IOM_USER:         return IDF_SETTINGS::COORD_ORIGIN::USER;
    case IdfOriginMode::IOM_UNKNOWN:
    default:
        return IDF_SETTINGS::COORD_ORIGIN::CENTER;
    }
}
 
 
template<>
kiapi::common::types::Units ToProtoEnum( JOB_EXPORT_PCB_STATS::UNITS aValue )
{
    switch( aValue )
    {
    case JOB_EXPORT_PCB_STATS::UNITS::INCH: return kiapi::common::types::Units::U_INCH;
    case JOB_EXPORT_PCB_STATS::UNITS::MM:   return kiapi::common::types::Units::U_MM;
    default:
        wxCHECK_MSG( false, kiapi::common::types::Units::U_UNKNOWN,
                     "Unhandled case in ToProtoEnum<JOB_EXPORT_PCB_STATS::UNITS>" );
    }
}
 
 
template<>
JOB_EXPORT_PCB_STATS::UNITS FromProtoEnum( kiapi::common::types::Units aValue )
{
    switch( aValue )
    {
    case kiapi::common::types::Units::U_INCH: return JOB_EXPORT_PCB_STATS::UNITS::INCH;
    case kiapi::common::types::Units::U_MM:   return JOB_EXPORT_PCB_STATS::UNITS::MM;
    case kiapi::common::types::Units::U_UNKNOWN:
    case kiapi::common::types::Units::U_METERS:
    case kiapi::common::types::Units::U_TENTHS:
    default:
        return JOB_EXPORT_PCB_STATS::UNITS::MM;
    }
}
 
 
template<>
DrcErrorType ToProtoEnum( PCB_DRC_CODE aValue )
{
    switch( aValue )
    {
    case DRCE_UNCONNECTED_ITEMS:             return DrcErrorType::DRCET_UNCONNECTED_ITEMS;
    case DRCE_SHORTING_ITEMS:                return DrcErrorType::DRCET_SHORTING_ITEMS;
    case DRCE_ALLOWED_ITEMS:                 return DrcErrorType::DRCET_ALLOWED_ITEMS;
    case DRCE_TEXT_ON_EDGECUTS:              return DrcErrorType::DRCET_TEXT_ON_EDGECUTS;
    case DRCE_CLEARANCE:                     return DrcErrorType::DRCET_CLEARANCE;
    case DRCE_CREEPAGE:                      return DrcErrorType::DRCET_CREEPAGE;
    case DRCE_TRACKS_CROSSING:               return DrcErrorType::DRCET_TRACKS_CROSSING;
    case DRCE_EDGE_CLEARANCE:                return DrcErrorType::DRCET_EDGE_CLEARANCE;
    case DRCE_ZONES_INTERSECT:               return DrcErrorType::DRCET_ZONES_INTERSECT;
    case DRCE_ISOLATED_COPPER:               return DrcErrorType::DRCET_ISOLATED_COPPER;
    case DRCE_STARVED_THERMAL:               return DrcErrorType::DRCET_STARVED_THERMAL;
    case DRCE_DANGLING_VIA:                  return DrcErrorType::DRCET_DANGLING_VIA;
    case DRCE_DANGLING_TRACK:                return DrcErrorType::DRCET_DANGLING_TRACK;
    case DRCE_DRILLED_HOLES_TOO_CLOSE:       return DrcErrorType::DRCET_DRILLED_HOLES_TOO_CLOSE;
    case DRCE_DRILLED_HOLES_COLOCATED:       return DrcErrorType::DRCET_DRILLED_HOLES_COLOCATED;
    case DRCE_HOLE_CLEARANCE:                return DrcErrorType::DRCET_HOLE_CLEARANCE;
    case DRCE_CONNECTION_WIDTH:              return DrcErrorType::DRCET_CONNECTION_WIDTH;
    case DRCE_TRACK_WIDTH:                   return DrcErrorType::DRCET_TRACK_WIDTH;
    case DRCE_TRACK_ANGLE:                   return DrcErrorType::DRCET_TRACK_ANGLE;
    case DRCE_TRACK_SEGMENT_LENGTH:          return DrcErrorType::DRCET_TRACK_SEGMENT_LENGTH;
    case DRCE_ANNULAR_WIDTH:                 return DrcErrorType::DRCET_ANNULAR_WIDTH;
    case DRCE_DRILL_OUT_OF_RANGE:            return DrcErrorType::DRCET_DRILL_OUT_OF_RANGE;
    case DRCE_VIA_DIAMETER:                  return DrcErrorType::DRCET_VIA_DIAMETER;
    case DRCE_PADSTACK:                      return DrcErrorType::DRCET_PADSTACK;
    case DRCE_PADSTACK_INVALID:              return DrcErrorType::DRCET_PADSTACK_INVALID;
    case DRCE_MICROVIA_DRILL_OUT_OF_RANGE:   return DrcErrorType::DRCET_MICROVIA_DRILL_OUT_OF_RANGE;
    case DRCE_MALFORMED_MICROVIA_STACK_SPAN: return DrcErrorType::DRCET_MALFORMED_MICROVIA_STACK_SPAN;
    case DRCE_MICROVIA_STACK_NOT_FILLED:     return DrcErrorType::DRCET_MICROVIA_STACK_NOT_FILLED;
    case DRCE_MICROVIA_STACK_DEPTH:          return DrcErrorType::DRCET_MICROVIA_STACK_DEPTH;
    case DRCE_MICROVIA_ASPECT_RATIO:         return DrcErrorType::DRCET_MICROVIA_ASPECT_RATIO;
    case DRCE_MICROVIA_CROSSES_CORE: return DrcErrorType::DRCET_MICROVIA_CROSSES_CORE;
    case DRCE_OVERLAPPING_FOOTPRINTS:        return DrcErrorType::DRCET_OVERLAPPING_FOOTPRINTS;
    case DRCE_MISSING_COURTYARD:             return DrcErrorType::DRCET_MISSING_COURTYARD;
    case DRCE_MALFORMED_COURTYARD:           return DrcErrorType::DRCET_MALFORMED_COURTYARD;
    case DRCE_PTH_IN_COURTYARD:              return DrcErrorType::DRCET_PTH_IN_COURTYARD;
    case DRCE_NPTH_IN_COURTYARD:             return DrcErrorType::DRCET_NPTH_IN_COURTYARD;
    case DRCE_DISABLED_LAYER_ITEM:           return DrcErrorType::DRCET_DISABLED_LAYER_ITEM;
    case DRCE_INVALID_OUTLINE:               return DrcErrorType::DRCET_INVALID_OUTLINE;
    case DRCE_MISSING_FOOTPRINT:             return DrcErrorType::DRCET_MISSING_FOOTPRINT;
    case DRCE_DUPLICATE_FOOTPRINT:           return DrcErrorType::DRCET_DUPLICATE_FOOTPRINT;
    case DRCE_NET_CONFLICT:                  return DrcErrorType::DRCET_NET_CONFLICT;
    case DRCE_EXTRA_FOOTPRINT:               return DrcErrorType::DRCET_EXTRA_FOOTPRINT;
    case DRCE_SCHEMATIC_PARITY:              return DrcErrorType::DRCET_SCHEMATIC_PARITY;
    case DRCE_SCHEMATIC_FIELDS_PARITY:       return DrcErrorType::DRCET_SCHEMATIC_FIELDS_PARITY;
    case DRCE_FOOTPRINT_FILTERS:             return DrcErrorType::DRCET_FOOTPRINT_FILTERS;
    case DRCE_LIB_FOOTPRINT_ISSUES:          return DrcErrorType::DRCET_LIB_FOOTPRINT_ISSUES;
    case DRCE_LIB_FOOTPRINT_MISMATCH:        return DrcErrorType::DRCET_LIB_FOOTPRINT_MISMATCH;
    case DRCE_UNRESOLVED_VARIABLE:           return DrcErrorType::DRCET_UNRESOLVED_VARIABLE;
    case DRCE_ASSERTION_FAILURE:             return DrcErrorType::DRCET_ASSERTION_FAILURE;
    case DRCE_GENERIC_WARNING:               return DrcErrorType::DRCET_GENERIC_WARNING;
    case DRCE_GENERIC_ERROR:                 return DrcErrorType::DRCET_GENERIC_ERROR;
    case DRCE_COPPER_SLIVER:                 return DrcErrorType::DRCET_COPPER_SLIVER;
    case DRCE_SILK_CLEARANCE:                return DrcErrorType::DRCET_SILK_CLEARANCE;
    case DRCE_SILK_MASK_CLEARANCE:           return DrcErrorType::DRCET_SILK_MASK_CLEARANCE;
    case DRCE_SILK_EDGE_CLEARANCE:           return DrcErrorType::DRCET_SILK_EDGE_CLEARANCE;
    case DRCE_SOLDERMASK_BRIDGE:             return DrcErrorType::DRCET_SOLDERMASK_BRIDGE;
    case DRCE_TEXT_HEIGHT:                   return DrcErrorType::DRCET_TEXT_HEIGHT;
    case DRCE_TEXT_THICKNESS:                return DrcErrorType::DRCET_TEXT_THICKNESS;
    case DRCE_LENGTH_OUT_OF_RANGE:           return DrcErrorType::DRCET_LENGTH_OUT_OF_RANGE;
    case DRCE_SKEW_OUT_OF_RANGE:             return DrcErrorType::DRCET_SKEW_OUT_OF_RANGE;
    case DRCE_NET_CHAIN_STUB_TOO_LONG:       return DrcErrorType::DRCET_NET_CHAIN_STUB_TOO_LONG;
    case DRCE_NET_CHAIN_RETURN_PATH_BREAK:   return DrcErrorType::DRCET_NET_CHAIN_RETURN_PATH_BREAK;
    case DRCE_NET_CHAIN_TUNING_PROFILES:     return DrcErrorType::DRCET_NET_CHAIN_TUNING_PROFILES;
    case DRCE_VIA_COUNT_OUT_OF_RANGE:        return DrcErrorType::DRCET_VIA_COUNT_OUT_OF_RANGE;
    case DRCE_DP_GAP_OUT_OF_RANGE:           return DrcErrorType::DRCET_DIFF_PAIR_GAP_OUT_OF_RANGE;
    case DRCE_DP_UNCOUPLED_LENGTH_TOO_LONG:  return DrcErrorType::DRCET_DIFF_PAIR_UNCOUPLED_LENGTH_TOO_LONG;
    case DRCE_FOOTPRINT:                     return DrcErrorType::DRCET_FOOTPRINT;
    case DRCE_FOOTPRINT_SCALED_WITH_PADS:    return DrcErrorType::DRCET_FOOTPRINT_SCALED_WITH_PADS;
    case DRCE_FOOTPRINT_TYPE_MISMATCH:       return DrcErrorType::DRCET_FOOTPRINT_TYPE_MISMATCH;
    case DRCE_PAD_TH_WITH_NO_HOLE:           return DrcErrorType::DRCET_PAD_TH_WITH_NO_HOLE;
    case DRCE_MIRRORED_TEXT_ON_FRONT_LAYER:  return DrcErrorType::DRCET_MIRRORED_TEXT_ON_FRONT_LAYER;
    case DRCE_UNMIRRORED_TEXT_ON_BACK_LAYER: return DrcErrorType::DRCET_NONMIRRORED_TEXT_ON_BACK_LAYER;
    case DRCE_MISSING_TUNING_PROFILE:        return DrcErrorType::DRCET_MISSING_TUNING_PROFILE;
    case DRCE_TUNING_PROFILE_IMPLICIT_RULES: return DrcErrorType::DRCET_TUNING_PROFILE_IMPLICIT_RULES;
    case DRCE_TRACK_ON_POST_MACHINED_LAYER:  return DrcErrorType::DRCET_TRACK_ON_POST_MACHINED_LAYER;
    case DRCE_TRACK_NOT_CENTERED_ON_VIA:     return DrcErrorType::DRCET_TRACK_NOT_CENTERED_ON_VIA;
    default:
        return DrcErrorType::DRCET_UNKNOWN;
    }
}
 
 
template<>
PCB_DRC_CODE FromProtoEnum( DrcErrorType aValue )
{
    switch( aValue )
    {
    case DrcErrorType::DRCET_UNCONNECTED_ITEMS:                   return DRCE_UNCONNECTED_ITEMS;
    case DrcErrorType::DRCET_SHORTING_ITEMS:                      return DRCE_SHORTING_ITEMS;
    case DrcErrorType::DRCET_ALLOWED_ITEMS:                       return DRCE_ALLOWED_ITEMS;
    case DrcErrorType::DRCET_TEXT_ON_EDGECUTS:                    return DRCE_TEXT_ON_EDGECUTS;
    case DrcErrorType::DRCET_CLEARANCE:                           return DRCE_CLEARANCE;
    case DrcErrorType::DRCET_CREEPAGE:                            return DRCE_CREEPAGE;
    case DrcErrorType::DRCET_TRACKS_CROSSING:                     return DRCE_TRACKS_CROSSING;
    case DrcErrorType::DRCET_EDGE_CLEARANCE:                      return DRCE_EDGE_CLEARANCE;
    case DrcErrorType::DRCET_ZONES_INTERSECT:                     return DRCE_ZONES_INTERSECT;
    case DrcErrorType::DRCET_ISOLATED_COPPER:                     return DRCE_ISOLATED_COPPER;
    case DrcErrorType::DRCET_STARVED_THERMAL:                     return DRCE_STARVED_THERMAL;
    case DrcErrorType::DRCET_DANGLING_VIA:                        return DRCE_DANGLING_VIA;
    case DrcErrorType::DRCET_DANGLING_TRACK:                      return DRCE_DANGLING_TRACK;
    case DrcErrorType::DRCET_DRILLED_HOLES_TOO_CLOSE:             return DRCE_DRILLED_HOLES_TOO_CLOSE;
    case DrcErrorType::DRCET_DRILLED_HOLES_COLOCATED:             return DRCE_DRILLED_HOLES_COLOCATED;
    case DrcErrorType::DRCET_HOLE_CLEARANCE:                      return DRCE_HOLE_CLEARANCE;
    case DrcErrorType::DRCET_CONNECTION_WIDTH:                    return DRCE_CONNECTION_WIDTH;
    case DrcErrorType::DRCET_TRACK_WIDTH:                         return DRCE_TRACK_WIDTH;
    case DrcErrorType::DRCET_TRACK_ANGLE:                         return DRCE_TRACK_ANGLE;
    case DrcErrorType::DRCET_TRACK_SEGMENT_LENGTH:                return DRCE_TRACK_SEGMENT_LENGTH;
    case DrcErrorType::DRCET_ANNULAR_WIDTH:                       return DRCE_ANNULAR_WIDTH;
    case DrcErrorType::DRCET_DRILL_OUT_OF_RANGE:                  return DRCE_DRILL_OUT_OF_RANGE;
    case DrcErrorType::DRCET_VIA_DIAMETER:                        return DRCE_VIA_DIAMETER;
    case DrcErrorType::DRCET_PADSTACK:                            return DRCE_PADSTACK;
    case DrcErrorType::DRCET_PADSTACK_INVALID:                    return DRCE_PADSTACK_INVALID;
    case DrcErrorType::DRCET_MICROVIA_DRILL_OUT_OF_RANGE:         return DRCE_MICROVIA_DRILL_OUT_OF_RANGE;
    case DrcErrorType::DRCET_MALFORMED_MICROVIA_STACK_SPAN:       return DRCE_MALFORMED_MICROVIA_STACK_SPAN;
    case DrcErrorType::DRCET_MICROVIA_STACK_NOT_FILLED:           return DRCE_MICROVIA_STACK_NOT_FILLED;
    case DrcErrorType::DRCET_MICROVIA_STACK_DEPTH:                return DRCE_MICROVIA_STACK_DEPTH;
    case DrcErrorType::DRCET_MICROVIA_ASPECT_RATIO:               return DRCE_MICROVIA_ASPECT_RATIO;
    case DrcErrorType::DRCET_MICROVIA_CROSSES_CORE: return DRCE_MICROVIA_CROSSES_CORE;
    case DrcErrorType::DRCET_OVERLAPPING_FOOTPRINTS:              return DRCE_OVERLAPPING_FOOTPRINTS;
    case DrcErrorType::DRCET_MISSING_COURTYARD:                   return DRCE_MISSING_COURTYARD;
    case DrcErrorType::DRCET_MALFORMED_COURTYARD:                 return DRCE_MALFORMED_COURTYARD;
    case DrcErrorType::DRCET_PTH_IN_COURTYARD:                    return DRCE_PTH_IN_COURTYARD;
    case DrcErrorType::DRCET_NPTH_IN_COURTYARD:                   return DRCE_NPTH_IN_COURTYARD;
    case DrcErrorType::DRCET_DISABLED_LAYER_ITEM:                 return DRCE_DISABLED_LAYER_ITEM;
    case DrcErrorType::DRCET_INVALID_OUTLINE:                     return DRCE_INVALID_OUTLINE;
    case DrcErrorType::DRCET_MISSING_FOOTPRINT:                   return DRCE_MISSING_FOOTPRINT;
    case DrcErrorType::DRCET_DUPLICATE_FOOTPRINT:                 return DRCE_DUPLICATE_FOOTPRINT;
    case DrcErrorType::DRCET_NET_CONFLICT:                        return DRCE_NET_CONFLICT;
    case DrcErrorType::DRCET_EXTRA_FOOTPRINT:                     return DRCE_EXTRA_FOOTPRINT;
    case DrcErrorType::DRCET_SCHEMATIC_PARITY:                    return DRCE_SCHEMATIC_PARITY;
    case DrcErrorType::DRCET_SCHEMATIC_FIELDS_PARITY:             return DRCE_SCHEMATIC_FIELDS_PARITY;
    case DrcErrorType::DRCET_FOOTPRINT_FILTERS:                   return DRCE_FOOTPRINT_FILTERS;
    case DrcErrorType::DRCET_LIB_FOOTPRINT_ISSUES:                return DRCE_LIB_FOOTPRINT_ISSUES;
    case DrcErrorType::DRCET_LIB_FOOTPRINT_MISMATCH:              return DRCE_LIB_FOOTPRINT_MISMATCH;
    case DrcErrorType::DRCET_UNRESOLVED_VARIABLE:                 return DRCE_UNRESOLVED_VARIABLE;
    case DrcErrorType::DRCET_ASSERTION_FAILURE:                   return DRCE_ASSERTION_FAILURE;
    case DrcErrorType::DRCET_GENERIC_WARNING:                     return DRCE_GENERIC_WARNING;
    case DrcErrorType::DRCET_GENERIC_ERROR:                       return DRCE_GENERIC_ERROR;
    case DrcErrorType::DRCET_COPPER_SLIVER:                       return DRCE_COPPER_SLIVER;
    case DrcErrorType::DRCET_SILK_CLEARANCE:                      return DRCE_SILK_CLEARANCE;
    case DrcErrorType::DRCET_SILK_MASK_CLEARANCE:                 return DRCE_SILK_MASK_CLEARANCE;
    case DrcErrorType::DRCET_SILK_EDGE_CLEARANCE:                 return DRCE_SILK_EDGE_CLEARANCE;
    case DrcErrorType::DRCET_SOLDERMASK_BRIDGE:                   return DRCE_SOLDERMASK_BRIDGE;
    case DrcErrorType::DRCET_TEXT_HEIGHT:                         return DRCE_TEXT_HEIGHT;
    case DrcErrorType::DRCET_TEXT_THICKNESS:                      return DRCE_TEXT_THICKNESS;
    case DrcErrorType::DRCET_LENGTH_OUT_OF_RANGE:                 return DRCE_LENGTH_OUT_OF_RANGE;
    case DrcErrorType::DRCET_NET_CHAIN_STUB_TOO_LONG:             return DRCE_NET_CHAIN_STUB_TOO_LONG;
    case DrcErrorType::DRCET_NET_CHAIN_RETURN_PATH_BREAK:         return DRCE_NET_CHAIN_RETURN_PATH_BREAK;
    case DrcErrorType::DRCET_NET_CHAIN_TUNING_PROFILES:           return DRCE_NET_CHAIN_TUNING_PROFILES;
    case DrcErrorType::DRCET_SKEW_OUT_OF_RANGE:                   return DRCE_SKEW_OUT_OF_RANGE;
    case DrcErrorType::DRCET_VIA_COUNT_OUT_OF_RANGE:              return DRCE_VIA_COUNT_OUT_OF_RANGE;
    case DrcErrorType::DRCET_DIFF_PAIR_GAP_OUT_OF_RANGE:          return DRCE_DP_GAP_OUT_OF_RANGE;
    case DrcErrorType::DRCET_DIFF_PAIR_UNCOUPLED_LENGTH_TOO_LONG: return DRCE_DP_UNCOUPLED_LENGTH_TOO_LONG;
    case DrcErrorType::DRCET_FOOTPRINT_SCALED_WITH_PADS:          return DRCE_FOOTPRINT_SCALED_WITH_PADS;
    case DrcErrorType::DRCET_FOOTPRINT:                           return DRCE_FOOTPRINT;
    case DrcErrorType::DRCET_FOOTPRINT_TYPE_MISMATCH:             return DRCE_FOOTPRINT_TYPE_MISMATCH;
    case DrcErrorType::DRCET_PAD_TH_WITH_NO_HOLE:                 return DRCE_PAD_TH_WITH_NO_HOLE;
    case DrcErrorType::DRCET_MIRRORED_TEXT_ON_FRONT_LAYER:        return DRCE_MIRRORED_TEXT_ON_FRONT_LAYER;
    case DrcErrorType::DRCET_NONMIRRORED_TEXT_ON_BACK_LAYER:      return DRCE_UNMIRRORED_TEXT_ON_BACK_LAYER;
    case DrcErrorType::DRCET_MISSING_TUNING_PROFILE:              return DRCE_MISSING_TUNING_PROFILE;
    case DrcErrorType::DRCET_TUNING_PROFILE_IMPLICIT_RULES:       return DRCE_TUNING_PROFILE_IMPLICIT_RULES;
    case DrcErrorType::DRCET_TRACK_ON_POST_MACHINED_LAYER:        return DRCE_TRACK_ON_POST_MACHINED_LAYER;
    case DrcErrorType::DRCET_TRACK_NOT_CENTERED_ON_VIA:           return DRCE_TRACK_NOT_CENTERED_ON_VIA;
 
    case DrcErrorType::DRCET_UNKNOWN:
    default:
        return static_cast<PCB_DRC_CODE>( 0 );
    }
}
 
 
template<>
types::ConstraintType ToProtoEnum( PCB_CONSTRAINT_TYPE aValue )
{
    switch( aValue )
    {
    case PCB_CONSTRAINT_TYPE::COINCIDENT:        return types::ConstraintType::CT_COINCIDENT;
    case PCB_CONSTRAINT_TYPE::HORIZONTAL:        return types::ConstraintType::CT_HORIZONTAL;
    case PCB_CONSTRAINT_TYPE::VERTICAL:          return types::ConstraintType::CT_VERTICAL;
    case PCB_CONSTRAINT_TYPE::PARALLEL:          return types::ConstraintType::CT_PARALLEL;
    case PCB_CONSTRAINT_TYPE::PERPENDICULAR:     return types::ConstraintType::CT_PERPENDICULAR;
    case PCB_CONSTRAINT_TYPE::COLLINEAR:         return types::ConstraintType::CT_COLLINEAR;
    case PCB_CONSTRAINT_TYPE::SYMMETRIC:         return types::ConstraintType::CT_SYMMETRIC;
    case PCB_CONSTRAINT_TYPE::EQUAL_LENGTH:      return types::ConstraintType::CT_EQUAL_LENGTH;
    case PCB_CONSTRAINT_TYPE::EQUAL_RADIUS:      return types::ConstraintType::CT_EQUAL_RADIUS;
    case PCB_CONSTRAINT_TYPE::POINT_ON_LINE:     return types::ConstraintType::CT_POINT_ON_LINE;
    case PCB_CONSTRAINT_TYPE::MIDPOINT:          return types::ConstraintType::CT_MIDPOINT;
    case PCB_CONSTRAINT_TYPE::FIXED_POSITION:    return types::ConstraintType::CT_FIXED_POSITION;
    case PCB_CONSTRAINT_TYPE::FIXED_LENGTH:      return types::ConstraintType::CT_FIXED_LENGTH;
    case PCB_CONSTRAINT_TYPE::CONCENTRIC:        return types::ConstraintType::CT_CONCENTRIC;
    case PCB_CONSTRAINT_TYPE::FIXED_RADIUS:      return types::ConstraintType::CT_FIXED_RADIUS;
    case PCB_CONSTRAINT_TYPE::ANGULAR_DIMENSION: return types::ConstraintType::CT_ANGULAR_DIMENSION;
    case PCB_CONSTRAINT_TYPE::TANGENT:           return types::ConstraintType::CT_TANGENT;
    case PCB_CONSTRAINT_TYPE::ARC_ANGLE:         return types::ConstraintType::CT_ARC_ANGLE;
 
    case PCB_CONSTRAINT_TYPE::UNDEFINED:
    default:
        wxCHECK_MSG( false, types::ConstraintType::CT_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PCB_CONSTRAINT_TYPE>" );
    }
}
 
 
template<>
PCB_CONSTRAINT_TYPE FromProtoEnum( types::ConstraintType aValue )
{
    switch( aValue )
    {
    case types::ConstraintType::CT_UNKNOWN:           return PCB_CONSTRAINT_TYPE::UNDEFINED;
    case types::ConstraintType::CT_COINCIDENT:        return PCB_CONSTRAINT_TYPE::COINCIDENT;
    case types::ConstraintType::CT_HORIZONTAL:        return PCB_CONSTRAINT_TYPE::HORIZONTAL;
    case types::ConstraintType::CT_VERTICAL:          return PCB_CONSTRAINT_TYPE::VERTICAL;
    case types::ConstraintType::CT_PARALLEL:          return PCB_CONSTRAINT_TYPE::PARALLEL;
    case types::ConstraintType::CT_PERPENDICULAR:     return PCB_CONSTRAINT_TYPE::PERPENDICULAR;
    case types::ConstraintType::CT_COLLINEAR:         return PCB_CONSTRAINT_TYPE::COLLINEAR;
    case types::ConstraintType::CT_SYMMETRIC:         return PCB_CONSTRAINT_TYPE::SYMMETRIC;
    case types::ConstraintType::CT_EQUAL_LENGTH:      return PCB_CONSTRAINT_TYPE::EQUAL_LENGTH;
    case types::ConstraintType::CT_EQUAL_RADIUS:      return PCB_CONSTRAINT_TYPE::EQUAL_RADIUS;
    case types::ConstraintType::CT_POINT_ON_LINE:     return PCB_CONSTRAINT_TYPE::POINT_ON_LINE;
    case types::ConstraintType::CT_MIDPOINT:          return PCB_CONSTRAINT_TYPE::MIDPOINT;
    case types::ConstraintType::CT_FIXED_POSITION:    return PCB_CONSTRAINT_TYPE::FIXED_POSITION;
    case types::ConstraintType::CT_FIXED_LENGTH:      return PCB_CONSTRAINT_TYPE::FIXED_LENGTH;
    case types::ConstraintType::CT_CONCENTRIC:        return PCB_CONSTRAINT_TYPE::CONCENTRIC;
    case types::ConstraintType::CT_FIXED_RADIUS:      return PCB_CONSTRAINT_TYPE::FIXED_RADIUS;
    case types::ConstraintType::CT_ANGULAR_DIMENSION: return PCB_CONSTRAINT_TYPE::ANGULAR_DIMENSION;
    case types::ConstraintType::CT_TANGENT:           return PCB_CONSTRAINT_TYPE::TANGENT;
    case types::ConstraintType::CT_ARC_ANGLE:         return PCB_CONSTRAINT_TYPE::ARC_ANGLE;
 
    default:
        wxCHECK_MSG( false, PCB_CONSTRAINT_TYPE::UNDEFINED,
                     "Unhandled case in FromProtoEnum<types::ConstraintType>" );
    }
}
 
 
template<>
types::ConstraintAnchor ToProtoEnum( CONSTRAINT_ANCHOR aValue )
{
    switch( aValue )
    {
    case CONSTRAINT_ANCHOR::WHOLE:  return types::ConstraintAnchor::CA_WHOLE;
    case CONSTRAINT_ANCHOR::START:  return types::ConstraintAnchor::CA_START;
    case CONSTRAINT_ANCHOR::END:    return types::ConstraintAnchor::CA_END;
    case CONSTRAINT_ANCHOR::MID:    return types::ConstraintAnchor::CA_MID;
    case CONSTRAINT_ANCHOR::CENTER: return types::ConstraintAnchor::CA_CENTER;
    case CONSTRAINT_ANCHOR::RADIUS: return types::ConstraintAnchor::CA_RADIUS;
    case CONSTRAINT_ANCHOR::VERTEX: return types::ConstraintAnchor::CA_VERTEX;
 
    default:
        wxCHECK_MSG( false, types::ConstraintAnchor::CA_UNKNOWN,
                     "Unhandled case in ToProtoEnum<CONSTRAINT_ANCHOR>" );
    }
}
 
 
template<>
CONSTRAINT_ANCHOR FromProtoEnum( types::ConstraintAnchor aValue )
{
    switch( aValue )
    {
    case types::ConstraintAnchor::CA_UNKNOWN:
    case types::ConstraintAnchor::CA_WHOLE:  return CONSTRAINT_ANCHOR::WHOLE;
    case types::ConstraintAnchor::CA_START:  return CONSTRAINT_ANCHOR::START;
    case types::ConstraintAnchor::CA_END:    return CONSTRAINT_ANCHOR::END;
    case types::ConstraintAnchor::CA_MID:    return CONSTRAINT_ANCHOR::MID;
    case types::ConstraintAnchor::CA_CENTER: return CONSTRAINT_ANCHOR::CENTER;
    case types::ConstraintAnchor::CA_RADIUS: return CONSTRAINT_ANCHOR::RADIUS;
    case types::ConstraintAnchor::CA_VERTEX: return CONSTRAINT_ANCHOR::VERTEX;
 
    default:
        wxCHECK_MSG( false, CONSTRAINT_ANCHOR::WHOLE,
                     "Unhandled case in FromProtoEnum<types::ConstraintAnchor>" );
    }
}
 
 
template<>
types::TuningPatternMode ToProtoEnum( LENGTH_TUNING_MODE aValue )
{
    switch( aValue )
    {
    case LENGTH_TUNING_MODE::SINGLE:         return types::TuningPatternMode::TPM_SINGLE;
    case LENGTH_TUNING_MODE::DIFF_PAIR:      return types::TuningPatternMode::TPM_DIFF_PAIR;
    case LENGTH_TUNING_MODE::DIFF_PAIR_SKEW: return types::TuningPatternMode::TPM_DIFF_PAIR_SKEW;
 
    default:
        wxCHECK_MSG( false, types::TuningPatternMode::TPM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<LENGTH_TUNING_MODE>" );
    }
}
 
 
template<>
LENGTH_TUNING_MODE FromProtoEnum( types::TuningPatternMode aValue )
{
    switch( aValue )
    {
    case types::TuningPatternMode::TPM_SINGLE:         return LENGTH_TUNING_MODE::SINGLE;
    case types::TuningPatternMode::TPM_DIFF_PAIR:      return LENGTH_TUNING_MODE::DIFF_PAIR;
    case types::TuningPatternMode::TPM_DIFF_PAIR_SKEW: return LENGTH_TUNING_MODE::DIFF_PAIR_SKEW;
 
    default:
    case types::TuningPatternMode::TPM_UNKNOWN:        return LENGTH_TUNING_MODE::SINGLE;
    }
 
    wxCHECK_MSG( false, LENGTH_TUNING_MODE::SINGLE,
                 "Unhandled case in FromProtoEnum<types::TuningPatternMode>" );
}
 
 
 
template<>
types::TuningPatternMeanderSide ToProtoEnum( PNS::MEANDER_SIDE aValue )
{
    switch( aValue )
    {
    case PNS::MEANDER_SIDE_DEFAULT: return types::TuningPatternMeanderSide::TPMS_DEFAULT;
    case PNS::MEANDER_SIDE_LEFT:    return types::TuningPatternMeanderSide::TPMS_LEFT;
    case PNS::MEANDER_SIDE_RIGHT:   return types::TuningPatternMeanderSide::TPMS_RIGHT;
 
    default:
        wxCHECK_MSG( false, types::TuningPatternMeanderSide::TPMS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PNS::MEANDER_SIDE>" );
    }
}
 
 
template<>
PNS::MEANDER_SIDE FromProtoEnum( types::TuningPatternMeanderSide aValue )
{
    switch( aValue )
    {
    case types::TuningPatternMeanderSide::TPMS_DEFAULT: return PNS::MEANDER_SIDE_DEFAULT;
    case types::TuningPatternMeanderSide::TPMS_LEFT:    return PNS::MEANDER_SIDE_LEFT;
    case types::TuningPatternMeanderSide::TPMS_RIGHT:   return PNS::MEANDER_SIDE_RIGHT;
 
    default:
    case types::TuningPatternMeanderSide::TPMS_UNKNOWN: return PNS::MEANDER_SIDE_DEFAULT;
    }
 
    wxCHECK_MSG( false, PNS::MEANDER_SIDE_DEFAULT,
                 "Unhandled case in FromProtoEnum<types::TuningPatternMeanderSide>" );
}
 
template<>
types::TuningPatternCornerStyle ToProtoEnum( PNS::MEANDER_STYLE aValue )
{
    switch( aValue )
    {
    case PNS::MEANDER_STYLE_CHAMFER: return types::TuningPatternCornerStyle::TPCS_CHAMFERED;
    case PNS::MEANDER_STYLE_ROUND:   return types::TuningPatternCornerStyle::TPCS_ROUNDED;
 
    default:
        wxCHECK_MSG( false, types::TuningPatternCornerStyle::TPCS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PNS::MEANDER_STYLE>" );
    }
}
 
 
template<>
PNS::MEANDER_STYLE FromProtoEnum( types::TuningPatternCornerStyle aValue )
{
    switch( aValue )
    {
    case types::TuningPatternCornerStyle::TPCS_CHAMFERED: return PNS::MEANDER_STYLE_CHAMFER;
    case types::TuningPatternCornerStyle::TPCS_ROUNDED:   return PNS::MEANDER_STYLE_ROUND;
 
    default:
    case types::TuningPatternCornerStyle::TPCS_UNKNOWN:   return PNS::MEANDER_STYLE_CHAMFER;
    }
 
    wxCHECK_MSG( false, PNS::MEANDER_STYLE_CHAMFER,
                 "Unhandled case in FromProtoEnum<types::TuningPatternCornerStyle>" );
}
 
template<>
types::TuningPatternStatus ToProtoEnum( PNS::MEANDER_PLACER_BASE::TUNING_STATUS aValue )
{
    switch( aValue )
    {
    case PNS::MEANDER_PLACER_BASE::TOO_SHORT: return types::TuningPatternStatus::TPS_TOO_SHORT;
    case PNS::MEANDER_PLACER_BASE::TOO_LONG:  return types::TuningPatternStatus::TPS_TOO_LONG;
    case PNS::MEANDER_PLACER_BASE::TUNED:     return types::TuningPatternStatus::TPS_TUNED;
 
    default:
        wxCHECK_MSG( false, types::TuningPatternStatus::TPS_UNKNOWN,
                     "Unhandled case in ToProtoEnum<TUNING_STATUS>" );
    }
}
 
 
template<>
PNS::MEANDER_PLACER_BASE::TUNING_STATUS FromProtoEnum( types::TuningPatternStatus aValue )
{
    switch( aValue )
    {
    case types::TuningPatternStatus::TPS_TOO_SHORT: return PNS::MEANDER_PLACER_BASE::TOO_SHORT;
    case types::TuningPatternStatus::TPS_TOO_LONG:  return PNS::MEANDER_PLACER_BASE::TOO_LONG;
    case types::TuningPatternStatus::TPS_TUNED:     return PNS::MEANDER_PLACER_BASE::TUNED;
 
    default:
    case types::TuningPatternStatus::TPS_UNKNOWN:   return PNS::MEANDER_PLACER_BASE::TUNED;
    }
 
    wxCHECK_MSG( false, PNS::MEANDER_PLACER_BASE::TUNED,
                 "Unhandled case in FromProtoEnum<types::TuningPatternStatus>" );
}
 
 
template<>
types::ViaStitchLayout ToProtoEnum( PCB_VIA_STITCH_LAYOUT aValue )
{
    switch( aValue )
    {
    case PCB_VIA_STITCH_LAYOUT::PLAIN:     return types::ViaStitchLayout::VSL_PLAIN;
    case PCB_VIA_STITCH_LAYOUT::STAGGERED: return types::ViaStitchLayout::VSL_STAGGERED;
    case PCB_VIA_STITCH_LAYOUT::POISSON:   return types::ViaStitchLayout::VSL_POISSON;
 
    default:
        wxCHECK_MSG( false, types::ViaStitchLayout::VSL_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PCB_VIA_STITCH_LAYOUT>" );
    }
}
 
 
template<>
PCB_VIA_STITCH_LAYOUT FromProtoEnum( types::ViaStitchLayout aValue )
{
    switch( aValue )
    {
    case types::ViaStitchLayout::VSL_PLAIN:     return PCB_VIA_STITCH_LAYOUT::PLAIN;
    case types::ViaStitchLayout::VSL_STAGGERED: return PCB_VIA_STITCH_LAYOUT::STAGGERED;
    case types::ViaStitchLayout::VSL_POISSON:   return PCB_VIA_STITCH_LAYOUT::POISSON;
 
    default:
    case types::ViaStitchLayout::VSL_UNKNOWN:   return PCB_VIA_STITCH_LAYOUT::PLAIN;
    }
 
    wxCHECK_MSG( false, PCB_VIA_STITCH_LAYOUT::PLAIN,
                 "Unhandled case in FromProtoEnum<types::ViaStitchLayout>" );
}
 
 
template<>
types::ViaStitchMode ToProtoEnum( PCB_VIA_STITCH_MODE aValue )
{
    switch( aValue )
    {
    case PCB_VIA_STITCH_MODE::STITCH: return types::ViaStitchMode::VSM_STITCH;
    case PCB_VIA_STITCH_MODE::GUARD:  return types::ViaStitchMode::VSM_GUARD;
 
    default:
        wxCHECK_MSG( false, types::ViaStitchMode::VSM_UNKNOWN,
                     "Unhandled case in ToProtoEnum<PCB_VIA_STITCH_MODE>" );
    }
}
 
 
template<>
PCB_VIA_STITCH_MODE FromProtoEnum( types::ViaStitchMode aValue )
{
    switch( aValue )
    {
    case types::ViaStitchMode::VSM_STITCH: return PCB_VIA_STITCH_MODE::STITCH;
    case types::ViaStitchMode::VSM_GUARD:  return PCB_VIA_STITCH_MODE::GUARD;
 
    default:
    case types::ViaStitchMode::VSM_UNKNOWN: return PCB_VIA_STITCH_MODE::STITCH;
    }
 
    wxCHECK_MSG( false, PCB_VIA_STITCH_MODE::STITCH,
                 "Unhandled case in FromProtoEnum<types::ViaStitchMode>" );
}
 
 
template<>
types::ViaStackStyle ToProtoEnum( VIA_STACK_STYLE aValue )
{
    switch( aValue )
    {
    case VIA_STACK_STYLE::STACKED:   return types::ViaStackStyle::VSK_STACKED;
    case VIA_STACK_STYLE::STAGGERED: return types::ViaStackStyle::VSK_STAGGERED;
 
    default:
        wxCHECK_MSG( false, types::ViaStackStyle::VSK_UNKNOWN,
                     "Unhandled case in ToProtoEnum<VIA_STACK_STYLE>" );
    }
}
 
 
template<>
VIA_STACK_STYLE FromProtoEnum( types::ViaStackStyle aValue )
{
    switch( aValue )
    {
    case types::ViaStackStyle::VSK_STACKED:   return VIA_STACK_STYLE::STACKED;
    case types::ViaStackStyle::VSK_STAGGERED: return VIA_STACK_STYLE::STAGGERED;
 
    default:
    case types::ViaStackStyle::VSK_UNKNOWN:   return VIA_STACK_STYLE::STACKED;
    }
 
    wxCHECK_MSG( false, VIA_STACK_STYLE::STACKED,
                 "Unhandled case in FromProtoEnum<types::ViaStackStyle>" );
}
 
 
// Adding something new here?  Add it to test_api_enums.cpp!