haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rework bitmap system to load from archived PNGs 

Bitmaps are now identified by an enum class instead of by pointers.
Bitmap loading and caching is now handled by a class in common, and
we no longer compile most bitmaps into the binary, so there is no
longer a bitmaps static library.

Instead, bitmaps are archived to a .tar.gz file which is installed
in ${KICAD_DATA}/resources/images.tar.gz

The source PNGs are checked in to Git as the original CPP files were,
so that people can build without the required dependencies to convert
SVGs to PNGs.

Initial support is also added for dark theme icons, although this
is not yet exposed in the GUI.

Stubs are present for multi-resolution image resources, but this is
not fully-baked yet and could use some refinement.
This commit is contained in:
Jon Evans 2021-03-07 21:59:07 -05:00
parent 4db10d419d
commit 18037e2f65
1644 changed files with 3830 additions and 25120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
3d-viewer/3d_cache/dialogs/panel_prev_3d.cpp
View File

@ -60,14 +60,14 @@ PANEL_PREV_3D::PANEL_PREV_3D( wxWindow* aParent, PCB_BASE_FRAME* aFrame, FOOTPRI
m_selected = -1;
// Set the bitmap of 3D view buttons:
m_bpvTop->SetBitmap( KiBitmap( axis3d_top_xpm ) );
m_bpvFront->SetBitmap( KiBitmap( axis3d_front_xpm ) );
m_bpvBack->SetBitmap( KiBitmap( axis3d_back_xpm ) );
m_bpvLeft->SetBitmap( KiBitmap( axis3d_left_xpm ) );
m_bpvRight->SetBitmap( KiBitmap( axis3d_right_xpm ) );
m_bpvBottom->SetBitmap( KiBitmap( axis3d_bottom_xpm ) );
m_bpvISO->SetBitmap( KiBitmap( ortho_xpm ) );
m_bpUpdate->SetBitmap( KiBitmap( reload_xpm ) );
m_bpvTop->SetBitmap( KiBitmap( BITMAPS::axis3d_top ) );
m_bpvFront->SetBitmap( KiBitmap( BITMAPS::axis3d_front ) );
m_bpvBack->SetBitmap( KiBitmap( BITMAPS::axis3d_back ) );
m_bpvLeft->SetBitmap( KiBitmap( BITMAPS::axis3d_left ) );
m_bpvRight->SetBitmap( KiBitmap( BITMAPS::axis3d_right ) );
m_bpvBottom->SetBitmap( KiBitmap( BITMAPS::axis3d_bottom ) );
m_bpvISO->SetBitmap( KiBitmap( BITMAPS::ortho ) );
m_bpUpdate->SetBitmap( KiBitmap( BITMAPS::reload ) );
// Set the min and max values of spin buttons (mandatory on Linux)
// They are not used, so they are set to min and max 32 bits int values

36
3d-viewer/3d_viewer/3d_menubar.cpp
View File

@ -50,12 +50,12 @@ void EDA_3D_VIEWER::CreateMenuBar()
fileMenu->Add( _( "Export Current View as PNG..." ),
"",
ID_MENU_SCREENCOPY_PNG,
export_png_xpm );
BITMAPS::export_png );
fileMenu->Add( _( "Export Current View as JPEG..." ),
"",
ID_MENU_SCREENCOPY_JPEG,
export_xpm );
BITMAPS::export_file );
fileMenu->AppendSeparator();
fileMenu->AddClose( _( "3D Viewer" ) );
@ -69,7 +69,7 @@ void EDA_3D_VIEWER::CreateMenuBar()
editMenu->Add( _( "Copy 3D Image" ),
"",
ID_TOOL_SCREENCOPY_TOCLIBBOARD,
copy_xpm );
BITMAPS::copy );
//-- View menu -------------------------------------------------------
@ -106,17 +106,17 @@ void EDA_3D_VIEWER::CreateMenuBar()
prefsMenu->Add( _( "Display Options" ), "",
ID_TOOL_SET_VISIBLE_ITEMS,
config_xpm );
BITMAPS::config );
prefsMenu->Add( _( "Raytracing" ), "",
ID_RENDER_CURRENT_VIEW,
tools_xpm,
BITMAPS::tools,
ACTION_MENU::CHECK );
// Render options submenu
ACTION_MENU* optsSubmenu = new ACTION_MENU( false, tool );
optsSubmenu->SetTitle( _( "Render Options" ) );
optsSubmenu->SetIcon( options_3drender_xpm );
optsSubmenu->SetIcon( BITMAPS::options_3drender );
// Material properties submenu
ACTION_MENU* propsSubmenu = new ACTION_MENU( false, tool );
@ -150,42 +150,42 @@ void EDA_3D_VIEWER::CreateMenuBar()
// Color submenu
ACTION_MENU* colorSubmenu = new ACTION_MENU( false, tool );
colorSubmenu->SetTitle( _( "Choose Colors" ) );
colorSubmenu->SetIcon( color_materials_xpm );
colorSubmenu->SetIcon( BITMAPS::color_materials );
colorSubmenu->Add( _( "Background Top Color..." ),
ID_MENU3D_BGCOLOR_TOP,
nullptr );
BITMAPS::INVALID_BITMAP );
colorSubmenu->Add( _( "Background Bottom Color..." ),
ID_MENU3D_BGCOLOR_BOTTOM,
nullptr );
BITMAPS::INVALID_BITMAP );
colorSubmenu->Add( _( "Silkscreen Color..." ),
ID_MENU3D_SILKSCREEN_COLOR,
nullptr );
BITMAPS::INVALID_BITMAP );
colorSubmenu->Add( _( "Solder Mask Color..." ),
ID_MENU3D_SOLDERMASK_COLOR,
nullptr );
BITMAPS::INVALID_BITMAP );
colorSubmenu->Add( _( "Solder Paste Color..." ),
ID_MENU3D_SOLDERPASTE_COLOR,
nullptr );
BITMAPS::INVALID_BITMAP );
colorSubmenu->Add( _( "Copper/Surface Finish Color..." ),
ID_MENU3D_COPPER_COLOR,
nullptr );
BITMAPS::INVALID_BITMAP );
colorSubmenu->Add( _( "Board Body Color..." ),
ID_MENU3D_PCB_BODY_COLOR,
nullptr );
BITMAPS::INVALID_BITMAP );
// Only allow the stackup to be used in the PCB editor, since it isn't editable in the other frames
if( Parent()->IsType( FRAME_PCB_EDITOR ) )
{
colorSubmenu->Add( _( "Get colors from physical stackup" ),
ID_MENU3D_STACKUP_COLORS,
nullptr );
BITMAPS::INVALID_BITMAP );
}
prefsMenu->Add( colorSubmenu );
@ -195,7 +195,7 @@ void EDA_3D_VIEWER::CreateMenuBar()
// Grid submenu
ACTION_MENU* gridSubmenu = new ACTION_MENU( false, tool );
gridSubmenu->SetTitle( _( "3D Grid" ) );
gridSubmenu->SetIcon( grid_xpm );
gridSubmenu->SetIcon( BITMAPS::grid );
gridSubmenu->Add( EDA_3D_ACTIONS::noGrid, ACTION_MENU::CHECK);
gridSubmenu->Add( EDA_3D_ACTIONS::show10mmGrid, ACTION_MENU::CHECK);
@ -206,13 +206,13 @@ void EDA_3D_VIEWER::CreateMenuBar()
prefsMenu->Add( gridSubmenu );
prefsMenu->AppendSeparator();
prefsMenu->Add( _( "Reset to Default Settings" ), ID_MENU3D_RESET_DEFAULTS, tools_xpm );
prefsMenu->Add( _( "Reset to Default Settings" ), ID_MENU3D_RESET_DEFAULTS, BITMAPS::tools );
#ifdef __APPLE__ // Note: will get moved to Apple menu by wxWidgets
prefsMenu->Add( _( "Preferences..." ) + "\tCtrl+,",
_( "Show preferences for all open tools" ),
wxID_PREFERENCES,
preference_xpm );
BITMAPS::preference );
#endif
//-- Menubar -------------------------------------------------------------

8
3d-viewer/3d_viewer/3d_toolbar.cpp
View File

@ -52,21 +52,21 @@ void EDA_3D_VIEWER::ReCreateMainToolbar()
// Set up toolbar
m_mainToolBar->AddTool( ID_RELOAD3D_BOARD, wxEmptyString,
KiScaledBitmap( import3d_xpm, this ), _( "Reload board" ) );
KiScaledBitmap( BITMAPS::import3d, this ), _( "Reload board" ) );
m_mainToolBar->AddScaledSeparator( this );
m_mainToolBar->AddTool( ID_TOOL_SCREENCOPY_TOCLIBBOARD, wxEmptyString,
KiScaledBitmap( copy_xpm, this ),
KiScaledBitmap( BITMAPS::copy, this ),
_( "Copy 3D image to clipboard" ) );
m_mainToolBar->AddScaledSeparator( this );
m_mainToolBar->AddTool( ID_TOOL_SET_VISIBLE_ITEMS, wxEmptyString,
KiScaledBitmap( config_xpm, this ),
KiScaledBitmap( BITMAPS::config, this ),
_( "Set display options, and some layers visibility" ) );
m_mainToolBar->AddScaledSeparator( this );
m_mainToolBar->AddTool( ID_RENDER_CURRENT_VIEW, wxEmptyString,
KiScaledBitmap( render_mode_xpm, this ),
KiScaledBitmap( BITMAPS::render_mode, this ),
_( "Render current view using Raytracing" ), wxITEM_CHECK );
m_mainToolBar->AddScaledSeparator( this );

2
3d-viewer/3d_viewer/eda_3d_viewer.cpp
View File

@ -97,7 +97,7 @@ EDA_3D_VIEWER::EDA_3D_VIEWER( KIWAY *aKiway, PCB_BASE_FRAME *aParent, const wxSt
// Give it an icon
wxIcon icon;
icon.CopyFromBitmap( KiBitmap( icon_3d_xpm ) );
icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_3d ) );
SetIcon( icon );
// Create the status line

102
3d-viewer/3d_viewer/tools/3d_actions.cpp
View File

@ -35,169 +35,169 @@
TOOL_ACTION EDA_3D_ACTIONS::controlActivate( "3DViewer.Control", AS_GLOBAL,
0, "", "", "",
NULL, AF_ACTIVATE ); // No description, it is not supposed to be shown anywhere
BITMAPS::INVALID_BITMAP, AF_ACTIVATE ); // No description, it is not supposed to be shown anywhere
TOOL_ACTION EDA_3D_ACTIONS::pivotCenter( "3DViewer.Control.pivotCenter",
AS_ACTIVE,
' ', "",
_( "Center pivot rotation" ), _( "Center pivot rotation (middle mouse click)" ),
nullptr, AF_NONE, (void*) WXK_SPACE );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) WXK_SPACE );
TOOL_ACTION EDA_3D_ACTIONS::rotateXCW( "3DViewer.Control.rotateXclockwise",
AS_GLOBAL, 0, "",
_( "Rotate X Clockwise" ), _( "Rotate X Clockwise" ),
rotate_cw_x_xpm, AF_NONE, (void*) ROTATION_DIR::X_CW );
BITMAPS::rotate_cw_x, AF_NONE, (void*) ROTATION_DIR::X_CW );
TOOL_ACTION EDA_3D_ACTIONS::rotateXCCW( "3DViewer.Control.rotateXcounterclockwise",
AS_GLOBAL, 0, "",
_( "Rotate X Counterclockwise" ), _( "Rotate X Counterclockwise" ),
rotate_ccw_x_xpm, AF_NONE, (void*) ROTATION_DIR::X_CCW );
BITMAPS::rotate_ccw_x, AF_NONE, (void*) ROTATION_DIR::X_CCW );
TOOL_ACTION EDA_3D_ACTIONS::rotateYCW( "3DViewer.Control.rotateYclockwise",
AS_GLOBAL, 0, "",
_( "Rotate Y Clockwise" ), _( "Rotate Y Clockwise" ),
rotate_cw_y_xpm, AF_NONE, (void*) ROTATION_DIR::Y_CW );
BITMAPS::rotate_cw_y, AF_NONE, (void*) ROTATION_DIR::Y_CW );
TOOL_ACTION EDA_3D_ACTIONS::rotateYCCW( "3DViewer.Control.rotateYcounterclockwise",
AS_GLOBAL, 0, "",
_( "Rotate Y Counterclockwise" ), _( "Rotate Y Counterclockwise" ),
rotate_ccw_y_xpm, AF_NONE, (void*) ROTATION_DIR::Y_CCW );
BITMAPS::rotate_ccw_y, AF_NONE, (void*) ROTATION_DIR::Y_CCW );
TOOL_ACTION EDA_3D_ACTIONS::rotateZCW( "3DViewer.Control.rotateZclockwise",
AS_GLOBAL, 0, "",
_( "Rotate Z Clockwise" ), _( "Rotate Z Clockwise" ),
rotate_cw_z_xpm, AF_NONE, (void*) ROTATION_DIR::Z_CW );
BITMAPS::rotate_cw_z, AF_NONE, (void*) ROTATION_DIR::Z_CW );
TOOL_ACTION EDA_3D_ACTIONS::rotateZCCW( "3DViewer.Control.rotateZcounterclockwise",
AS_GLOBAL, 0, "",
_( "Rotate Z Counterclockwise" ), _( "Rotate Z Counterclockwise" ),
rotate_ccw_z_xpm, AF_NONE, (void*) ROTATION_DIR::Z_CCW );
BITMAPS::rotate_ccw_z, AF_NONE, (void*) ROTATION_DIR::Z_CCW );
TOOL_ACTION EDA_3D_ACTIONS::moveLeft( "3DViewer.Control.moveLeft",
AS_ACTIVE,
WXK_LEFT, "",
_( "Move board Left" ), _( "Move board Left" ),
left_xpm, AF_NONE, (void*) CURSOR_LEFT );
BITMAPS::left, AF_NONE, (void*) CURSOR_LEFT );
TOOL_ACTION EDA_3D_ACTIONS::moveRight( "3DViewer.Control.moveRight",
AS_ACTIVE,
WXK_RIGHT, "",
_( "Move board Right" ), _( "Move board Right" ),
right_xpm, AF_NONE, (void*) CURSOR_RIGHT );
BITMAPS::right, AF_NONE, (void*) CURSOR_RIGHT );
TOOL_ACTION EDA_3D_ACTIONS::moveUp( "3DViewer.Control.moveUp",
AS_ACTIVE,
WXK_UP, "",
_( "Move board Up" ), _( "Move board Up" ),
up_xpm, AF_NONE, (void*) CURSOR_UP );
BITMAPS::up, AF_NONE, (void*) CURSOR_UP );
TOOL_ACTION EDA_3D_ACTIONS::moveDown( "3DViewer.Control.moveDown",
AS_ACTIVE,
WXK_DOWN, "",
_( "Move board Down" ), _( "Move board Down" ),
down_xpm, AF_NONE, (void*) CURSOR_DOWN );
BITMAPS::down, AF_NONE, (void*) CURSOR_DOWN );
TOOL_ACTION EDA_3D_ACTIONS::homeView( "3DViewer.Control.homeView",
AS_ACTIVE,
WXK_HOME, "",
_( "Home view" ), _( "Home view" ),
nullptr, AF_NONE, (void*) WXK_HOME );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) WXK_HOME );
TOOL_ACTION EDA_3D_ACTIONS::resetView( "3DViewer.Control.resetView",
AS_ACTIVE,
'R', "",
_( "Reset view" ), _( "Reset view" ),
nullptr, AF_NONE, (void*) ID_VIEW3D_RESET );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) ID_VIEW3D_RESET );
TOOL_ACTION EDA_3D_ACTIONS::flipView( "3DViewer.Control.flipView",
AS_ACTIVE,
0, "",
_( "Flip Board" ), _( "Flip the board view" ),
flip_board_xpm, AF_NONE, (void*) ID_VIEW3D_FLIP );
BITMAPS::flip_board, AF_NONE, (void*) ID_VIEW3D_FLIP );
TOOL_ACTION EDA_3D_ACTIONS::toggleOrtho( "3DViewer.Control.toggleOrtho",
AS_GLOBAL, 0, "",
_( "Toggle orthographic projection" ), _( "Enable/disable orthographic projection" ),
ortho_xpm );
BITMAPS::ortho );
TOOL_ACTION EDA_3D_ACTIONS::viewFront( "3DViewer.Control.viewFront",
AS_ACTIVE,
'Y', "",
_( "View Front" ), _( "View Front" ),
axis3d_front_xpm, AF_NONE, (void*) ID_VIEW3D_FRONT );
BITMAPS::axis3d_front, AF_NONE, (void*) ID_VIEW3D_FRONT );
TOOL_ACTION EDA_3D_ACTIONS::viewBack( "3DViewer.Control.viewBack",
AS_ACTIVE,
MD_SHIFT + 'Y', "",
_( "View Back" ), _( "View Back" ),
axis3d_back_xpm, AF_NONE, (void*) ID_VIEW3D_BACK );
BITMAPS::axis3d_back, AF_NONE, (void*) ID_VIEW3D_BACK );
TOOL_ACTION EDA_3D_ACTIONS::viewLeft( "3DViewer.Control.viewLeft",
AS_ACTIVE,
MD_SHIFT + 'X', "",
_( "View Left" ), _( "View Left" ),
axis3d_left_xpm, AF_NONE, (void*) ID_VIEW3D_LEFT );
BITMAPS::axis3d_left, AF_NONE, (void*) ID_VIEW3D_LEFT );
TOOL_ACTION EDA_3D_ACTIONS::viewRight( "3DViewer.Control.viewRight",
AS_ACTIVE,
'X', "",
_( "View Right" ), _( "View Right" ),
axis3d_right_xpm, AF_NONE, (void*) ID_VIEW3D_RIGHT );
BITMAPS::axis3d_right, AF_NONE, (void*) ID_VIEW3D_RIGHT );
TOOL_ACTION EDA_3D_ACTIONS::viewTop( "3DViewer.Control.viewTop",
AS_ACTIVE,
'Z', "",
_( "View Top" ), _( "View Top" ),
axis3d_top_xpm, AF_NONE, (void*) ID_VIEW3D_TOP );
BITMAPS::axis3d_top, AF_NONE, (void*) ID_VIEW3D_TOP );
TOOL_ACTION EDA_3D_ACTIONS::viewBottom( "3DViewer.Control.viewBottom",
AS_ACTIVE,
MD_SHIFT + 'Z', "",
_( "View Bottom" ), _( "View Bottom" ),
axis3d_bottom_xpm, AF_NONE, (void*) ID_VIEW3D_BOTTOM );
BITMAPS::axis3d_bottom, AF_NONE, (void*) ID_VIEW3D_BOTTOM );
TOOL_ACTION EDA_3D_ACTIONS::noGrid( "3DViewer.Control.noGrid",
AS_GLOBAL, 0, "",
_( "No 3D Grid" ), _( "No 3D Grid" ),
nullptr, AF_NONE, (void*) GRID3D_TYPE::NONE );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) GRID3D_TYPE::NONE );
TOOL_ACTION EDA_3D_ACTIONS::show10mmGrid( "3DViewer.Control.show10mmGrid",
AS_GLOBAL, 0, "",
_( "3D Grid 10mm" ), _( "3D Grid 10mm" ),
nullptr, AF_NONE, (void*) GRID3D_TYPE::GRID_10MM );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) GRID3D_TYPE::GRID_10MM );
TOOL_ACTION EDA_3D_ACTIONS::show5mmGrid( "3DViewer.Control.show5mmGrid",
AS_GLOBAL, 0, "",
_( "3D Grid 5mm" ), _( "3D Grid 5mm" ),
nullptr, AF_NONE, (void*) GRID3D_TYPE::GRID_5MM );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) GRID3D_TYPE::GRID_5MM );
TOOL_ACTION EDA_3D_ACTIONS::show2_5mmGrid( "3DViewer.Control.show2_5mmGrid",
AS_GLOBAL, 0, "",
_( "3D Grid 2.5mm" ), _( "3D Grid 2.5mm" ),
nullptr, AF_NONE, (void*) GRID3D_TYPE::GRID_2P5MM );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) GRID3D_TYPE::GRID_2P5MM );
TOOL_ACTION EDA_3D_ACTIONS::show1mmGrid( "3DViewer.Control.show1mmGrid",
AS_GLOBAL, 0, "",
_( "3D Grid 1mm" ), _( "3D Grid 1mm" ),
nullptr, AF_NONE, (void*) GRID3D_TYPE::GRID_1MM );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) GRID3D_TYPE::GRID_1MM );
TOOL_ACTION EDA_3D_ACTIONS::materialNormal( "3DViewer.Control.materialNormal",
AS_ACTIVE,
0, "",
_( "Use All Properties" ), _( "Use all material properties from each 3D model file" ),
nullptr, AF_NONE, (void*) MATERIAL_MODE::NORMAL );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) MATERIAL_MODE::NORMAL );
TOOL_ACTION EDA_3D_ACTIONS::materialDiffuse( "3DViewer.Control.materialDiffuse",
AS_ACTIVE,
0, "",
_( "Use Diffuse Only" ), _( "Use only the diffuse color property from model 3D model file" ),
nullptr, AF_NONE, (void*) MATERIAL_MODE::DIFFUSE_ONLY );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) MATERIAL_MODE::DIFFUSE_ONLY );
TOOL_ACTION EDA_3D_ACTIONS::materialCAD( "3DViewer.Control.materialCAD",
AS_ACTIVE,
0, "",
_( "CAD Color Style" ),_( "Use a CAD color style based on the diffuse color of the material" ),
nullptr, AF_NONE, (void*) MATERIAL_MODE::CAD_MODE );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) MATERIAL_MODE::CAD_MODE );
TOOL_ACTION EDA_3D_ACTIONS::rotate45axisZ( "3DViewer.Control.rotate45axisZ",
AS_ACTIVE,
@ -208,108 +208,108 @@ TOOL_ACTION EDA_3D_ACTIONS::attributesTHT( "3DViewer.Control.attributesTHT",
AS_ACTIVE,
'T', "",
_( "Toggle Through Hole 3D models" ), _( "Toggle 3D models with 'Through hole' attribute" ),
nullptr, AF_NONE, (void*) FL_FP_ATTRIBUTES_NORMAL );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_FP_ATTRIBUTES_NORMAL );
TOOL_ACTION EDA_3D_ACTIONS::attributesSMD( "3DViewer.Control.attributesSMD",
AS_ACTIVE,
'S', "",
_( "Toggle SMD 3D models" ), _( "Toggle 3D models with 'Surface mount' attribute" ),
nullptr, AF_NONE, (void*) FL_FP_ATTRIBUTES_NORMAL_INSERT );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_FP_ATTRIBUTES_NORMAL_INSERT );
TOOL_ACTION EDA_3D_ACTIONS::attributesVirtual( "3DViewer.Control.attributesVirtual",
AS_ACTIVE,
'V', "",
_( "Toggle Virtual 3D models" ), _( "Toggle 3D models with 'Virtual' attribute" ),
nullptr, AF_NONE, (void*) FL_FP_ATTRIBUTES_VIRTUAL );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_FP_ATTRIBUTES_VIRTUAL );
TOOL_ACTION EDA_3D_ACTIONS::showBoundingBoxes( "3DViewer.Control.showBoundingBoxes",
AS_GLOBAL, 0, "",
_( "Show Model Bounding Boxes" ), _( "Show Model Bounding Boxes" ),
ortho_xpm, AF_NONE, (void*) FL_RENDER_OPENGL_SHOW_MODEL_BBOX );
BITMAPS::ortho, AF_NONE, (void*) FL_RENDER_OPENGL_SHOW_MODEL_BBOX );
TOOL_ACTION EDA_3D_ACTIONS::renderShadows( "3DViewer.Control.renderShadows",
AS_GLOBAL, 0, "",
_( "Render Shadows" ), _( "Render Shadows" ),
nullptr, AF_NONE, (void*) FL_RENDER_RAYTRACING_SHADOWS );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_RENDER_RAYTRACING_SHADOWS );
TOOL_ACTION EDA_3D_ACTIONS::proceduralTextures( "3DViewer.Control.proceduralTextures",
AS_GLOBAL, 0, "",
_( "Procedural Textures" ), _( "Apply procedural textures to materials (slow)" ),
nullptr, AF_NONE, (void*) FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES );
TOOL_ACTION EDA_3D_ACTIONS::addFloor( "3DViewer.Control.addFloor",
AS_GLOBAL, 0, "",
_( "Add Floor" ), _( "Adds a floor plane below the board (slow)"),
nullptr, AF_NONE, (void*) FL_RENDER_RAYTRACING_BACKFLOOR );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_RENDER_RAYTRACING_BACKFLOOR );
TOOL_ACTION EDA_3D_ACTIONS::showRefractions( "3DViewer.Control.showRefractions",
AS_GLOBAL, 0, "",
_( "Refractions" ), _( "Render materials with refractive properties on final render (slow)" ),
nullptr, AF_NONE, (void*) FL_RENDER_RAYTRACING_REFRACTIONS );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_RENDER_RAYTRACING_REFRACTIONS );
TOOL_ACTION EDA_3D_ACTIONS::showReflections( "3DViewer.Control.showReflections",
AS_GLOBAL, 0, "",
_( "Reflections" ), _( "Render materials with reflective properties on final render (slow)" ),
nullptr, AF_NONE, (void*) FL_RENDER_RAYTRACING_REFLECTIONS );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_RENDER_RAYTRACING_REFLECTIONS );
TOOL_ACTION EDA_3D_ACTIONS::antiAliasing( "3DViewer.Control.antiAliasing",
AS_GLOBAL, 0, "",
_( "Anti-aliasing" ), _( "Render with improved quality on final render (slow)" ),
nullptr, AF_NONE, (void*) FL_RENDER_RAYTRACING_ANTI_ALIASING );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_RENDER_RAYTRACING_ANTI_ALIASING );
TOOL_ACTION EDA_3D_ACTIONS::postProcessing( "3DViewer.Control.postProcessing",
AS_GLOBAL, 0, "",
_( "Post-processing" ),
_( "Apply Screen Space Ambient Occlusion and Global Illumination reflections on final render (slow)"),
nullptr, AF_NONE, (void*) FL_RENDER_RAYTRACING_POST_PROCESSING );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_RENDER_RAYTRACING_POST_PROCESSING );
TOOL_ACTION EDA_3D_ACTIONS::toggleRealisticMode( "3DViewer.Control.toggleRealisticMode",
AS_GLOBAL, 0, "",
_( "Toggle realistic mode" ), _( "Toggle realistic mode" ),
nullptr, AF_NONE, (void*) FL_USE_REALISTIC_MODE );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_USE_REALISTIC_MODE );
TOOL_ACTION EDA_3D_ACTIONS::toggleBoardBody( "3DViewer.Control.toggleBoardBody",
AS_GLOBAL, 0, "",
_( "Toggle board body display" ), _( "Toggle board body display" ),
nullptr, AF_NONE, (void*) FL_SHOW_BOARD_BODY );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SHOW_BOARD_BODY );
TOOL_ACTION EDA_3D_ACTIONS::showAxis( "3DViewer.Control.showAxis",
AS_GLOBAL, 0, "",
_( "Show 3D Axis" ), _( "Show 3D Axis" ),
axis3d_front_xpm, AF_NONE, (void*) FL_AXIS );
BITMAPS::axis3d_front, AF_NONE, (void*) FL_AXIS );
TOOL_ACTION EDA_3D_ACTIONS::toggleZones( "3DViewer.Control.toggleZones",
AS_GLOBAL, 0, "",
_( "Toggle zone display" ), _( "Toggle zone display" ),
nullptr, AF_NONE, (void*) FL_ZONE );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_ZONE );
TOOL_ACTION EDA_3D_ACTIONS::toggleAdhesive( "3DViewer.Control.toggleAdhesive",
AS_GLOBAL, 0, "",
_( "Toggle adhesive display" ), _( "Toggle display of adhesive layers" ),
nullptr, AF_NONE, (void*) FL_ADHESIVE );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_ADHESIVE );
TOOL_ACTION EDA_3D_ACTIONS::toggleSilk( "3DViewer.Control.toggleSilk",
AS_GLOBAL, 0, "",
_( "Toggle silkscreen display" ), _( "Toggle display of silkscreen layers" ),
nullptr, AF_NONE, (void*) FL_SILKSCREEN );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SILKSCREEN );
TOOL_ACTION EDA_3D_ACTIONS::toggleSolderMask( "3DViewer.Control.toggleSolderMask",
AS_GLOBAL, 0, "",
_( "Toggle solder mask display" ), _( "Toggle display of solder mask layers" ),
nullptr, AF_NONE, (void*) FL_SOLDERMASK );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SOLDERMASK );
TOOL_ACTION EDA_3D_ACTIONS::toggleSolderPaste( "3DViewer.Control.toggleSolderPaste",
AS_GLOBAL, 0, "",
_( "Toggle solder paste display" ), _( "Toggle display of solder paste layers" ),
nullptr, AF_NONE, (void*) FL_SOLDERPASTE );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SOLDERPASTE );
TOOL_ACTION EDA_3D_ACTIONS::toggleComments( "3DViewer.Control.toggleComments",
AS_GLOBAL, 0, "",
_( "Toggle comments display" ), _( "Toggle display of comments and drawings layers" ),
nullptr, AF_NONE, (void*) FL_COMMENTS );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_COMMENTS );
TOOL_ACTION EDA_3D_ACTIONS::toggleECO( "3DViewer.Control.toggleECO",
AS_GLOBAL, 0, "",
_( "Toggle ECO display" ), _( "Toggle display of ECO layers" ),
nullptr, AF_NONE, (void*) FL_ECO );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_ECO );

76
CMakeModules/BuildSteps/CreateBitmapInfo.cmake Normal file
View File

@ -0,0 +1,76 @@
# This program source code file is part of KiCad, a free EDA CAD application.
#
# Copyright (C) 2021 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 <http://www.gnu.org/licenses/>.
# Creates the bitmap_info header file from a temporary file created by bitmaps_png/CMakeLists.txt
# Invoke with the following parameters:
# inputFile: Path to the temporary file containing the contents of the bitmap info list
# outputFile: Path to write the header to
set( header_content "
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2021 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 <http://www.gnu.org/licenses/>.
*/
/**
* This file is auto-generated by CMake when MAINTAIN_PNGS is on. Do not edit by hand!
*/
#ifndef KICAD_BITMAP_INFO_H
#define KICAD_BITMAP_INFO_H
#include <vector>
#include <bitmaps/bitmaps_list.h>
struct BITMAP_INFO
{
BITMAPS id;
wxString filename;
int height;
wxString theme;
};
const std::vector<BITMAP_INFO> g_BitmapInfo = {
" )
set( footer_content "
};
#endif // KICAD_BITMAP_INFO_H
" )
file( READ "${inputFile}" file_content )
file( WRITE "${outputFile}" "${header_content}" )
file( APPEND "${outputFile}" "${file_content}" )
file( APPEND "${outputFile}" "${footer_content}" )

12
bitmap2component/bitmap2cmp_gui.cpp
View File

@ -167,17 +167,17 @@ BM2CMP_FRAME::BM2CMP_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
//Set icon for aspect ratio
m_AspectRatioLocked = true;
m_AspectRatio = 1;
m_AspectRatioLockButton->SetBitmap( KiBitmap( locked_xpm ) );
m_AspectRatioLockButton->SetBitmap( KiBitmap( BITMAPS::locked ) );
// Give an icon
wxIcon icon;
wxIconBundle icon_bundle;
icon.CopyFromBitmap( KiBitmap( icon_bitmap2component_xpm ) );
icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_bitmap2component ) );
icon_bundle.AddIcon( icon );
icon.CopyFromBitmap( KiBitmap( icon_bitmap2component_32_xpm ) );
icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_bitmap2component_32 ) );
icon_bundle.AddIcon( icon );
icon.CopyFromBitmap( KiBitmap( icon_bitmap2component_16_xpm ) );
icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_bitmap2component_16 ) );
icon_bundle.AddIcon( icon );
SetIcons( icon_bundle );
@ -583,7 +583,7 @@ void BM2CMP_FRAME::ToggleAspectRatioLock( wxCommandEvent& event )
if( m_AspectRatioLocked )
{
m_AspectRatioLockButton->SetBitmap( KiBitmap( locked_xpm ) );
m_AspectRatioLockButton->SetBitmap( KiBitmap( BITMAPS::locked ) );
//Force display update when aspect ratio is locked
auto fakeEvent = wxCommandEvent();
OnSizeChangeX( fakeEvent );
@ -591,7 +591,7 @@ void BM2CMP_FRAME::ToggleAspectRatioLock( wxCommandEvent& event )
else
{
m_AspectRatioLockButton->SetBitmap( KiBitmap( unlocked_xpm ) );
m_AspectRatioLockButton->SetBitmap( KiBitmap( BITMAPS::unlocked ) );
}
}

184
bitmaps_png/CMakeLists.txt
View File

@ -54,6 +54,10 @@ option( MAINTAIN_PNGS
# Used Only to maintain PNG files (and therefore to recreate .cpp files)
# The png2cpp creates files with native End of Line format.
set( THEMES
light
dark )
# Plan for three sizes of bitmaps:
# SMALL - for menus - 16 x 16
# MID - for toolbars - 24 x 24
@ -200,9 +204,9 @@ set( BMAPS_MID
cut
datasheet
delete_association
delete_cursor
delete_gerber
delete_sheet
delete
directory
directory_browser
directory_open
@ -231,6 +235,7 @@ set( BMAPS_MID
export_cmp
export_dsn
export_idf
export_file
export_footprint_names
export_module
export_part
@ -238,7 +243,6 @@ set( BMAPS_MID
export_step
export_svg
export_to_pcbnew
export
fabrication
file_bom
file_drl
@ -587,8 +591,12 @@ set( TMP_DIR "${CMAKE_CURRENT_BINARY_DIR}/tmp" )
# true to generate log files, false to build icon files only
# generate logs is useful only if you have problems
set( CREATE_LOG_FILES false )
set( CREATE_LOG_FILES true )
set( BITMAP_INFO_FILE "${CMAKE_SOURCE_DIR}/include/bitmaps/bitmap_info.h" )
set( BITMAP_INFO_TEMP_FILE ${TMP_DIR}/bitmap_info_contents.h )
set( ALL_PNGS "" )
function( svg2png inputFile outFile pngWidth pngHeight )
#message( "svg2png( inputFile: ${inputFile} outFile: ${outFile} pngWidth: ${pngWidth} pngHeight: ${pngHeight})")
@ -599,8 +607,6 @@ function( svg2png inputFile outFile pngWidth pngHeight )
set( logfile "null" )
endif()
get_filename_component( bmn ${inputFile} NAME_WE )
add_custom_command(
OUTPUT ${outFile}
# this Inkscape command line is for old Inkscape version < 1.0
@ -626,8 +632,6 @@ function( png2png inputFile outFile )
set( logfile "null" )
endif()
get_filename_component( bmn ${inputFile} NAME_WE )
add_custom_command(
OUTPUT ${outFile}
@ -660,35 +664,93 @@ endfunction()
# and and puts them into cpp_${pngHeight} and png_${pngHeight} directories.
function( bitmap_dir pngWidth pngHeight bmapList theme )
set( cppDir "${CMAKE_CURRENT_SOURCE_DIR}/cpp_${pngHeight}" )
set( pngDir "${CMAKE_CURRENT_SOURCE_DIR}/png_${pngHeight}" )
set( pngDir "${CMAKE_CURRENT_SOURCE_DIR}/png" )
file( MAKE_DIRECTORY ${pngDir} ${cppDir} )
file( MAKE_DIRECTORY ${pngDir} )
#file( REMOVE_RECURSE ${TMP_DIR} )
file( MAKE_DIRECTORY ${TMP_DIR} )
#svg2png( inputFile outFile pngWidth pngHeight )
foreach( theme ${THEMES} )
if( NOT ${theme} STREQUAL "light" )
set( themeTag "_${theme}" )
else()
set( themeTag "" )
endif()
foreach( bmn ${bmapList} )
set( svgFile "${CMAKE_CURRENT_SOURCE_DIR}/sources/${theme}/${bmn}.svg" )
set( pngFile "${pngDir}/${bmn}.png" )
set( cppFile "${cppDir}/${bmn}.cpp" )
set( tmpFile "${TMP_DIR}/${bmn}_${pngHeight}.png" )
foreach( bmn ${bmapList} )
#svg2png( inputFile outFile pngWidth pngHeight )
svg2png( ${svgFile} ${tmpFile} ${pngWidth} ${pngHeight} )
set( svgFile "${CMAKE_CURRENT_SOURCE_DIR}/sources/${theme}/${bmn}.svg" )
set( pngFile "${bmn}${themeTag}_${pngHeight}.png" )
set( pngPath "${pngDir}/${pngFile}" )
set( tmpFile "${TMP_DIR}/${pngFile}" )
#png2png( inputFile outFile )
png2png( ${tmpFile} ${pngFile} )
if( NOT EXISTS ${svgFile} )
continue()
endif()
#png2cpp( inputFile outFile )
png2cpp( ${pngFile} ${cppFile} )
#svg2png( inputFile outFile pngWidth pngHeight )
svg2png( ${svgFile} ${tmpFile} ${pngWidth} ${pngHeight} )
#png2png( inputFile outFile )
png2png( ${tmpFile} ${pngPath} )
set( bitmapInfo " { BITMAPS::${bmn}, wxT( \"${pngFile}\" ), "
"${pngHeight}, wxT( \"${theme}\" ) },\n" )
file( APPEND ${BITMAP_INFO_TEMP_FILE} ${bitmapInfo} )
list( APPEND ALL_PNGS ${pngPath} )
endforeach()
endforeach()
set( ALL_PNGS ${ALL_PNGS} PARENT_SCOPE )
endfunction()
# Creates the bitmap_info header file after creating all PNGs
function( generate_bitmap_info inputFile outputFile )
add_custom_command(
OUTPUT ${outputFile}
COMMAND ${CMAKE_COMMAND} -DinputFile=${inputFile} -DoutputFile=${outputFile}
-P ${CMAKE_MODULE_PATH}/BuildSteps/CreateBitmapInfo.cmake
DEPENDS ${inputFile} ${CMAKE_MODULE_PATH}/BuildSteps/CreateBitmapInfo.cmake
COMMENT "Creating ${outputFile}"
VERBATIM
)
endfunction()
include( FindUnixCommands )
set( BITMAP_ARCHIVE_PATH ${CMAKE_BINARY_DIR}/resources/images.tar.gz )
if( NOT ALL_PNGS )
file( GLOB_RECURSE ALL_PNGS ${CMAKE_CURRENT_SOURCE_DIR}/png/*.png )
endif()
if( MINGW )
# This seems like a huge hack, but I can't find a better way. If anyone else does, please
# feel free to replace this with it...
file( TO_CMAKE_PATH "${BITMAP_ARCHIVE_PATH}" TAR_OUTPUT_FILE )
string( REGEX REPLACE "^([a-zA-Z]):/" "/\\1/" TAR_OUTPUT_FILE "${TAR_OUTPUT_FILE}" )
else()
set( TAR_OUTPUT_FILE "${BITMAP_ARCHIVE_PATH}" )
endif()
add_custom_target( bitmap_archive ALL
COMMAND ${TAR} cfz "${TAR_OUTPUT_FILE}" .
DEPENDS ${ALL_PNGS}
BYPRODUCTS ${BITMAP_ARCHIVE_PATH}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/png
COMMENT "Creating image archive ${TAR_OUTPUT_FILE}"
VERBATIM
)
install( FILES ${BITMAP_ARCHIVE_PATH}
DESTINATION ${KICAD_DATA}/resources
)
if( MAINTAIN_PNGS )
# Inkscape is required to convert SVG files to PNG files.
@ -731,6 +793,8 @@ if( MAINTAIN_PNGS )
message( STATUS "Creating icons for ${KICAD_ICON_THEME} theme" )
file( WRITE ${BITMAP_INFO_TEMP_FILE} )
# these 3 cmake commands for each desired bitmap size set, repeat as needed:
bitmap_dir( 16 16 "${BMAPS_SMALL}" ${KICAD_ICON_THEME} )
@ -748,66 +812,18 @@ if( MAINTAIN_PNGS )
bitmap_dir( 48 48 "${BMAPS_BIG}" ${KICAD_ICON_THEME} )
generate_bitmap_info( ${BITMAP_INFO_TEMP_FILE} ${BITMAP_INFO_FILE} )
add_custom_target( generate_pngs ALL
DEPENDS ${ALL_PNGS}
COMMENT "Creating PNGs from SVGs"
)
add_custom_target( bitmap_info ALL
DEPENDS ${BITMAP_INFO_FILE}
COMMENT "Creating bitmap_info header"
)
add_dependencies( bitmap_archive generate_pngs bitmap_info )
endif( MAINTAIN_PNGS )
#message( "CPP_LIST: ${CPP_LIST}" )
# a target with no output, just so changes get built
#add_custom_target( make_cpp_files ALL DEPENDS ${CPP_LIST} )
set( CPP_LIST "" )
foreach( bmn ${BMAPS_SMALL} )
#message( "library add cpp_16/${bmn}.cpp" )
list( APPEND CPP_LIST cpp_16/${bmn}.cpp )
endforeach()
foreach( bmn ${BMAPS_MID} )
#message( "library add cpp_24/${bmn}.cpp" )
list( APPEND CPP_LIST cpp_24/${bmn}.cpp )
endforeach()
foreach( bmn ${BMAPS_24} )
#message( "library add cpp_24/${bmn}.cpp" )
list( APPEND CPP_LIST cpp_24/${bmn}.cpp )
endforeach()
foreach( bmn ${BMAPS_32} )
#message( "library add cpp_32/${bmn}.cpp" )
list( APPEND CPP_LIST cpp_32/${bmn}.cpp )
endforeach()
foreach( bmn ${BMAPS_BIG} )
#message( "library add cpp_48/${bmn}.cpp" )
list( APPEND CPP_LIST cpp_48/${bmn}.cpp )
endforeach()
foreach( bmn ${BMAPS_OTHER} )
#message( "library add cpp_other/${bmn}.cpp" )
list( APPEND CPP_LIST cpp_other/${bmn}.cpp )
endforeach()
# Commented out to prevent name smashing in the library
# Uncomment to regenerate for icon sets
# TODO: make this build automatic
#foreach( bmn ${BMAPS_22} )
#message( "library add cpp_22/${bmn}.cpp" )
# list( APPEND CPP_LIST cpp_22/${bmn}.cpp )
#endforeach()
#foreach( bmn ${BMAPS_64} )
#message( "library add cpp_64/${bmn}.cpp" )
# list( APPEND CPP_LIST cpp_64/${bmn}.cpp )
#endforeach()
#foreach( bmn ${BMAPS_128} )
#message( "library add cpp_128/${bmn}.cpp" )
# list( APPEND CPP_LIST cpp_128/${bmn}.cpp )
#endforeach()
#add_library( bitmaps SHARED ${CPP_LIST} )
add_library( bitmaps STATIC ${CPP_LIST} )
target_include_directories( bitmaps PUBLIC
include
)

38
bitmaps_png/cpp_16/icon_bitmap2component_16.cpp
View File

@ -1,38 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x01, 0x4a, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x95, 0x53, 0xcb, 0x4a, 0xc3,
0x40, 0x14, 0x9d, 0x9f, 0x70, 0x51, 0x75, 0x21, 0x85, 0xae, 0xc5, 0xad, 0x3f, 0x21, 0x88, 0x04,
0x8a, 0x8b, 0x56, 0x31, 0x52, 0x4d, 0xb0, 0x1b, 0x77, 0x8a, 0x20, 0x22, 0xe8, 0x4a, 0x10, 0x7c,
0xa0, 0x60, 0x36, 0x6e, 0xf2, 0x18, 0x29, 0x4d, 0x49, 0x93, 0x49, 0x6c, 0x8b, 0xf5, 0x8f, 0xac,
0xb8, 0x70, 0x71, 0x9d, 0x9b, 0x74, 0x42, 0x62, 0x34, 0x69, 0x16, 0x87, 0x99, 0xcc, 0x9d, 0xf3,
0xb8, 0x77, 0x08, 0x71, 0x1c, 0x67, 0xce, 0xf3, 0x3c, 0x8b, 0x63, 0xc2, 0x01, 0x33, 0x62, 0x62,
0x59, 0x96, 0x4d, 0x29, 0xad, 0x90, 0x29, 0x19, 0xca, 0xc0, 0x34, 0x4d, 0x50, 0x14, 0x05, 0x0c,
0xc3, 0xe8, 0xa2, 0xc0, 0x07, 0x63, 0xac, 0x34, 0x19, 0x57, 0xe4, 0x12, 0x51, 0x10, 0x22, 0xc9,
0xd5, 0xf7, 0x7d, 0xbe, 0x67, 0xe0, 0xba, 0x2e, 0x48, 0x92, 0x84, 0x8e, 0x20, 0x35, 0x76, 0x05,
0x39, 0x04, 0x49, 0x92, 0x8a, 0x9c, 0x37, 0x65, 0x15, 0x56, 0xcf, 0xec, 0xd4, 0x79, 0x61, 0x02,
0x04, 0x3a, 0xaf, 0xd5, 0x9b, 0x50, 0x3d, 0xea, 0x81, 0xfa, 0x34, 0xc8, 0x0a, 0xe4, 0x25, 0x40,
0xe7, 0x7d, 0xde, 0xf3, 0xc9, 0xe3, 0x0b, 0x5c, 0x9b, 0x41, 0xa6, 0x9e, 0x49, 0xb0, 0x21, 0xb7,
0xa3, 0x9e, 0x5b, 0x87, 0xa1, 0x73, 0x62, 0x60, 0x7f, 0x82, 0xfc, 0x57, 0x40, 0xf2, 0x4e, 0x2b,
0x9f, 0x9c, 0x49, 0x20, 0xa6, 0xad, 0xeb, 0x7a, 0xd8, 0x73, 0xed, 0xb8, 0x07, 0x57, 0x86, 0x9f,
0x22, 0x74, 0x1c, 0x96, 0x9f, 0x00, 0x9d, 0x71, 0xda, 0x38, 0xb0, 0xf9, 0xd3, 0x77, 0xa8, 0x9d,
0x8f, 0xe1, 0xb9, 0x1b, 0x89, 0x1c, 0x68, 0x03, 0x58, 0xe4, 0x67, 0xc9, 0x59, 0xc4, 0x02, 0xeb,
0xdb, 0x6a, 0xec, 0x2c, 0xc8, 0x02, 0x2b, 0x97, 0x63, 0xa8, 0xdf, 0x8d, 0x60, 0x61, 0xfa, 0xbd,
0x7c, 0xf1, 0x06, 0x76, 0x9f, 0xa5, 0x05, 0x7e, 0x3b, 0x17, 0x61, 0xeb, 0x61, 0x18, 0x0b, 0x7c,
0x46, 0xce, 0x8d, 0x99, 0xc9, 0x08, 0x6c, 0xe5, 0x9e, 0x06, 0x5f, 0x84, 0x3b, 0xb3, 0xa6, 0xbc,
0x07, 0xea, 0x4d, 0x07, 0xda, 0xbc, 0xc7, 0x32, 0xb8, 0xa5, 0xc1, 0x2b, 0xd1, 0x34, 0x6d, 0x89,
0x3f, 0xd5, 0x88, 0x27, 0xf9, 0x2e, 0xf1, 0x47, 0xe2, 0xdd, 0x3e, 0x7f, 0xb5, 0xca, 0x0f, 0x8c,
0xc6, 0xe6, 0xee, 0x40, 0x23, 0xf4, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE icon_bitmap2component_16_xpm[1] = {{ png, sizeof( png ), "icon_bitmap2component_16_xpm" }};
//EOF

35
bitmaps_png/cpp_16/icon_eeschema_16.cpp
View File

@ -1,35 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x01, 0x18, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x70, 0x36, 0x37, 0x17,
0x0f, 0x0e, 0xf4, 0xbf, 0x6c, 0x65, 0x69, 0xf9, 0xcf, 0xd8, 0xd8, 0xf8, 0x3f, 0x31, 0x18, 0xa4,
0x36, 0x38, 0xc0, 0xf7, 0x12, 0x48, 0x2f, 0x03, 0x88, 0xd1, 0x54, 0x53, 0xfa, 0xff, 0xee, 0x85,
0x03, 0xff, 0x9f, 0x5e, 0x3f, 0x8e, 0x81, 0x41, 0x1a, 0x90, 0xf9, 0xb7, 0x35, 0xa3, 0xff, 0x5f,
0xd1, 0x8c, 0xfc, 0x5f, 0xab, 0xe7, 0xf2, 0x3f, 0xc5, 0xd2, 0xe5, 0x03, 0x03, 0xc8, 0x34, 0x5c,
0x9a, 0x61, 0x06, 0x20, 0x63, 0x90, 0x01, 0x30, 0x43, 0xac, 0x8d, 0x4d, 0xff, 0x33, 0xa0, 0xdb,
0x80, 0x8c, 0x1f, 0x5c, 0x3a, 0x8c, 0xd5, 0x05, 0x30, 0x0c, 0x92, 0x83, 0x1b, 0xf0, 0xe4, 0xda,
0xb1, 0xff, 0x21, 0x41, 0xfe, 0x60, 0x0c, 0x62, 0xdf, 0x3c, 0xb3, 0xf7, 0x7f, 0x7c, 0x74, 0xf8,
0xff, 0xf8, 0x98, 0x08, 0xbc, 0xae, 0x83, 0x1b, 0x70, 0xff, 0xe2, 0x21, 0xb8, 0x33, 0x4f, 0xee,
0xdd, 0xf0, 0x3f, 0xc0, 0xcf, 0xfb, 0x7f, 0x43, 0x55, 0xf1, 0xff, 0xc7, 0x57, 0x8f, 0x92, 0x6e,
0x80, 0xab, 0xb3, 0xd3, 0xff, 0x59, 0x93, 0x3a, 0x70, 0x6a, 0xc4, 0x30, 0xc0, 0xdb, 0xd3, 0xfd,
0xbf, 0x97, 0x87, 0x1b, 0xdc, 0x80, 0xb6, 0xfa, 0x0a, 0x82, 0x9a, 0xf1, 0xba, 0xc0, 0xdd, 0xcd,
0x05, 0xee, 0x82, 0x07, 0x0d, 0x13, 0xc9, 0x0f, 0x83, 0x75, 0x41, 0xe9, 0xe0, 0xd0, 0x26, 0xca,
0x00, 0xf4, 0x58, 0xb8, 0x55, 0xdd, 0x03, 0x8f, 0x2e, 0xa2, 0x0c, 0x40, 0x89, 0x7f, 0xa0, 0xb3,
0x91, 0xe3, 0x9b, 0x64, 0x03, 0x08, 0x25, 0x65, 0x94, 0x84, 0x44, 0x6e, 0x52, 0xbe, 0x0c, 0x4b,
0xca, 0xc1, 0x81, 0xbe, 0x17, 0x9b, 0xaa, 0x4b, 0xfe, 0xdf, 0x39, 0x4f, 0x7c, 0x66, 0x02, 0x69,
0xae, 0xd1, 0x77, 0x05, 0x65, 0xa6, 0xf7, 0x0c, 0x56, 0x56, 0x56, 0x62, 0x20, 0x43, 0xac, 0xad,
0xac, 0x88, 0xce, 0xce, 0x20, 0xb5, 0xc1, 0x81, 0x7e, 0x17, 0x40, 0x7a, 0x01, 0x28, 0xb5, 0xaa,
0x32, 0xdd, 0xe9, 0x73, 0xb5, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60,
0x82,
};
const BITMAP_OPAQUE icon_eeschema_16_xpm[1] = {{ png, sizeof( png ), "icon_eeschema_16_xpm" }};
//EOF

31
bitmaps_png/cpp_16/icon_gerbview_16.cpp
View File

@ -1,31 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0xd9, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x75, 0x8e, 0x3b, 0x0a, 0x02,
0x31, 0x18, 0x84, 0x7f, 0x2c, 0x3c, 0x83, 0xa7, 0x12, 0xd1, 0x3f, 0x85, 0x62, 0x25, 0x56, 0x36,
0xbe, 0x50, 0xec, 0x76, 0x1b, 0xc1, 0x53, 0x6c, 0x29, 0x6a, 0xe1, 0xfb, 0xb1, 0x76, 0x82, 0x8d,
0xde, 0x61, 0x89, 0xbd, 0x47, 0x10, 0x97, 0x31, 0x1b, 0x5d, 0x93, 0x75, 0x91, 0x81, 0x24, 0x93,
0x7c, 0xff, 0x64, 0x88, 0xa8, 0x98, 0xe7, 0x13, 0xcb, 0xe5, 0xb3, 0x7c, 0x13, 0x72, 0x13, 0xae,
0x43, 0x96, 0x1f, 0x5d, 0xb8, 0xee, 0x66, 0xa8, 0x54, 0x60, 0xec, 0x71, 0x54, 0xda, 0x43, 0xa8,
0xd5, 0x87, 0xf1, 0x0c, 0x76, 0x88, 0xcf, 0xac, 0x6d, 0xa4, 0x18, 0x38, 0x7e, 0xe5, 0x83, 0x4a,
0x81, 0x99, 0xe8, 0xe9, 0xbd, 0x6d, 0x27, 0x80, 0x2a, 0xd2, 0x45, 0x55, 0x1f, 0x19, 0x4b, 0xfd,
0x30, 0xff, 0xb8, 0xb7, 0xc8, 0xbd, 0x47, 0x97, 0x03, 0x0b, 0x58, 0x24, 0x81, 0x8a, 0x74, 0xd0,
0x50, 0x53, 0x7d, 0x65, 0xba, 0x30, 0xf0, 0x17, 0xb0, 0x3b, 0x30, 0xc6, 0x6a, 0x9f, 0xaa, 0x6a,
0x56, 0x87, 0x08, 0x88, 0x3b, 0x6f, 0xd1, 0xd1, 0x88, 0xad, 0x44, 0x42, 0x13, 0x2b, 0x85, 0x8c,
0x70, 0xf8, 0x4d, 0x30, 0x6a, 0x61, 0x9d, 0x68, 0x90, 0x02, 0x58, 0xfd, 0x2f, 0x7e, 0x01, 0x17,
0x1b, 0xcc, 0x50, 0xfb, 0x07, 0x2c, 0x1e, 0xa6, 0xd0, 0x20, 0x05, 0x88, 0x90, 0xc6, 0x57, 0x03,
0x0c, 0xd3, 0x09, 0x1e, 0xed, 0x72, 0x93, 0xc0, 0xff, 0x07, 0x78, 0x22, 0xfb, 0x02, 0x26, 0x14,
0x74, 0x8c, 0x6a, 0xd1, 0x3d, 0xb9, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE icon_gerbview_16_xpm[1] = {{ png, sizeof( png ), "icon_gerbview_16_xpm" }};
//EOF

58
bitmaps_png/cpp_16/icon_kicad_16.cpp
View File

@ -1,58 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x02, 0x8b, 0x49, 0x44, 0x41, 0x54, 0x38, 0x4f, 0x75, 0x90, 0xcb, 0x8f, 0x4f,
0x59, 0x10, 0xc7, 0x3f, 0x75, 0xee, 0xf9, 0x3d, 0x2e, 0x3d, 0x4d, 0x37, 0x69, 0x8f, 0x34, 0x9a,
0xd0, 0xba, 0x43, 0x08, 0x91, 0x88, 0x05, 0x12, 0x3b, 0x21, 0x36, 0x62, 0x35, 0x1b, 0x89, 0xde,
0xa0, 0x23, 0x32, 0x61, 0xb0, 0xe9, 0xd1, 0x33, 0x63, 0xa1, 0x3d, 0x36, 0x76, 0x22, 0x36, 0xfe,
0x06, 0x11, 0x8f, 0x85, 0x85, 0x85, 0x48, 0x48, 0x88, 0x34, 0x91, 0x08, 0x0b, 0xd1, 0x26, 0x68,
0xf4, 0xcf, 0xcf, 0xef, 0x71, 0xcf, 0xa9, 0x9a, 0xc5, 0xbd, 0xf3, 0x1b, 0x16, 0xce, 0xc9, 0x49,
0x9d, 0x6f, 0xd5, 0xa9, 0x4f, 0x9d, 0x2a, 0x01, 0x18, 0xde, 0x7a, 0x6b, 0x44, 0xbd, 0x9b, 0xc0,
0x33, 0x17, 0xf1, 0x18, 0x0e, 0x90, 0xc2, 0x82, 0xa0, 0x80, 0xe5, 0x56, 0x23, 0xc4, 0x58, 0xb3,
0x2c, 0x1b, 0x7f, 0x71, 0x6f, 0xd7, 0x45, 0x19, 0xde, 0x76, 0xe3, 0x80, 0x55, 0x93, 0x2b, 0xe2,
0x12, 0xcc, 0x3c, 0x8a, 0x07, 0x12, 0x0c, 0xf7, 0x03, 0x20, 0x87, 0x44, 0x1c, 0x01, 0x91, 0x00,
0x31, 0xe2, 0x9a, 0xee, 0x84, 0x0c, 0x6d, 0xbb, 0xfd, 0x51, 0x52, 0xd7, 0xab, 0x56, 0xc2, 0x28,
0x61, 0x78, 0x8c, 0xff, 0x40, 0x39, 0x00, 0x34, 0x4f, 0x24, 0x20, 0x64, 0x08, 0x01, 0x27, 0x19,
0xda, 0x8c, 0x75, 0x19, 0xda, 0x7e, 0x27, 0x52, 0x4a, 0x5c, 0x4f, 0x77, 0x95, 0xc1, 0xe5, 0x29,
0x4a, 0x89, 0x37, 0xff, 0x24, 0xbc, 0x9e, 0x12, 0xfa, 0x17, 0x56, 0xe8, 0xef, 0x73, 0x08, 0x81,
0xb7, 0xef, 0xdb, 0xf4, 0xeb, 0x24, 0x57, 0x97, 0x1d, 0xa6, 0x5d, 0xea, 0x61, 0xeb, 0xfd, 0x0b,
0x34, 0x82, 0xc7, 0x21, 0x88, 0xa8, 0x21, 0x1a, 0x38, 0x3d, 0xda, 0xcd, 0xc4, 0xb1, 0x5e, 0xd6,
0xac, 0x10, 0x24, 0x2a, 0x67, 0x46, 0x53, 0x2e, 0xff, 0xd9, 0xc3, 0xa9, 0x91, 0x2e, 0x6a, 0x5f,
0xda, 0x6c, 0x5f, 0xfc, 0x8a, 0xd2, 0xd7, 0x29, 0x66, 0x7f, 0x9a, 0x64, 0x59, 0x3a, 0x0d, 0x26,
0x38, 0x54, 0x11, 0x8b, 0x7c, 0x9c, 0x6e, 0x51, 0xad, 0xa6, 0x54, 0xab, 0x55, 0x3e, 0x4c, 0x67,
0xec, 0xdf, 0xe3, 0xd9, 0xbc, 0x71, 0x2e, 0xb5, 0x3a, 0x1c, 0x1c, 0x7b, 0xc7, 0x4c, 0x2d, 0xe3,
0xec, 0xdd, 0x35, 0xdc, 0xe9, 0x3d, 0xc6, 0xb5, 0xf4, 0x6f, 0x5e, 0xcc, 0xf4, 0x21, 0x1a, 0x71,
0x18, 0x88, 0x05, 0x1c, 0x6d, 0xca, 0xe5, 0x32, 0x95, 0x4a, 0x85, 0x0d, 0xab, 0x3d, 0xbf, 0x1f,
0x1a, 0x00, 0x71, 0x1c, 0xff, 0xeb, 0x25, 0xef, 0x3f, 0xd4, 0x91, 0xd8, 0x60, 0xcb, 0xa6, 0x2e,
0x7e, 0xd9, 0x7d, 0x84, 0x55, 0xfb, 0x7e, 0x65, 0xc9, 0x02, 0x0f, 0x06, 0x8e, 0x08, 0x28, 0x88,
0x46, 0xbc, 0xf7, 0x88, 0x08, 0x47, 0x46, 0x56, 0x50, 0x2e, 0x27, 0x8c, 0x4f, 0x4c, 0xf2, 0xe8,
0xc9, 0x27, 0x9c, 0x36, 0x48, 0xac, 0x41, 0xf3, 0x6b, 0x8d, 0xe1, 0xc1, 0x6e, 0x06, 0xfa, 0x2b,
0xa4, 0x15, 0x01, 0x05, 0x87, 0xe6, 0x00, 0x54, 0x10, 0xc9, 0x4f, 0xb9, 0x9c, 0x90, 0x65, 0xca,
0xd3, 0x67, 0x9f, 0x71, 0xd6, 0xc4, 0x59, 0x0b, 0xb1, 0x0c, 0xb3, 0x88, 0x88, 0x43, 0xc4, 0x15,
0x39, 0x3f, 0x00, 0x0c, 0x33, 0x43, 0x44, 0x78, 0xf5, 0x7a, 0x86, 0x52, 0xc9, 0x31, 0xf1, 0xc7,
0x3a, 0x2a, 0xfe, 0xff, 0xc7, 0x18, 0x98, 0x59, 0x7e, 0xe9, 0x00, 0x0a, 0x8d, 0x41, 0x8c, 0x91,
0x18, 0x23, 0xe7, 0x2e, 0x3d, 0x63, 0xea, 0x5d, 0x9d, 0xc1, 0x95, 0x73, 0x38, 0x3e, 0xba, 0xb2,
0x13, 0x17, 0x07, 0xaa, 0x4a, 0x96, 0x05, 0x20, 0xf7, 0xe5, 0x80, 0x82, 0x16, 0x42, 0x46, 0x08,
0x81, 0x6f, 0x75, 0xe5, 0xe4, 0xd8, 0x43, 0xb2, 0x2c, 0xb0, 0x77, 0xcf, 0x52, 0x76, 0xee, 0x98,
0x5f, 0x54, 0x83, 0x76, 0xbb, 0x4d, 0x08, 0x59, 0x0e, 0xcd, 0x5b, 0x50, 0x43, 0x61, 0xf9, 0xd2,
0x94, 0x66, 0xb3, 0x49, 0xab, 0xd5, 0x62, 0x60, 0x49, 0xca, 0xa3, 0xc7, 0x0d, 0xee, 0x3f, 0x98,
0x22, 0x84, 0x8c, 0x13, 0x47, 0x57, 0xb1, 0x76, 0xf5, 0x6c, 0x16, 0x2d, 0x98, 0x45, 0xab, 0xd5,
0x44, 0x55, 0xe9, 0x9b, 0x57, 0x86, 0x08, 0x32, 0xb4, 0xfe, 0xe6, 0x74, 0xe2, 0xb5, 0x07, 0xc0,
0x54, 0xf3, 0xaf, 0x15, 0xc3, 0x34, 0x33, 0x30, 0x03, 0x91, 0xdc, 0x0f, 0x1d, 0x2d, 0x22, 0x68,
0xf4, 0x75, 0x97, 0x10, 0xc7, 0x62, 0x90, 0xbc, 0xc7, 0x62, 0xc2, 0x42, 0xa1, 0x91, 0x8e, 0xee,
0xec, 0x42, 0x9b, 0x0a, 0x82, 0x9e, 0x13, 0x80, 0xa1, 0xf5, 0xd7, 0x7f, 0x43, 0xfd, 0x38, 0x58,
0x97, 0x7c, 0x5f, 0xed, 0x67, 0xcb, 0xa4, 0x6e, 0x12, 0xcf, 0x3f, 0x7f, 0xb2, 0xf3, 0xf4, 0xbf,
0x9e, 0xd0, 0x32, 0x3b, 0x12, 0xac, 0x04, 0xee, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44,
0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE icon_kicad_16_xpm[1] = {{ png, sizeof( png ), "icon_kicad_16_xpm" }};
//EOF

30
bitmaps_png/cpp_16/icon_libedit_16.cpp
View File

@ -1,30 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0xd3, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0xa0, 0x26, 0x08,
0x0b, 0x0b, 0x7b, 0x11, 0x1e, 0x1e, 0x9e, 0x05, 0x64, 0x32, 0x92, 0x65, 0x40, 0x48, 0x48, 0xc8,
0xff, 0xe4, 0xb4, 0xcc, 0x2f, 0x91, 0x91, 0xd1, 0xfb, 0x23, 0x23, 0x23, 0xc5, 0xc9, 0x32, 0x60,
0xd5, 0x8e, 0x63, 0xff, 0x9b, 0x3b, 0x27, 0xfe, 0x8a, 0x88, 0x88, 0xfc, 0x10, 0x1a, 0x1a, 0x1a,
0x48, 0xb2, 0x01, 0x6b, 0x76, 0x9d, 0x00, 0xe3, 0x59, 0x4b, 0x37, 0xfc, 0x8f, 0x8b, 0x4f, 0xfc,
0x0a, 0x74, 0xc9, 0x6a, 0x3f, 0x3f, 0x3f, 0x5e, 0x9c, 0x9a, 0x80, 0xb6, 0x24, 0x80, 0x34, 0xc2,
0x30, 0xcc, 0x00, 0x10, 0x5e, 0xb9, 0xed, 0xc8, 0xff, 0x8a, 0xba, 0x96, 0x6f, 0x11, 0x91, 0x91,
0x2f, 0x80, 0x72, 0xb6, 0x44, 0xbb, 0x40, 0xb7, 0xe3, 0xc8, 0x7f, 0xa9, 0xc6, 0x23, 0x60, 0x1a,
0xc4, 0x9f, 0x3c, 0x77, 0xc5, 0xff, 0xe8, 0x98, 0xd8, 0xaf, 0x11, 0x11, 0x11, 0x7d, 0x40, 0x0b,
0xd9, 0x88, 0xf2, 0x02, 0x3a, 0x5e, 0xb2, 0x71, 0xdf, 0xff, 0x9c, 0x82, 0x92, 0xaf, 0x91, 0xd1,
0x31, 0xd7, 0x80, 0x86, 0xa8, 0x93, 0x6c, 0x00, 0x08, 0xaf, 0xde, 0x79, 0x1c, 0x64, 0xc8, 0x5f,
0xa0, 0xba, 0x3f, 0x20, 0xb5, 0x40, 0x83, 0x2e, 0xe3, 0x34, 0x00, 0xe6, 0x7c, 0xb2, 0x5c, 0x40,
0x95, 0x30, 0xb0, 0xeb, 0x3f, 0x4a, 0x5c, 0x2c, 0xe0, 0x8a, 0x46, 0xa2, 0xd3, 0x01, 0xd5, 0x53,
0x22, 0x45, 0x79, 0x81, 0x9c, 0xdc, 0x08, 0x00, 0xc2, 0xa4, 0x09, 0x49, 0xfd, 0x24, 0xa7, 0xd0,
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE icon_libedit_16_xpm[1] = {{ png, sizeof( png ), "icon_libedit_16_xpm" }};
//EOF

27
bitmaps_png/cpp_16/icon_modedit_16.cpp
View File

@ -1,27 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0x9b, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0xa0, 0x26, 0x90,
0x6e, 0x3c, 0x72, 0x59, 0xaa, 0xf1, 0xc8, 0x7f, 0x10, 0x4d, 0x0c, 0x1f, 0x0e, 0x22, 0x23, 0xa3,
0xb7, 0x87, 0x84, 0x84, 0xfc, 0x07, 0x49, 0xc2, 0x30, 0x21, 0x7e, 0x58, 0x58, 0xf8, 0x77, 0xa0,
0x98, 0x03, 0xd8, 0x00, 0x90, 0xe4, 0xaa, 0x1d, 0x47, 0x51, 0x14, 0xac, 0xd9, 0x75, 0x02, 0x2f,
0x7f, 0xda, 0x82, 0xd5, 0xff, 0xc3, 0xc2, 0xc3, 0xbf, 0xc3, 0x0d, 0x58, 0xb3, 0xeb, 0xf8, 0x7f,
0x93, 0x6e, 0x88, 0x21, 0xc6, 0xdd, 0x10, 0x0d, 0x84, 0xf8, 0x20, 0x7d, 0x50, 0x2f, 0x44, 0x9d,
0x69, 0xeb, 0x9b, 0xfa, 0x07, 0x24, 0x48, 0x0a, 0x86, 0x1b, 0x10, 0x1a, 0x1a, 0xaa, 0x12, 0x1e,
0x1e, 0xf1, 0x8b, 0x6c, 0x03, 0x10, 0xde, 0x18, 0x28, 0x17, 0x50, 0x1c, 0x06, 0xe8, 0xb1, 0x00,
0xa2, 0x91, 0x43, 0x1d, 0x17, 0x1f, 0xc5, 0x00, 0x8a, 0xd2, 0x41, 0x64, 0x74, 0xf4, 0x16, 0x92,
0x53, 0x62, 0x38, 0x52, 0x4a, 0x44, 0xcf, 0x0b, 0x40, 0x7c, 0x89, 0x18, 0xfe, 0xe0, 0x00, 0x00,
0xae, 0xb0, 0xdb, 0xae, 0xbb, 0xd9, 0xb2, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44,
0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE icon_modedit_16_xpm[1] = {{ png, sizeof( png ), "icon_modedit_16_xpm" }};
//EOF

31
bitmaps_png/cpp_16/icon_pagelayout_editor_16.cpp
View File

@ -1,31 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0xe4, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0xd5, 0x93, 0x31, 0x0e, 0x82,
0x40, 0x14, 0x44, 0x57, 0x8f, 0x61, 0x83, 0x95, 0xd7, 0xc0, 0x43, 0xc0, 0x09, 0xb8, 0x00, 0x6a,
0x41, 0x8b, 0x89, 0xc4, 0x0b, 0x78, 0x0b, 0xce, 0x40, 0xa5, 0x40, 0x23, 0x01, 0x4e, 0x60, 0xb9,
0x85, 0x0d, 0x01, 0x6b, 0xbe, 0x3b, 0x6b, 0x20, 0x66, 0x13, 0x59, 0x24, 0x36, 0x16, 0x13, 0xc8,
0xcf, 0xcc, 0xdb, 0xdd, 0x64, 0x3e, 0x63, 0x3e, 0xcd, 0x8d, 0x20, 0xde, 0xad, 0x8e, 0x29, 0x5f,
0xec, 0x2f, 0xad, 0x10, 0x69, 0xd4, 0xc2, 0x6b, 0x1c, 0xe2, 0x2d, 0x23, 0x9a, 0x31, 0x84, 0xd7,
0xa7, 0xeb, 0x23, 0xbb, 0xdd, 0xa9, 0x6e, 0x1a, 0x6a, 0x34, 0x82, 0x07, 0x5e, 0x53, 0x64, 0x24,
0x04, 0x34, 0x0c, 0x54, 0x23, 0xe7, 0x7c, 0x10, 0x84, 0x0c, 0xb2, 0x0c, 0x57, 0x52, 0x4f, 0xce,
0xf3, 0x9c, 0x6c, 0xdb, 0x1e, 0x84, 0x20, 0x83, 0x2c, 0x00, 0xaf, 0x41, 0x5d, 0x93, 0xe7, 0x79,
0x54, 0x14, 0x05, 0x55, 0x55, 0x25, 0xbf, 0xba, 0xe7, 0x20, 0xdb, 0x03, 0xa2, 0x28, 0x22, 0xcb,
0xb2, 0xc8, 0x71, 0x1c, 0x4a, 0x92, 0x84, 0xc2, 0x30, 0xfc, 0x0e, 0xe0, 0xba, 0xae, 0x04, 0x74,
0xc2, 0x13, 0xca, 0xb2, 0x1c, 0x0f, 0x98, 0xa2, 0x3f, 0x00, 0x74, 0xed, 0x7b, 0xff, 0x57, 0x67,
0x3f, 0x01, 0xb4, 0x63, 0x2b, 0xac, 0x4a, 0x16, 0xe9, 0x53, 0x95, 0x75, 0x37, 0xe8, 0xab, 0x8c,
0x85, 0x30, 0x27, 0x2e, 0xd3, 0x32, 0x48, 0x37, 0x0c, 0x2b, 0x09, 0x88, 0x5c, 0x67, 0xff, 0x4c,
0xda, 0x75, 0x16, 0x1e, 0x78, 0x65, 0x58, 0x64, 0x9f, 0x32, 0x03, 0x43, 0xd3, 0xa9, 0xd9, 0xd9,
0x6b, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE icon_pagelayout_editor_16_xpm[1] = {{ png, sizeof( png ), "icon_pagelayout_editor_16_xpm" }};
//EOF

27
bitmaps_png/cpp_16/icon_pcbcalculator_16.cpp
View File

@ -1,27 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0xa7, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0xf8, 0x3c, 0x89, 0x41,
0xf4, 0xd3, 0x44, 0x86, 0x35, 0x40, 0xfc, 0x05, 0x88, 0xff, 0xa3, 0x63, 0x10, 0xc0, 0x22, 0x0e,
0x52, 0xbb, 0xfa, 0x53, 0x0f, 0x83, 0x08, 0x03, 0x54, 0xf3, 0x7f, 0x5c, 0x18, 0x87, 0x01, 0x10,
0x3c, 0x89, 0x61, 0x15, 0x03, 0xb2, 0xcd, 0x21, 0x21, 0x21, 0x60, 0x4c, 0xb4, 0x01, 0x13, 0x19,
0x3e, 0x83, 0x0c, 0xf8, 0x1f, 0x19, 0x16, 0x08, 0xd7, 0x8c, 0x8c, 0x91, 0x0d, 0xc0, 0x25, 0x4f,
0x1d, 0x03, 0x28, 0xf0, 0x02, 0xaa, 0x01, 0x24, 0x07, 0x22, 0xc8, 0x80, 0xff, 0x14, 0x02, 0xa2,
0x5c, 0xb0, 0x73, 0xe7, 0x4e, 0x9c, 0x98, 0x01, 0xd9, 0xff, 0xd8, 0xd8, 0x30, 0x03, 0xb0, 0x05,
0x22, 0xdc, 0x00, 0xf4, 0xc0, 0x43, 0x8f, 0x05, 0x82, 0x06, 0x10, 0x8a, 0x05, 0xa2, 0xbc, 0x40,
0xc8, 0x00, 0x7c, 0x2e, 0xf8, 0x42, 0xae, 0x17, 0xf6, 0x6c, 0xdf, 0xf8, 0x8f, 0x01, 0x9c, 0xab,
0x88, 0x08, 0x44, 0x6c, 0xf8, 0xc4, 0xfa, 0xee, 0x47, 0x0c, 0xa0, 0x2c, 0x09, 0x35, 0xe4, 0x33,
0xb1, 0xd1, 0x08, 0xb2, 0x19, 0xa4, 0xf9, 0xee, 0x8a, 0x54, 0x35, 0x00, 0xc9, 0x82, 0xa0, 0x23,
0x7f, 0x04, 0xe5, 0x89, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE icon_pcbcalculator_16_xpm[1] = {{ png, sizeof( png ), "icon_pcbcalculator_16_xpm" }};
//EOF

41
bitmaps_png/cpp_16/icon_pcbnew_16.cpp
View File

@ -1,41 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x01, 0x86, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x30, 0x4f, 0x34, 0xd7,
0xb2, 0xf4, 0xb6, 0x7c, 0x6a, 0x62, 0x6e, 0xf2, 0xdf, 0xd8, 0xd8, 0x98, 0x28, 0x6c, 0x68, 0x6a,
0xf8, 0x5f, 0xd3, 0x55, 0xf3, 0xbb, 0x4e, 0x8c, 0x8e, 0x15, 0x03, 0x48, 0xb3, 0x6d, 0x82, 0xed,
0x7f, 0xf7, 0x49, 0xee, 0xff, 0x55, 0x6a, 0x55, 0xfe, 0x33, 0xa4, 0x30, 0xfc, 0x67, 0x4e, 0x63,
0xfe, 0x6f, 0xda, 0x69, 0xfa, 0xdf, 0x63, 0x9a, 0xc7, 0x7f, 0x87, 0x89, 0x0e, 0xff, 0xb9, 0xb2,
0xb9, 0xc0, 0xe2, 0x30, 0xcc, 0x94, 0xc4, 0xf4, 0x5f, 0xc6, 0x53, 0x06, 0x6c, 0x08, 0x03, 0xc8,
0x34, 0x90, 0x00, 0x4c, 0x12, 0x97, 0x66, 0xc6, 0x14, 0xc6, 0xff, 0xda, 0x8d, 0xda, 0x60, 0x71,
0x10, 0x06, 0x59, 0x08, 0x72, 0x35, 0x03, 0xc8, 0x49, 0xfc, 0x69, 0x8c, 0xff, 0xa3, 0x4a, 0x39,
0xff, 0xc7, 0x96, 0x71, 0xff, 0x77, 0xe8, 0x34, 0xc2, 0xd0, 0xcc, 0x92, 0xce, 0xf2, 0xdf, 0xa4,
0xc3, 0x04, 0xae, 0x19, 0x86, 0x41, 0x7a, 0xc1, 0x06, 0x1c, 0x68, 0x17, 0xfa, 0x7f, 0xb7, 0x57,
0x14, 0x8c, 0x4f, 0xf5, 0xc9, 0xfc, 0xf7, 0x9a, 0x68, 0x0b, 0xd7, 0xcc, 0x91, 0xc9, 0xf1, 0xdf,
0xba, 0xc7, 0x1a, 0x43, 0x33, 0x8a, 0x01, 0x30, 0xcd, 0x30, 0x1c, 0x57, 0xc1, 0x07, 0xd6, 0xcc,
0x93, 0xc3, 0xf3, 0xdf, 0x61, 0x82, 0x03, 0x42, 0xd3, 0x54, 0x0f, 0x78, 0x38, 0x81, 0x30, 0x4e,
0x03, 0x40, 0xde, 0x01, 0x29, 0x70, 0x99, 0xec, 0x82, 0xf0, 0xf3, 0x54, 0xf7, 0xff, 0xd2, 0xe5,
0xd2, 0x28, 0x81, 0x89, 0xd5, 0x0b, 0xfb, 0x3b, 0x84, 0xfe, 0xf3, 0xa5, 0x33, 0x82, 0x15, 0x20,
0x3b, 0x57, 0xb8, 0x50, 0x18, 0x45, 0x33, 0x8a, 0x01, 0xb0, 0x40, 0x8c, 0x28, 0xe1, 0x80, 0x6b,
0x46, 0x37, 0x00, 0x26, 0x96, 0x00, 0x54, 0x77, 0xbc, 0x53, 0xf8, 0xff, 0x69, 0x20, 0x86, 0x1b,
0x80, 0x6e, 0x32, 0x2e, 0x03, 0x4c, 0xf3, 0x58, 0x51, 0xbc, 0x8a, 0x62, 0xc0, 0xea, 0x16, 0x01,
0xb8, 0xc4, 0xaa, 0x66, 0x01, 0xac, 0x06, 0xa4, 0x96, 0x73, 0x61, 0x37, 0x00, 0xa4, 0x00, 0x3d,
0x20, 0xb1, 0x19, 0x60, 0x89, 0xcf, 0x05, 0x20, 0x5b, 0x61, 0x12, 0x2b, 0x5b, 0x04, 0x70, 0x86,
0x41, 0x52, 0x19, 0x27, 0xd8, 0xff, 0x27, 0x60, 0x61, 0x00, 0x4a, 0x8e, 0xdc, 0xe9, 0xdc, 0x28,
0x1a, 0xb0, 0x85, 0x81, 0x48, 0x91, 0x08, 0x46, 0x7e, 0x00, 0x65, 0x03, 0x06, 0x4b, 0x1f, 0xcb,
0xa7, 0x36, 0x09, 0x36, 0xe0, 0xb4, 0x0d, 0x53, 0xac, 0x56, 0xaf, 0x86, 0x99, 0x0e, 0xa6, 0xb9,
0xff, 0x97, 0xad, 0x94, 0x45, 0x64, 0x26, 0x0f, 0x99, 0xff, 0x1a, 0xae, 0x1a, 0xdf, 0x18, 0xc0,
0xd9, 0xd9, 0x87, 0xf4, 0xec, 0x0c, 0xd2, 0x0c, 0xca, 0xce, 0x00, 0x6b, 0x44, 0xd1, 0x15, 0x81,
0x50, 0xb1, 0x52, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE icon_pcbnew_16_xpm[1] = {{ png, sizeof( png ), "icon_pcbnew_16_xpm" }};
//EOF

38
bitmaps_png/cpp_16/list_nets_16.cpp
View File

@ -1,38 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x01, 0x4f, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x48, 0x4a, 0x4a, 0x52,
0x4a, 0x48, 0x48, 0xd8, 0x03, 0xc4, 0x6f, 0x80, 0xf8, 0x1d, 0x01, 0xfc, 0x16, 0x88, 0xf7, 0x03,
0xb1, 0x2a, 0x03, 0x0c, 0x40, 0x05, 0xfe, 0x93, 0x88, 0x8f, 0x22, 0x1b, 0xf0, 0x05, 0x24, 0x08,
0x02, 0x30, 0x05, 0xf8, 0x00, 0x54, 0xcd, 0x1f, 0xa0, 0x56, 0x46, 0x98, 0x01, 0x3f, 0xc8, 0x70,
0xc1, 0x7f, 0xea, 0x1b, 0x40, 0xa2, 0x17, 0x48, 0x73, 0x41, 0x62, 0x7c, 0xc2, 0xff, 0x82, 0xf0,
0xe8, 0xff, 0x95, 0x81, 0x11, 0xff, 0xb3, 0x23, 0x63, 0x48, 0x33, 0xa0, 0xc6, 0x3f, 0xfc, 0xff,
0x26, 0x7d, 0xb7, 0xff, 0xfb, 0xd5, 0x1c, 0xe1, 0x78, 0xb9, 0xa9, 0xe7, 0xff, 0x3d, 0x6a, 0x36,
0x4a, 0x04, 0xbd, 0xf0, 0xe6, 0xc0, 0x89, 0xff, 0x07, 0x34, 0x5d, 0xe0, 0x1a, 0x9f, 0xaf, 0xdf,
0xf9, 0xff, 0xc5, 0xa6, 0x3d, 0x30, 0xfe, 0xb3, 0x5d, 0xea, 0xae, 0x52, 0xb8, 0x5d, 0x00, 0x74,
0xf6, 0x26, 0x5d, 0x57, 0x14, 0x9b, 0x2f, 0xa5, 0x57, 0xfd, 0xbf, 0x9c, 0x51, 0x0d, 0xe7, 0xef,
0x53, 0x73, 0x9c, 0x85, 0xd3, 0x80, 0xa2, 0x90, 0x28, 0xb8, 0xc2, 0x83, 0xba, 0xee, 0xff, 0x1f,
0x4c, 0x5b, 0xfc, 0xff, 0xf5, 0xee, 0xc3, 0xff, 0x8f, 0x98, 0x07, 0x20, 0x1b, 0xfa, 0x0a, 0x64,
0xc0, 0x37, 0x6c, 0x5e, 0x78, 0x7b, 0xf8, 0x14, 0x8a, 0xed, 0x67, 0x43, 0x32, 0xc1, 0xe2, 0x67,
0xc3, 0xb3, 0x91, 0xc5, 0x7f, 0x83, 0x0c, 0x38, 0x8e, 0xcd, 0x05, 0x79, 0x11, 0x31, 0x28, 0x06,
0xdc, 0x6a, 0x9e, 0xf4, 0xff, 0xef, 0x8f, 0x9f, 0xff, 0x0f, 0xe9, 0x7b, 0x20, 0x8b, 0xdf, 0x00,
0x19, 0xa0, 0x0b, 0xc4, 0x17, 0xb0, 0x19, 0xb2, 0xd2, 0xc4, 0x13, 0xae, 0xf8, 0xd5, 0xf6, 0x03,
0xff, 0x3f, 0x9e, 0xbf, 0x8a, 0x62, 0xe8, 0x7e, 0x75, 0x87, 0x72, 0x78, 0x9e, 0x88, 0x8d, 0x8d,
0xe5, 0x8e, 0x8a, 0x8a, 0x12, 0x44, 0xc6, 0x73, 0x4c, 0x3c, 0x0d, 0xf7, 0xab, 0x3b, 0xbe, 0x02,
0x29, 0xbe, 0x92, 0xd7, 0xf0, 0xff, 0xf5, 0x9e, 0x23, 0xff, 0x2f, 0xa6, 0x94, 0x83, 0x35, 0x1f,
0x50, 0x73, 0xdc, 0xbb, 0x5f, 0xc1, 0x81, 0x83, 0x81, 0x10, 0xd8, 0xaf, 0xed, 0x20, 0x01, 0xd4,
0xb0, 0x00, 0xa8, 0xe1, 0x23, 0xd8, 0x56, 0x55, 0xa7, 0x5b, 0x40, 0x76, 0xe5, 0x36, 0x15, 0x4f,
0x76, 0x90, 0x3c, 0x00, 0xb3, 0x1b, 0x11, 0xc1, 0x83, 0x34, 0xa0, 0xdc, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE list_nets_16_xpm[1] = {{ png, sizeof( png ), "list_nets_16_xpm" }};
//EOF

29
bitmaps_png/cpp_16/options_generic_16.cpp
View File

@ -1,29 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0xc2, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0xa0, 0x26, 0x90,
0x68, 0x38, 0xae, 0x20, 0xd5, 0x70, 0x64, 0xb2, 0x54, 0xc3, 0xa1, 0x00, 0xb2, 0x0d, 0x91, 0x6a,
0x3a, 0x9c, 0x25, 0xd5, 0x78, 0xe4, 0x1f, 0x10, 0x4f, 0x23, 0x5a, 0x93, 0x78, 0xc3, 0x51, 0x1d,
0x86, 0xff, 0xff, 0x19, 0xe1, 0x86, 0x34, 0x1e, 0x79, 0x00, 0x32, 0x44, 0xb2, 0xf9, 0xb8, 0x26,
0x91, 0xb6, 0x1e, 0xa9, 0x93, 0x6a, 0x38, 0x3a, 0x57, 0xa1, 0x61, 0x3f, 0x87, 0x74, 0xe3, 0x21,
0x67, 0xa0, 0xe6, 0xff, 0x60, 0xdc, 0x70, 0xd4, 0x8d, 0x48, 0xbf, 0x1f, 0xd2, 0x02, 0x6a, 0xf8,
0x09, 0xc4, 0xbf, 0xe0, 0x9a, 0x81, 0x58, 0xb2, 0xf1, 0x70, 0x0b, 0xd1, 0xde, 0x90, 0x6e, 0x38,
0x1a, 0x02, 0xd4, 0xf4, 0x06, 0xd9, 0x00, 0x08, 0x3e, 0xdc, 0x40, 0xb4, 0x21, 0xda, 0x0d, 0x57,
0xd9, 0x80, 0xb1, 0x20, 0x07, 0x0c, 0xc8, 0x24, 0xa0, 0xe6, 0xbf, 0x64, 0x19, 0x82, 0x08, 0x97,
0xa3, 0x11, 0x40, 0xcd, 0x7f, 0x10, 0x86, 0x1c, 0xed, 0x20, 0xd7, 0x90, 0xdf, 0x88, 0x40, 0x3d,
0xdc, 0x39, 0x84, 0x0d, 0x01, 0x46, 0x69, 0x2c, 0x4a, 0x98, 0x34, 0x1d, 0x49, 0xa1, 0xc8, 0x10,
0xe9, 0x86, 0x23, 0xfd, 0xe4, 0xe5, 0x95, 0x86, 0xc3, 0x2e, 0xd2, 0x8d, 0x47, 0x6a, 0x65, 0x1a,
0x8e, 0x09, 0x51, 0x25, 0x07, 0x03, 0x00, 0x28, 0x74, 0x91, 0x27, 0xb1, 0x4d, 0xc4, 0xee, 0x00,
0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE options_generic_16_xpm[1] = {{ png, sizeof( png ), "options_generic_16_xpm" }};
//EOF

27
bitmaps_png/cpp_16/pinorient_down.cpp
View File

@ -1,27 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0xa1, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x80, 0x83, 0x48,
0xf1, 0xe0, 0xa5, 0x21, 0x1f, 0x42, 0x3e, 0x86, 0x2c, 0x8e, 0x90, 0x62, 0xc0, 0x04, 0xd1, 0x7c,
0x21, 0xb7, 0x82, 0x6f, 0x06, 0x67, 0x87, 0xe6, 0x87, 0xdc, 0x0b, 0xb9, 0x1d, 0xcd, 0x87, 0xa1,
0x20, 0xa4, 0x38, 0xe4, 0x5d, 0xa8, 0x28, 0x88, 0x15, 0x24, 0x19, 0xf2, 0x21, 0xb8, 0x10, 0x53,
0xc1, 0xe2, 0xd0, 0x4d, 0x30, 0x76, 0xe8, 0x8e, 0xe0, 0xf9, 0x18, 0x0a, 0x82, 0xbb, 0x42, 0xae,
0x37, 0x30, 0x81, 0x58, 0x0d, 0x4c, 0x21, 0xb7, 0x42, 0xeb, 0x30, 0x15, 0x68, 0x84, 0xfc, 0x0a,
0x99, 0x15, 0x29, 0x12, 0x28, 0x16, 0x32, 0x2b, 0xe4, 0x4b, 0xb8, 0x32, 0x16, 0x67, 0x86, 0x04,
0x85, 0xbc, 0x0d, 0xf9, 0x0f, 0x84, 0x2f, 0x82, 0xbd, 0x18, 0xb0, 0x03, 0x3f, 0xde, 0xd0, 0x03,
0xc1, 0xfb, 0x42, 0x39, 0x19, 0x70, 0x83, 0x90, 0x55, 0x21, 0xab, 0x18, 0x18, 0x86, 0x9e, 0x82,
0x50, 0x9b, 0x90, 0x50, 0x24, 0x78, 0x08, 0x08, 0x91, 0xf8, 0x41, 0x16, 0x0c, 0x21, 0x0f, 0xc0,
0x81, 0x83, 0x0b, 0x5e, 0x01, 0x00, 0xe8, 0xaf, 0x55, 0xdb, 0x97, 0x1f, 0x1a, 0xf2, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinorient_down_xpm[1] = {{ png, sizeof( png ), "pinorient_down_xpm" }};
//EOF

27
bitmaps_png/cpp_16/pinorient_left.cpp
View File

@ -1,27 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x9a, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x08, 0xb9, 0x1d, 0x62,
0xc5, 0x80, 0x0f, 0x84, 0xfc, 0x0f, 0x09, 0x1d, 0x00, 0x05, 0xe1, 0x6a, 0x21, 0xad, 0xc1, 0x33,
0x43, 0xb2, 0x7c, 0xb9, 0xb0, 0x2a, 0x08, 0xf5, 0x0e, 0xf9, 0x16, 0x72, 0x2f, 0x74, 0x5f, 0xc8,
0xe7, 0x90, 0x1b, 0xa1, 0x12, 0x18, 0x0a, 0x7c, 0xb9, 0x42, 0xde, 0x06, 0xcf, 0x69, 0x60, 0x62,
0x60, 0x08, 0x92, 0x09, 0x79, 0x10, 0xbc, 0x08, 0xa8, 0x20, 0xf8, 0x60, 0xc8, 0x2a, 0x04, 0x0c,
0x3d, 0x18, 0xf2, 0x3f, 0x50, 0x0c, 0xa2, 0x38, 0xb8, 0x30, 0xe4, 0x35, 0x50, 0x41, 0xe8, 0x11,
0x74, 0x05, 0x91, 0x22, 0x50, 0x05, 0xd9, 0x21, 0x1f, 0x31, 0xac, 0xf0, 0xe3, 0x0d, 0x79, 0x17,
0x3c, 0x0d, 0x64, 0x45, 0xa4, 0x48, 0xc8, 0x0d, 0xb0, 0x15, 0x18, 0x8e, 0x0c, 0x09, 0xf9, 0x1d,
0x72, 0x25, 0x74, 0x7d, 0xc8, 0xdb, 0x90, 0x5b, 0xa1, 0xa2, 0x58, 0xbd, 0x19, 0xaa, 0x1b, 0xd2,
0x17, 0xbc, 0x28, 0x34, 0x1f, 0x87, 0x37, 0xa9, 0x1f, 0xd4, 0xb7, 0xf0, 0x47, 0x37, 0x00, 0x17,
0xa7, 0x55, 0xbe, 0xb3, 0x5b, 0xdf, 0x98, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinorient_left_xpm[1] = {{ png, sizeof( png ), "pinorient_left_xpm" }};
//EOF

27
bitmaps_png/cpp_16/pinorient_right.cpp
View File

@ -1,27 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0xa1, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0xc0, 0x03, 0x82,
0xac, 0x43, 0x6e, 0xe1, 0x93, 0x67, 0x08, 0x09, 0x0d, 0xf9, 0x4f, 0x15, 0x05, 0xb1, 0xdc, 0xc1,
0x85, 0x21, 0x8b, 0x43, 0xfa, 0x83, 0xf5, 0xb0, 0x2a, 0x88, 0x14, 0x0f, 0xbe, 0x13, 0xf2, 0x3a,
0x64, 0x6d, 0xc8, 0xa5, 0x90, 0xdf, 0x21, 0xa1, 0x58, 0x14, 0x04, 0x2f, 0x0a, 0xbe, 0x16, 0x2a,
0x04, 0xe4, 0x31, 0x06, 0x4f, 0x0b, 0x79, 0x1b, 0xca, 0x83, 0xa1, 0x20, 0xe4, 0x79, 0x68, 0x26,
0x84, 0x1b, 0x28, 0x16, 0xf2, 0x3f, 0xe4, 0x40, 0xc8, 0x2a, 0x04, 0x0c, 0x3d, 0x02, 0x52, 0xf0,
0x3a, 0xa4, 0x00, 0xea, 0x6b, 0xc9, 0x90, 0xff, 0xa1, 0x28, 0x0a, 0x82, 0x0f, 0x82, 0x14, 0x2c,
0x0e, 0xbe, 0x1f, 0x24, 0xc3, 0xc0, 0x10, 0xca, 0x1c, 0xb2, 0x20, 0xe4, 0x75, 0x28, 0x27, 0x86,
0x15, 0xa1, 0x12, 0x21, 0x37, 0x42, 0x3e, 0x87, 0xee, 0x0b, 0x79, 0x10, 0xf2, 0x35, 0xd8, 0x0b,
0xab, 0x37, 0x43, 0x39, 0x43, 0x33, 0x43, 0x66, 0x84, 0x34, 0x87, 0xaa, 0xd0, 0x2c, 0x24, 0x29,
0x51, 0x60, 0x15, 0x7c, 0x13, 0x00, 0xfa, 0x0f, 0x55, 0x18, 0x7f, 0xe7, 0xc8, 0xad, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinorient_right_xpm[1] = {{ png, sizeof( png ), "pinorient_right_xpm" }};
//EOF

27
bitmaps_png/cpp_16/pinorient_up.cpp
View File

@ -1,27 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x99, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x08, 0xb9, 0x1d, 0xf2,
0x1f, 0x0f, 0xbc, 0xc5, 0x10, 0x62, 0x15, 0x12, 0x8a, 0x80, 0xc1, 0xc7, 0x43, 0xf7, 0x21, 0xf3,
0x43, 0xac, 0x18, 0x50, 0x41, 0xc8, 0x86, 0x90, 0x25, 0x0c, 0xf8, 0xc0, 0x10, 0x50, 0x10, 0xca,
0x13, 0x7c, 0x3c, 0x64, 0x4f, 0x28, 0x27, 0x0e, 0xe9, 0xe0, 0xb0, 0x90, 0x77, 0xe0, 0xc0, 0x79,
0x1b, 0xec, 0x85, 0x45, 0x3a, 0x50, 0x3f, 0xe4, 0x77, 0xc8, 0xd4, 0x50, 0xa1, 0x40, 0xb1, 0x90,
0xb9, 0x21, 0x5f, 0x83, 0x55, 0x31, 0xf5, 0x4f, 0x08, 0xb9, 0xc8, 0xc0, 0x08, 0xb6, 0x88, 0x39,
0xf8, 0x7e, 0x48, 0x33, 0xa6, 0xf3, 0x16, 0x87, 0xae, 0x81, 0xbb, 0x65, 0x5f, 0xf0, 0x4c, 0x4c,
0x13, 0x0a, 0x43, 0x5e, 0x87, 0x0a, 0x81, 0x58, 0x41, 0x32, 0x21, 0x9f, 0x83, 0x33, 0x30, 0x14,
0xc4, 0x72, 0x03, 0xe3, 0xf5, 0x7a, 0x48, 0x16, 0x50, 0xe1, 0x83, 0xe0, 0x6b, 0x58, 0x7d, 0x02,
0x74, 0xde, 0xe2, 0x90, 0x8f, 0x21, 0xaf, 0x43, 0x16, 0x46, 0x8a, 0x23, 0x44, 0x01, 0xcb, 0x60,
0x55, 0x16, 0xa6, 0x16, 0x2b, 0x14, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE pinorient_up_xpm[1] = {{ png, sizeof( png ), "pinorient_up_xpm" }};
//EOF

24
bitmaps_png/cpp_16/pinshape_active_low_input.cpp
View File

@ -1,24 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x6e, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x08, 0xb9, 0x1d, 0x62,
0xc5, 0x80, 0x04, 0x82, 0xdd, 0x03, 0xc5, 0x90, 0xf9, 0x0c, 0x21, 0xff, 0x43, 0x42, 0x91, 0x78,
0xb9, 0x21, 0xff, 0x42, 0x72, 0x71, 0x2a, 0x00, 0x4b, 0xff, 0x0d, 0x29, 0xc0, 0xa1, 0x20, 0x24,
0x3d, 0xe4, 0x5f, 0x68, 0x75, 0xc8, 0x13, 0x1c, 0x0a, 0x42, 0xd3, 0x40, 0xd2, 0x40, 0x3e, 0x76,
0x05, 0x30, 0x69, 0x1c, 0x0a, 0x40, 0xd2, 0x21, 0x55, 0x50, 0x3e, 0x16, 0x05, 0x53, 0x80, 0xd2,
0x6f, 0x43, 0x56, 0x41, 0xe1, 0xb7, 0x90, 0xf3, 0x70, 0xf6, 0xaa, 0x90, 0x4e, 0xa0, 0x82, 0xd0,
0x5e, 0x24, 0x01, 0x74, 0xd8, 0x8d, 0x16, 0x0e, 0x58, 0xc0, 0xd0, 0x50, 0x70, 0x0b, 0x35, 0xba,
0xd1, 0x01, 0x00, 0x02, 0xcb, 0x57, 0xa9, 0xb1, 0x4c, 0x80, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x49,
0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinshape_active_low_input_xpm[1] = {{ png, sizeof( png ), "pinshape_active_low_input_xpm" }};
//EOF

24
bitmaps_png/cpp_16/pinshape_active_low_output.cpp
View File

@ -1,24 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x72, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x08, 0x79, 0x16, 0xe6,
0xce, 0x80, 0x0f, 0x84, 0xfc, 0x0f, 0x7d, 0x14, 0x24, 0x83, 0x57, 0x41, 0xc8, 0xcf, 0x90, 0x87,
0xe1, 0x9a, 0xf8, 0x14, 0xcc, 0x08, 0x39, 0x14, 0xf2, 0x2e, 0xc8, 0x1a, 0xb7, 0x82, 0x3e, 0x4f,
0xf6, 0xd0, 0x35, 0x21, 0x5f, 0x43, 0xbd, 0x71, 0x2a, 0x60, 0x60, 0x08, 0x65, 0x0e, 0x9e, 0x19,
0xf2, 0x27, 0x38, 0x15, 0xa7, 0x02, 0x20, 0x60, 0x0c, 0x69, 0x08, 0xf9, 0x17, 0xd2, 0x80, 0x45,
0x41, 0xf0, 0xcd, 0x90, 0x55, 0x50, 0xf8, 0x16, 0xe8, 0xa7, 0xdd, 0x70, 0x1e, 0x08, 0x76, 0x83,
0x4c, 0x38, 0x86, 0x22, 0x84, 0x02, 0x83, 0xbb, 0x40, 0x0a, 0x42, 0x09, 0x04, 0xd4, 0x50, 0x50,
0x70, 0x2b, 0xc4, 0x0a, 0x9f, 0x3c, 0x00, 0x71, 0x0b, 0x4d, 0x2b, 0xaa, 0xcc, 0x3e, 0xcc, 0x00,
0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinshape_active_low_output_xpm[1] = {{ png, sizeof( png ), "pinshape_active_low_output_xpm" }};
//EOF

29
bitmaps_png/cpp_16/pinshape_clock_active_low.cpp
View File

@ -1,29 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0xc6, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x00, 0x83, 0x90,
0xce, 0xe0, 0x2e, 0x06, 0x24, 0x10, 0xac, 0x14, 0x6c, 0x82, 0xcc, 0x67, 0x08, 0x59, 0x19, 0xb2,
0x1a, 0xc1, 0x0b, 0xd5, 0x0a, 0x79, 0x11, 0x7a, 0x10, 0xa7, 0x02, 0x90, 0x74, 0xc8, 0xdf, 0xd0,
0x23, 0xa8, 0x0a, 0x8e, 0x05, 0xef, 0x83, 0x4a, 0xab, 0x87, 0x3c, 0x0b, 0x3d, 0x12, 0x32, 0x17,
0x45, 0x41, 0x88, 0x4f, 0xc8, 0xbf, 0x90, 0xd3, 0x08, 0x69, 0x3f, 0xde, 0xe0, 0x09, 0x48, 0x0a,
0xc2, 0x35, 0x43, 0x3e, 0x84, 0xde, 0x07, 0x59, 0x01, 0x93, 0x06, 0x3a, 0x12, 0xa1, 0x20, 0x50,
0x38, 0xf8, 0x4e, 0xc8, 0xe1, 0xd0, 0xd5, 0x21, 0xab, 0x11, 0xd2, 0x28, 0x0a, 0x42, 0xf7, 0x85,
0xdc, 0x8d, 0x14, 0x09, 0x59, 0x19, 0xbc, 0x15, 0xe8, 0xb4, 0xff, 0x21, 0xdb, 0x42, 0x56, 0x81,
0xe1, 0xad, 0x90, 0xd7, 0x60, 0xba, 0x83, 0x21, 0x64, 0x4f, 0xf0, 0xa3, 0x08, 0x29, 0xa0, 0x2f,
0xb6, 0x85, 0x2c, 0x87, 0x4a, 0x22, 0xc3, 0x3e, 0x86, 0x50, 0xfe, 0x90, 0x4b, 0xa1, 0x97, 0x43,
0xd7, 0x21, 0x87, 0x03, 0x1a, 0x08, 0x92, 0x09, 0x79, 0x1c, 0xf2, 0x32, 0x64, 0x2d, 0x03, 0x6e,
0x10, 0x64, 0x14, 0xf2, 0x3b, 0xf8, 0x32, 0x03, 0x3e, 0x10, 0xba, 0x23, 0x78, 0x2b, 0x5e, 0x05,
0xa8, 0x71, 0x41, 0x96, 0x82, 0xee, 0x90, 0x1e, 0xec, 0x32, 0x00, 0x60, 0xa3, 0x63, 0x3f, 0x99,
0x90, 0xc4, 0xb2, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinshape_clock_active_low_xpm[1] = {{ png, sizeof( png ), "pinshape_clock_active_low_xpm" }};
//EOF

28
bitmaps_png/cpp_16/pinshape_clock_fall.cpp
View File

@ -1,28 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0xb3, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0xad, 0xd1, 0x3f, 0x0e, 0x01,
0x71, 0x10, 0xc5, 0xf1, 0x11, 0x42, 0xdc, 0xc1, 0x39, 0x44, 0x47, 0xab, 0xd0, 0xd8, 0xef, 0xbb,
0x87, 0x2b, 0x28, 0xa9, 0x94, 0x6e, 0x20, 0x1b, 0x11, 0x7f, 0x82, 0x4e, 0x28, 0x68, 0x54, 0x1a,
0x89, 0x4a, 0xa3, 0x95, 0x10, 0x89, 0x88, 0x64, 0x63, 0x75, 0xec, 0x06, 0xbf, 0xca, 0x4c, 0xf9,
0x3e, 0xaf, 0x99, 0x31, 0x33, 0x33, 0x33, 0x1a, 0x5e, 0xd3, 0x5c, 0x83, 0x4f, 0xf7, 0xcf, 0x20,
0x51, 0x4a, 0x39, 0x40, 0x39, 0xc3, 0x98, 0xe1, 0x4f, 0xa0, 0xb4, 0x46, 0x84, 0x5a, 0xc6, 0x80,
0x86, 0x0c, 0x5e, 0xed, 0x29, 0x27, 0xe6, 0x31, 0x50, 0xcd, 0xe9, 0xc6, 0xf6, 0xd5, 0x3e, 0x2b,
0xef, 0xb5, 0x22, 0x40, 0x59, 0xad, 0xb9, 0x30, 0x78, 0xc7, 0x66, 0x51, 0x90, 0xa0, 0xc3, 0x51,
0x13, 0xba, 0xef, 0x38, 0x06, 0xbc, 0x3a, 0x77, 0x15, 0xf1, 0xe9, 0x31, 0x25, 0xa4, 0x81, 0x10,
0xd2, 0x84, 0x1d, 0x42, 0xd5, 0x82, 0x71, 0x60, 0xa5, 0x24, 0x3e, 0x33, 0x02, 0xc2, 0x8f, 0xdd,
0x9b, 0xf2, 0x5c, 0x69, 0x3b, 0x2f, 0xe9, 0x55, 0x08, 0xb4, 0x71, 0x9e, 0x9a, 0x1a, 0x0f, 0x56,
0xee, 0x5f, 0x2c, 0xd4, 0xff, 0x9e, 0x3c, 0x01, 0x52, 0x85, 0x62, 0x94, 0x73, 0xca, 0x44, 0xb7,
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinshape_clock_fall_xpm[1] = {{ png, sizeof( png ), "pinshape_clock_fall_xpm" }};
//EOF

31
bitmaps_png/cpp_16/pinshape_clock_invert.cpp
View File

@ -1,31 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0xe6, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x00, 0x83, 0x90,
0xce, 0xe0, 0x2e, 0x06, 0x7c, 0x20, 0x64, 0x65, 0xc8, 0x6a, 0x0a, 0x15, 0x1c, 0x0b, 0xde, 0x87,
0x4f, 0xda, 0x27, 0xe4, 0x5f, 0xc8, 0x69, 0x06, 0x86, 0x60, 0xd5, 0x90, 0x86, 0x90, 0x05, 0xa1,
0x45, 0xd1, 0x7c, 0x28, 0xd2, 0xe1, 0x9a, 0x21, 0x1f, 0x42, 0xef, 0x87, 0xac, 0x0e, 0xf5, 0x0e,
0xf9, 0x1a, 0x72, 0x23, 0x74, 0x7d, 0xc8, 0xbb, 0xe0, 0x3b, 0xa1, 0xd2, 0x70, 0xe9, 0x40, 0xe1,
0xe0, 0x3b, 0x21, 0x87, 0x43, 0x57, 0x87, 0xac, 0x0b, 0x79, 0x19, 0x3c, 0xad, 0x81, 0x89, 0x81,
0x21, 0x52, 0x3c, 0xe4, 0x76, 0xf0, 0x22, 0xb8, 0x82, 0xd0, 0x7d, 0x21, 0x77, 0x23, 0x45, 0x42,
0x56, 0x06, 0xef, 0x0b, 0xf9, 0x1f, 0x28, 0x06, 0xb5, 0x32, 0x37, 0xe4, 0x7b, 0xc8, 0x2a, 0x10,
0x04, 0x7a, 0x3e, 0x64, 0x4f, 0xf0, 0xa3, 0x08, 0xa9, 0x90, 0x95, 0xa1, 0x07, 0x43, 0xfe, 0x47,
0x48, 0xc1, 0x15, 0xfc, 0x80, 0x2b, 0x08, 0xe5, 0x0f, 0xb9, 0x14, 0x7a, 0x39, 0x74, 0x5d, 0xf0,
0xfa, 0x90, 0xb7, 0x21, 0xf3, 0x1c, 0x58, 0x80, 0x96, 0x8a, 0x85, 0xdc, 0x0e, 0x59, 0x8c, 0xe4,
0xc8, 0x20, 0x99, 0x90, 0xc7, 0x21, 0x2f, 0x43, 0xd6, 0x86, 0x06, 0x86, 0xfc, 0x0c, 0xb9, 0x1b,
0xb2, 0x2d, 0xe4, 0x43, 0xf0, 0x4d, 0x98, 0x65, 0x30, 0x25, 0x46, 0x21, 0xbf, 0x83, 0x2f, 0x03,
0xdd, 0xa3, 0x1e, 0xdc, 0x1e, 0x32, 0x37, 0xa4, 0x20, 0x94, 0x07, 0x23, 0x24, 0x42, 0x77, 0x04,
0x6f, 0xa5, 0x75, 0x5c, 0x74, 0x87, 0xf4, 0x60, 0x97, 0x01, 0x00, 0x33, 0xe7, 0x5e, 0xdb, 0x57,
0x68, 0x71, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinshape_clock_invert_xpm[1] = {{ png, sizeof( png ), "pinshape_clock_invert_xpm" }};
//EOF

25
bitmaps_png/cpp_16/pinshape_clock_normal.cpp
View File

@ -1,25 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x7f, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x00, 0x83, 0x90,
0xce, 0xe0, 0x2e, 0x06, 0x7c, 0x20, 0x64, 0x65, 0xc8, 0x6a, 0x0a, 0x15, 0x1c, 0x0b, 0xde, 0x87,
0x4f, 0xda, 0x27, 0xe4, 0x5f, 0xc8, 0x69, 0x9c, 0xd2, 0xe1, 0x9a, 0x21, 0x1f, 0x42, 0xef, 0xe3,
0xb4, 0x22, 0x50, 0x38, 0xf8, 0x4e, 0xc8, 0xe1, 0xd0, 0xd5, 0x38, 0x15, 0x84, 0xee, 0x0b, 0xb9,
0x1b, 0x29, 0x12, 0xb2, 0x32, 0x78, 0x6b, 0xc8, 0x92, 0x90, 0x55, 0xe8, 0x10, 0xe8, 0xf9, 0x90,
0x3d, 0xc1, 0x8f, 0x22, 0xa4, 0xf0, 0x28, 0x08, 0xe5, 0x0f, 0xb9, 0x14, 0x7a, 0x39, 0x74, 0x1d,
0x1e, 0x6f, 0x06, 0xc9, 0x84, 0x3c, 0x0e, 0x79, 0x19, 0xb2, 0x16, 0x8f, 0x37, 0x83, 0x8c, 0x42,
0x7e, 0x07, 0x5f, 0xc6, 0x1b, 0x50, 0xa1, 0x3b, 0x82, 0xb7, 0xd2, 0x3a, 0x2e, 0xba, 0x43, 0x7a,
0xb0, 0xcb, 0x00, 0x00, 0x81, 0xd8, 0x45, 0xe3, 0xc4, 0x63, 0xdf, 0xe9, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinshape_clock_normal_xpm[1] = {{ png, sizeof( png ), "pinshape_clock_normal_xpm" }};
//EOF

26
bitmaps_png/cpp_16/pinshape_invert.cpp
View File

@ -1,26 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x8a, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x08, 0xb9, 0x1d, 0x62,
0xc5, 0x80, 0x0f, 0x84, 0xfc, 0x0f, 0x09, 0xa5, 0x8b, 0x82, 0x60, 0x97, 0x90, 0xee, 0x90, 0x49,
0xc1, 0x5e, 0x0c, 0x8c, 0x58, 0x15, 0x84, 0x4c, 0x0c, 0xf9, 0x17, 0x72, 0x38, 0xe4, 0x44, 0xc8,
0xdf, 0xe0, 0x39, 0x58, 0x14, 0x04, 0xb7, 0x84, 0xfc, 0x0d, 0xf5, 0x06, 0xb3, 0xfd, 0x61, 0x2c,
0x54, 0x13, 0xb6, 0x84, 0x1c, 0x82, 0xf3, 0x4e, 0x87, 0xdc, 0x0a, 0x59, 0x85, 0x80, 0xc1, 0xed,
0x20, 0x05, 0xbb, 0x42, 0x0e, 0xc3, 0x14, 0x04, 0x9f, 0x0a, 0xb9, 0x8b, 0xac, 0x20, 0xa4, 0x0f,
0xa4, 0xa0, 0x27, 0xe4, 0x6f, 0x88, 0x27, 0x58, 0xda, 0x05, 0xe8, 0x8a, 0x00, 0x0c, 0x2b, 0xc2,
0xc2, 0x82, 0x97, 0x02, 0x95, 0xec, 0x0f, 0xd9, 0x03, 0x24, 0x17, 0x62, 0xf7, 0x26, 0x63, 0x48,
0x50, 0xc8, 0xbc, 0xe0, 0x45, 0xc1, 0xc1, 0x03, 0x14, 0xd4, 0xb7, 0xf0, 0x47, 0x37, 0x00, 0xd8,
0x16, 0x51, 0x62, 0xd6, 0x1c, 0x5c, 0x96, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinshape_invert_xpm[1] = {{ png, sizeof( png ), "pinshape_invert_xpm" }};
//EOF

29
bitmaps_png/cpp_16/pinshape_nonlogic.cpp
View File

@ -1,29 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0xbc, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x40, 0x03, 0x21,
0x21, 0x21, 0x56, 0x40, 0x7c, 0x83, 0x81, 0x5c, 0x00, 0xd4, 0x1c, 0x0a, 0xc4, 0xff, 0x87, 0xa0,
0x01, 0x07, 0xd4, 0x9c, 0x4d, 0xf7, 0x2b, 0x38, 0x70, 0x20, 0x1b, 0xb0, 0x57, 0xd3, 0x49, 0x7e,
0xb7, 0x92, 0x8b, 0x1c, 0x51, 0x06, 0xec, 0x57, 0x73, 0xbc, 0x7f, 0x40, 0xcd, 0x71, 0x6f, 0x9c,
0x5f, 0x70, 0x0c, 0xc8, 0x80, 0x7d, 0x6a, 0x8e, 0xfa, 0x40, 0xb1, 0xd7, 0xfb, 0xd4, 0x1d, 0xbb,
0x88, 0x32, 0x00, 0xa6, 0x61, 0xab, 0xb6, 0xf3, 0xb5, 0x1c, 0xaf, 0x80, 0xff, 0x20, 0x36, 0xd0,
0xc0, 0x83, 0xfb, 0xb5, 0x1d, 0x78, 0x88, 0xf6, 0x06, 0xc8, 0x90, 0x3d, 0xea, 0x4e, 0x5f, 0xf6,
0xaa, 0x3b, 0xfe, 0xdf, 0xa8, 0xeb, 0xfc, 0x24, 0x3a, 0x30, 0x68, 0x1d, 0xd0, 0x35, 0xab, 0xd0,
0x71, 0x70, 0x70, 0x70, 0x17, 0x4e, 0x03, 0xf6, 0x12, 0x61, 0x00, 0x10, 0x77, 0xe2, 0xf5, 0x42,
0x36, 0xd4, 0x0b, 0xfb, 0xd5, 0x1c, 0x0e, 0x11, 0xed, 0x05, 0xa0, 0x86, 0xc7, 0xd8, 0x02, 0x71,
0xbf, 0x9a, 0x53, 0x0f, 0x71, 0x06, 0xa8, 0x3b, 0x98, 0xa0, 0x47, 0x23, 0x28, 0x0a, 0x89, 0x8e,
0xc6, 0x61, 0x90, 0x94, 0x61, 0x20, 0x28, 0x28, 0xc8, 0x1a, 0x18, 0xcf, 0x77, 0x88, 0x55, 0x0f,
0x00, 0x78, 0x38, 0x82, 0x55, 0x32, 0xc1, 0x1d, 0x9f, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pinshape_nonlogic_xpm[1] = {{ png, sizeof( png ), "pinshape_nonlogic_xpm" }};
//EOF

20
bitmaps_png/cpp_16/pinshape_normal.cpp
View File

@ -1,20 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x29, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x08, 0xbe, 0x19, 0x6a,
0xc9, 0x80, 0x0f, 0x84, 0xfc, 0x0f, 0x09, 0x1d, 0x16, 0x0a, 0x8e, 0x85, 0xac, 0xc2, 0x05, 0x83,
0xdb, 0x89, 0x52, 0x30, 0x0c, 0xc2, 0x21, 0xf8, 0x4e, 0x88, 0x15, 0x3e, 0x79, 0x00, 0x0e, 0xde,
0x3b, 0xa2, 0x47, 0x12, 0x08, 0xc2, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE pinshape_normal_xpm[1] = {{ png, sizeof( png ), "pinshape_normal_xpm" }};
//EOF

27
bitmaps_png/cpp_16/pintype_3states.cpp
View File

@ -1,27 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0xa1, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x20, 0x04, 0x42,
0x79, 0x10, 0xec, 0x00, 0x81, 0x28, 0x41, 0x18, 0x64, 0x60, 0x84, 0xca, 0x86, 0x7c, 0x0a, 0x71,
0x66, 0x60, 0x08, 0x9e, 0x10, 0xf2, 0x1f, 0x0d, 0x4e, 0x02, 0x8a, 0xba, 0x84, 0x7c, 0x62, 0x00,
0x32, 0x83, 0x80, 0x4c, 0xbd, 0x90, 0x77, 0x21, 0x4f, 0x83, 0x23, 0x83, 0x5d, 0x80, 0xd0, 0x2b,
0xf8, 0x7e, 0xc8, 0x9b, 0x60, 0x6d, 0xa0, 0x68, 0x70, 0xc8, 0x7f, 0xa8, 0x02, 0xa0, 0x61, 0x66,
0x21, 0x9f, 0x42, 0xd7, 0x84, 0x32, 0x37, 0x30, 0x85, 0x2c, 0x0f, 0xf9, 0x14, 0x64, 0x0a, 0x12,
0x43, 0x51, 0x00, 0x54, 0xe2, 0x14, 0xf2, 0x3d, 0x64, 0x56, 0xc8, 0xec, 0x90, 0x6f, 0x21, 0x0e,
0x10, 0x11, 0x34, 0x05, 0x40, 0x01, 0xdf, 0x90, 0x5f, 0x40, 0xe8, 0x03, 0xe7, 0x43, 0x14, 0x04,
0x1f, 0x09, 0x59, 0x05, 0x87, 0x87, 0x80, 0x10, 0x99, 0x87, 0xa1, 0x00, 0x15, 0x1e, 0x42, 0xb3,
0x02, 0x1d, 0x60, 0xb8, 0x81, 0x56, 0x0a, 0xc0, 0x41, 0x8d, 0x43, 0x01, 0x28, 0xa8, 0x91, 0x23,
0x0b, 0x7f, 0x54, 0xe2, 0x00, 0x00, 0x06, 0x78, 0x71, 0x58, 0x64, 0x23, 0x0f, 0xc1, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_3states_xpm[1] = {{ png, sizeof( png ), "pintype_3states_xpm" }};
//EOF

24
bitmaps_png/cpp_16/pintype_bidi.cpp
View File

@ -1,24 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x6a, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0xa0, 0x17, 0x48,
0xe0, 0x08, 0x99, 0x18, 0xac, 0x07, 0xe3, 0x05, 0x6b, 0x84, 0x4c, 0xf5, 0xe5, 0x42, 0x95, 0xde,
0x1e, 0xf2, 0x3e, 0x58, 0x03, 0xc6, 0x0f, 0x57, 0x0e, 0x79, 0x13, 0xb2, 0x17, 0xae, 0x24, 0x94,
0x2d, 0x64, 0x73, 0xc8, 0x87, 0x50, 0x33, 0x64, 0x13, 0x03, 0xf5, 0x43, 0x5e, 0x87, 0x1c, 0x0a,
0xe5, 0xc1, 0x21, 0x8d, 0xa2, 0x24, 0xf4, 0x6c, 0xc8, 0xaf, 0x90, 0x3d, 0x21, 0xab, 0xb0, 0xc0,
0x5d, 0x21, 0x3f, 0x42, 0x1e, 0x12, 0xa1, 0x80, 0x2d, 0x74, 0x53, 0xc8, 0x87, 0x60, 0x73, 0x9c,
0x56, 0x30, 0x60, 0x55, 0x82, 0x24, 0x4d, 0x84, 0x37, 0x89, 0x08, 0x28, 0xda, 0x02, 0x00, 0xbe,
0xc5, 0x4f, 0x49, 0xf5, 0x7c, 0x65, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_bidi_xpm[1] = {{ png, sizeof( png ), "pintype_bidi_xpm" }};
//EOF

22
bitmaps_png/cpp_16/pintype_input.cpp
View File

@ -1,22 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x53, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0xc0, 0x03, 0x82,
0x2c, 0x42, 0xae, 0xe0, 0x93, 0x67, 0x08, 0x09, 0x0d, 0xf9, 0x4f, 0x8e, 0x82, 0xe0, 0x98, 0xd0,
0x1c, 0xfc, 0x0a, 0xe2, 0x43, 0xfe, 0x85, 0x54, 0xe1, 0xb5, 0x22, 0x38, 0x15, 0xa8, 0xa4, 0x16,
0xaf, 0x1b, 0x20, 0x4a, 0xc0, 0x0a, 0x82, 0x27, 0x84, 0xac, 0xc2, 0x06, 0x43, 0xcf, 0x86, 0xfc,
0x0f, 0x39, 0x40, 0x8c, 0x02, 0x3c, 0x56, 0xd4, 0xe0, 0x77, 0x64, 0x0d, 0xf9, 0xde, 0x24, 0x18,
0x50, 0x94, 0xc7, 0x05, 0x6a, 0x74, 0x03, 0x00, 0xcd, 0xee, 0x50, 0x75, 0x42, 0x50, 0x19, 0xa1,
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_input_xpm[1] = {{ png, sizeof( png ), "pintype_input_xpm" }};
//EOF

20
bitmaps_png/cpp_16/pintype_nic.cpp
View File

@ -1,20 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x29, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0xc0, 0x03, 0x82,
0x2c, 0x42, 0xae, 0xe0, 0x93, 0x67, 0x08, 0x09, 0x0d, 0xf9, 0x3f, 0x34, 0x14, 0x04, 0x4f, 0x08,
0x59, 0x85, 0x02, 0x43, 0x49, 0x55, 0x30, 0x3c, 0xc2, 0x81, 0x50, 0x74, 0x03, 0x00, 0x62, 0x02,
0x30, 0x29, 0xdb, 0x94, 0xf7, 0x27, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE pintype_nic_xpm[1] = {{ png, sizeof( png ), "pintype_nic_xpm" }};
//EOF

29
bitmaps_png/cpp_16/pintype_noconnect.cpp
View File

@ -1,29 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0xc1, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x20, 0x13, 0x04,
0x05, 0x05, 0x59, 0x84, 0x84, 0x84, 0x5c, 0x21, 0x57, 0x3f, 0x03, 0x50, 0x73, 0x28, 0x10, 0xff,
0x67, 0xd8, 0xaf, 0xe2, 0x60, 0xb1, 0x5f, 0xc1, 0x81, 0x03, 0x9f, 0xe2, 0x3d, 0x6a, 0x2e, 0x4a,
0x40, 0x75, 0x32, 0xd8, 0x0d, 0x50, 0x73, 0x7c, 0xb1, 0x5f, 0xd5, 0x71, 0x07, 0x2e, 0x43, 0xf6,
0x69, 0x38, 0x1a, 0x03, 0xd5, 0xbc, 0xdb, 0xa7, 0xe6, 0xd8, 0x86, 0xd5, 0x80, 0x83, 0x2a, 0x76,
0x86, 0x40, 0x05, 0x6f, 0x0e, 0xa8, 0x3b, 0xee, 0x3c, 0x26, 0x63, 0xc9, 0x89, 0xac, 0x08, 0x24,
0x77, 0x40, 0xcd, 0xf1, 0x2d, 0x36, 0x39, 0xb8, 0x01, 0x30, 0x85, 0xe8, 0x86, 0xe0, 0xd3, 0x8c,
0x61, 0x00, 0xba, 0x21, 0x47, 0x80, 0xe1, 0x82, 0x4f, 0x33, 0x56, 0x03, 0x60, 0x86, 0x00, 0xfd,
0xfa, 0x79, 0x9f, 0xba, 0xd3, 0xdf, 0xd5, 0x7a, 0x2e, 0x2f, 0xa3, 0x02, 0x83, 0xd7, 0x02, 0x15,
0xad, 0xc2, 0x81, 0x8f, 0xe1, 0x30, 0xc0, 0xe1, 0xcb, 0x5e, 0x35, 0xa0, 0x01, 0xfa, 0x2e, 0x2f,
0x48, 0x32, 0x00, 0xd9, 0xcf, 0x20, 0x2f, 0xe0, 0x0a, 0x58, 0x9c, 0x81, 0x88, 0xee, 0x67, 0x7c,
0xb1, 0x83, 0x11, 0x8d, 0xb8, 0x02, 0x0c, 0x9f, 0x21, 0xd4, 0x4b, 0x48, 0x14, 0x27, 0x65, 0x8a,
0x33, 0x13, 0xa5, 0xd9, 0x19, 0x00, 0x87, 0x79, 0xc4, 0x97, 0x2f, 0x3c, 0xf4, 0x53, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_noconnect_xpm[1] = {{ png, sizeof( png ), "pintype_noconnect_xpm" }};
//EOF

36
bitmaps_png/cpp_16/pintype_notspecif.cpp
View File

@ -1,36 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x01, 0x31, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x18, 0xfa, 0x20,
0x22, 0x22, 0x42, 0x21, 0x24, 0x24, 0x64, 0x09, 0x10, 0xaf, 0xc2, 0x85, 0x2b, 0x5d, 0xfd, 0x0e,
0xcc, 0x30, 0xf3, 0xb8, 0xb1, 0xd0, 0xc8, 0xf5, 0xc1, 0x14, 0x4b, 0x8f, 0x2b, 0x19, 0x3e, 0x41,
0x5b, 0x41, 0x7a, 0x82, 0x82, 0x82, 0xe4, 0x19, 0x40, 0x04, 0x2e, 0x03, 0xc2, 0x83, 0x82, 0xd7,
0x2c, 0x31, 0x70, 0x7b, 0x7c, 0xd8, 0xc4, 0xef, 0xff, 0x83, 0xe9, 0x4b, 0xfe, 0xbf, 0xd8, 0xb4,
0xfb, 0xff, 0xb5, 0x92, 0xb6, 0xff, 0x7b, 0xd5, 0x1c, 0xff, 0x76, 0xd9, 0x7a, 0x9d, 0x08, 0x0d,
0x0d, 0x95, 0xc3, 0xeb, 0xba, 0xfd, 0xaa, 0x4e, 0x13, 0xf6, 0xab, 0x39, 0xfe, 0x7f, 0xbe, 0x6e,
0xc7, 0xff, 0xb7, 0x87, 0x4e, 0xfe, 0xbf, 0x5e, 0xd6, 0xfe, 0xff, 0xf7, 0xc7, 0xcf, 0xff, 0xcf,
0x47, 0xe7, 0xff, 0xdf, 0x07, 0x34, 0x64, 0xbf, 0x86, 0x83, 0x03, 0x4e, 0xcd, 0x3b, 0xb4, 0xdd,
0x85, 0x80, 0x9a, 0x7f, 0x81, 0x0c, 0x38, 0x66, 0x13, 0xf2, 0xff, 0x90, 0xa1, 0xf7, 0x7f, 0x10,
0xfb, 0xf3, 0x8d, 0xbb, 0xff, 0xaf, 0x97, 0x77, 0x80, 0xd9, 0xfb, 0xd5, 0x1c, 0x76, 0xe1, 0x34,
0xe0, 0x80, 0x9a, 0x93, 0x27, 0x44, 0x11, 0x02, 0x5f, 0xaf, 0xe8, 0xfc, 0xff, 0xed, 0xe1, 0xd3,
0xff, 0x20, 0x2f, 0x41, 0xc5, 0x3e, 0xe3, 0x34, 0x00, 0xe8, 0x44, 0x2f, 0x64, 0xcd, 0xa7, 0x7c,
0x92, 0x81, 0xce, 0xff, 0xf4, 0xff, 0x84, 0x4b, 0x34, 0xb2, 0xa1, 0x6f, 0x70, 0x1a, 0xb0, 0x47,
0xc3, 0x59, 0x18, 0xe6, 0x05, 0x10, 0x06, 0x69, 0xbc, 0x92, 0x53, 0x87, 0xe2, 0xa2, 0xfd, 0xaa,
0x8e, 0x3b, 0x88, 0x0a, 0x44, 0x10, 0xbe, 0x98, 0x5c, 0xfe, 0xff, 0xe9, 0xb2, 0x8d, 0x70, 0xcd,
0xa0, 0x40, 0xdc, 0xa7, 0xe2, 0x68, 0x8f, 0xd7, 0x80, 0x6d, 0x2a, 0x9e, 0xec, 0xfb, 0xd5, 0x9c,
0x96, 0x83, 0x34, 0x9c, 0x74, 0x8f, 0x43, 0x76, 0xc1, 0xb7, 0x7d, 0xea, 0x8e, 0x49, 0x44, 0x27,
0x36, 0x60, 0x68, 0xbb, 0x80, 0x5c, 0x73, 0x40, 0xdd, 0x71, 0x29, 0xd0, 0xe6, 0x2a, 0x60, 0xf4,
0x29, 0x30, 0x0c, 0x1f, 0x00, 0x00, 0xd5, 0xf4, 0xd6, 0x6c, 0xb0, 0x8a, 0x50, 0x2e, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_notspecif_xpm[1] = {{ png, sizeof( png ), "pintype_notspecif_xpm" }};
//EOF

33
bitmaps_png/cpp_16/pintype_opencoll.cpp
View File

@ -1,33 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0xff, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x20, 0x00, 0x42,
0x43, 0x43, 0x85, 0xb4, 0x4b, 0x16, 0xbf, 0x91, 0x6a, 0x3c, 0xf2, 0x1f, 0x0b, 0xbe, 0x8f, 0x57,
0x73, 0x40, 0x40, 0x80, 0x40, 0x48, 0x48, 0xc8, 0x19, 0xcf, 0xd8, 0xcc, 0x67, 0x6a, 0x15, 0x6b,
0xb3, 0xa4, 0x1b, 0x0f, 0x87, 0x22, 0x63, 0xc9, 0x86, 0xa3, 0x76, 0x38, 0x35, 0x47, 0x47, 0x47,
0xf3, 0x01, 0x35, 0x9f, 0x00, 0xe2, 0xc7, 0xe1, 0xe1, 0xe1, 0xca, 0x0c, 0xa4, 0x80, 0xd8, 0xd8,
0x58, 0x6e, 0xa0, 0xd3, 0x0f, 0x02, 0x35, 0xbf, 0x00, 0x6a, 0xd6, 0x24, 0x49, 0xb3, 0xaf, 0xaf,
0x2f, 0x17, 0x50, 0xe3, 0x01, 0x20, 0x7e, 0x09, 0x34, 0x44, 0x8b, 0xa0, 0x86, 0xe0, 0xe0, 0xe0,
0x2e, 0xa0, 0xe2, 0x55, 0x48, 0xf8, 0x39, 0x10, 0xbf, 0x25, 0x4a, 0x33, 0x08, 0x00, 0x15, 0xf7,
0x21, 0x1b, 0x00, 0xd4, 0xf8, 0x14, 0x48, 0x7f, 0x02, 0xd2, 0x36, 0x20, 0x79, 0x4f, 0x4f, 0x4f,
0x76, 0x20, 0xbf, 0x96, 0x68, 0x2f, 0x40, 0x35, 0xac, 0x06, 0xe2, 0x1f, 0x61, 0x61, 0x61, 0x91,
0x40, 0x7a, 0x17, 0xd0, 0xb0, 0x1d, 0x24, 0x85, 0x03, 0x50, 0x03, 0x33, 0x50, 0xf3, 0x42, 0xa0,
0xe6, 0x7f, 0x40, 0xfc, 0x1f, 0xe8, 0xcd, 0x45, 0xa4, 0x1a, 0x20, 0x01, 0xd4, 0x78, 0x11, 0xa4,
0x19, 0x84, 0x49, 0x72, 0x01, 0xd4, 0x0b, 0x7d, 0x20, 0x5b, 0x81, 0xf4, 0x14, 0x20, 0xbe, 0x05,
0xc4, 0xc7, 0x18, 0xc8, 0x05, 0x40, 0x83, 0xe6, 0x03, 0x5d, 0xb0, 0x75, 0x88, 0x18, 0x20, 0xd1,
0x70, 0x5c, 0x01, 0x3d, 0xc3, 0x58, 0x67, 0xb4, 0xed, 0xb7, 0x4d, 0x6f, 0x3a, 0x87, 0x2e, 0x0e,
0x52, 0x8b, 0x61, 0x80, 0x64, 0xe3, 0x91, 0x3e, 0x1c, 0xd9, 0x16, 0x03, 0x4b, 0x37, 0x1e, 0x9d,
0x00, 0xd2, 0x03, 0x00, 0x89, 0x3b, 0xa8, 0x3a, 0xc8, 0xf0, 0xfb, 0x49, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_opencoll_xpm[1] = {{ png, sizeof( png ), "pintype_opencoll_xpm" }};
//EOF

31
bitmaps_png/cpp_16/pintype_openemit.cpp
View File

@ -1,31 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0xde, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0xc0, 0x01, 0xa4,
0x9b, 0x8e, 0x5a, 0x4a, 0x35, 0x1e, 0xf9, 0x0d, 0xc4, 0xff, 0x71, 0xe0, 0x2e, 0x06, 0x7c, 0x40,
0xa1, 0x61, 0x3f, 0x87, 0x64, 0xc3, 0x91, 0x20, 0xe9, 0xc6, 0xc3, 0xa1, 0x20, 0xec, 0x98, 0x5c,
0xf9, 0xd7, 0x30, 0x7f, 0x7a, 0x0f, 0x8c, 0x2f, 0xde, 0x7c, 0x50, 0x91, 0x81, 0x14, 0x10, 0x12,
0x12, 0xf2, 0x3f, 0x38, 0x38, 0x38, 0x8c, 0x81, 0x5c, 0x40, 0x91, 0x01, 0x40, 0xcd, 0xcd, 0x40,
0xfc, 0x37, 0x28, 0x28, 0xc8, 0x82, 0x1c, 0xcd, 0x4d, 0x20, 0xcd, 0x40, 0xdb, 0xe3, 0x49, 0xd6,
0x0c, 0xd4, 0xd4, 0x08, 0xd4, 0xfc, 0x0f, 0x88, 0xd3, 0x69, 0xa7, 0x39, 0x34, 0x34, 0xd4, 0x06,
0xa8, 0x28, 0x14, 0x0d, 0x4f, 0x82, 0x3a, 0x3b, 0x89, 0x18, 0x9b, 0xee, 0x83, 0x42, 0x18, 0x1d,
0x03, 0x0d, 0x5e, 0x47, 0x76, 0x94, 0x01, 0x0d, 0xcd, 0x80, 0x3a, 0xbf, 0x06, 0x49, 0xcc, 0x10,
0x18, 0x0b, 0xf2, 0xa4, 0x84, 0x7e, 0x0a, 0xc8, 0x1b, 0x40, 0x97, 0xd4, 0x01, 0xb1, 0x19, 0x90,
0xfd, 0x16, 0x68, 0x80, 0x24, 0xa9, 0x51, 0x98, 0x02, 0xb4, 0x19, 0xe4, 0x92, 0x9f, 0x20, 0x17,
0xa5, 0xa5, 0xa5, 0xb1, 0x92, 0x64, 0x00, 0xd0, 0x66, 0x3f, 0xa0, 0xc6, 0x5f, 0xd0, 0x70, 0xf9,
0x4a, 0xaa, 0xed, 0x11, 0x40, 0xfc, 0x14, 0x88, 0x6f, 0x01, 0xf1, 0x03, 0x97, 0x84, 0xe2, 0x7b,
0xb0, 0x8c, 0x04, 0xc3, 0x92, 0x4d, 0x47, 0x6c, 0x89, 0x36, 0x10, 0x98, 0x7d, 0xef, 0x63, 0xc9,
0xd2, 0xf7, 0x01, 0xf6, 0xc5, 0x94, 0xd3, 0x71, 0x77, 0xb7, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x49,
0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_openemit_xpm[1] = {{ png, sizeof( png ), "pintype_openemit_xpm" }};
//EOF

22
bitmaps_png/cpp_16/pintype_output.cpp
View File

@ -1,22 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x54, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x08, 0xb9, 0x12, 0x64,
0xc1, 0x80, 0x0f, 0x84, 0xfc, 0x0f, 0x09, 0xa5, 0xbe, 0x82, 0x60, 0x8d, 0x90, 0xa9, 0xbe, 0x5c,
0x78, 0x14, 0x84, 0x2b, 0x87, 0xbc, 0x09, 0xd9, 0x0b, 0x55, 0x82, 0xdd, 0x8a, 0x40, 0xfd, 0x90,
0xd7, 0x21, 0x87, 0x42, 0x79, 0xf0, 0xb8, 0x01, 0xae, 0x04, 0xa8, 0xe0, 0x58, 0xc8, 0x2a, 0xac,
0x70, 0x57, 0xc8, 0x8f, 0x90, 0x87, 0x44, 0x29, 0x20, 0x68, 0x05, 0xe9, 0x8e, 0x24, 0xe8, 0x4d,
0x82, 0x01, 0x45, 0x62, 0x5c, 0x10, 0x88, 0x6e, 0x00, 0xd8, 0x97, 0x53, 0x93, 0x2a, 0x95, 0x06,
0x90, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_output_xpm[1] = {{ png, sizeof( png ), "pintype_output_xpm" }};
//EOF

21
bitmaps_png/cpp_16/pintype_passive.cpp
View File

@ -1,21 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x41, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0xc0, 0x03, 0x42,
0x2d, 0x43, 0x2f, 0xe3, 0x93, 0x67, 0x08, 0x0e, 0x0b, 0xf9, 0xcf, 0x10, 0xcb, 0x4d, 0x40, 0x41,
0xc8, 0x9b, 0x60, 0x2f, 0xfc, 0x0a, 0x7e, 0x87, 0x46, 0xd1, 0x58, 0x41, 0xe8, 0xdf, 0x90, 0x13,
0x21, 0xab, 0x70, 0xc0, 0x63, 0xc4, 0x28, 0xa0, 0x83, 0x23, 0x09, 0x06, 0x14, 0xc1, 0xa0, 0x26,
0x18, 0x59, 0x84, 0xa2, 0x1b, 0x00, 0x0a, 0x15, 0x4d, 0x41, 0xae, 0x97, 0xe2, 0x12, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_passive_xpm[1] = {{ png, sizeof( png ), "pintype_passive_xpm" }};
//EOF

24
bitmaps_png/cpp_16/pintype_powerinput.cpp
View File

@ -1,24 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x69, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0xc0, 0x03, 0x42,
0x6d, 0x42, 0x1e, 0xe0, 0x93, 0x67, 0x08, 0x09, 0x0d, 0xf9, 0x8f, 0x21, 0x18, 0x9c, 0x14, 0xbc,
0x22, 0xd4, 0x09, 0xa7, 0x82, 0x60, 0xed, 0x90, 0xff, 0x40, 0xf8, 0x33, 0xd4, 0x0f, 0x87, 0x82,
0x70, 0xb5, 0x90, 0x7f, 0x08, 0x25, 0x58, 0xad, 0x08, 0xcd, 0x47, 0x28, 0x01, 0x2b, 0x08, 0x32,
0x0a, 0x59, 0x18, 0xb2, 0x0a, 0x05, 0x9e, 0x07, 0x2b, 0xf8, 0x1f, 0xf2, 0x37, 0x64, 0x19, 0x50,
0x41, 0xc8, 0x43, 0x28, 0x17, 0x0b, 0x0c, 0xfe, 0x47, 0x8c, 0x02, 0x82, 0x56, 0x10, 0x74, 0x24,
0x89, 0xde, 0x24, 0x18, 0x50, 0x04, 0x83, 0x9a, 0x88, 0xc8, 0x42, 0x8f, 0x6e, 0x00, 0xc6, 0x02,
0x8c, 0xa5, 0x1f, 0x1f, 0xfc, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE pintype_powerinput_xpm[1] = {{ png, sizeof( png ), "pintype_powerinput_xpm" }};
//EOF

23
bitmaps_png/cpp_16/pintype_poweroutput.cpp
View File

@ -1,23 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x66, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x08, 0xbe, 0x1f, 0x62,
0xcb, 0x80, 0x0f, 0x84, 0xfc, 0x0f, 0x0e, 0x23, 0x51, 0x41, 0x48, 0x7a, 0xc8, 0xca, 0x20, 0x0b,
0x9c, 0x0a, 0x82, 0x2c, 0x42, 0xfe, 0x03, 0xe1, 0xb7, 0x60, 0x17, 0x5c, 0x0a, 0x8c, 0x42, 0xfe,
0xa1, 0x28, 0xc1, 0x62, 0x45, 0x15, 0x58, 0x01, 0x4c, 0x09, 0x90, 0x71, 0x2c, 0x64, 0x15, 0x1a,
0x7c, 0x0f, 0x53, 0x12, 0xe2, 0xcc, 0x00, 0x65, 0xe2, 0x82, 0xaf, 0x89, 0x52, 0x40, 0xc8, 0x0a,
0x82, 0x8e, 0x44, 0x55, 0x10, 0x6c, 0x42, 0xc0, 0x9b, 0xa1, 0x36, 0x04, 0x02, 0x0a, 0x28, 0x52,
0x10, 0xbc, 0x22, 0xd4, 0x92, 0xf8, 0xc8, 0x22, 0x14, 0xdd, 0x00, 0xe9, 0xf8, 0x8d, 0x50, 0x39,
0xfb, 0xe6, 0x18, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE pintype_poweroutput_xpm[1] = {{ png, sizeof( png ), "pintype_poweroutput_xpm" }};
//EOF

25
bitmaps_png/cpp_16/small_down.cpp
View File

@ -1,25 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x7c, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x20, 0x0d, 0x84,
0x1c, 0x0e, 0x39, 0x8c, 0x5f, 0xc1, 0xff, 0x90, 0xff, 0x43, 0x55, 0x41, 0x88, 0x67, 0xb0, 0x2f,
0xba, 0x82, 0x60, 0xdf, 0x10, 0x4f, 0x84, 0x82, 0x0f, 0x21, 0xff, 0x43, 0xeb, 0x90, 0x15, 0x84,
0xd6, 0x01, 0x59, 0x1f, 0xe0, 0x0a, 0x82, 0x93, 0x42, 0xfe, 0x00, 0x05, 0xa6, 0x87, 0x32, 0x83,
0x14, 0x00, 0xc9, 0xe9, 0x40, 0xfa, 0x4f, 0x70, 0x12, 0x92, 0x25, 0x40, 0x03, 0xbf, 0x02, 0x05,
0x37, 0x80, 0x14, 0x84, 0xac, 0x04, 0xe2, 0x1f, 0xa1, 0x21, 0x68, 0xee, 0x08, 0xb2, 0x0e, 0x79,
0x0b, 0x96, 0x06, 0xc1, 0xb7, 0x41, 0xd6, 0x58, 0x9c, 0x1a, 0xaa, 0x15, 0xf2, 0x10, 0x2c, 0xfd,
0x30, 0x54, 0x0b, 0x87, 0x27, 0x83, 0x64, 0x42, 0x3f, 0x87, 0x7e, 0x0e, 0x92, 0x21, 0x29, 0x7e,
0x01, 0xfb, 0x71, 0x4a, 0x16, 0x3a, 0x02, 0x89, 0x04, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE small_down_xpm[1] = {{ png, sizeof( png ), "small_down_xpm" }};
//EOF

24
bitmaps_png/cpp_16/small_edit.cpp
View File

@ -1,24 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x76, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x20, 0x0b, 0x30,
0x06, 0x4f, 0x08, 0x79, 0x17, 0xec, 0x85, 0x53, 0x3e, 0xa4, 0x2c, 0xe4, 0x3f, 0x10, 0xfe, 0xc0,
0xae, 0x84, 0x31, 0x42, 0x2a, 0x4a, 0x30, 0xf4, 0x2c, 0x58, 0xc9, 0x5b, 0x2c, 0xd2, 0x21, 0x53,
0x43, 0x9e, 0x87, 0x6b, 0x42, 0x94, 0x04, 0x4f, 0xc0, 0x26, 0x0d, 0xd2, 0x09, 0x56, 0x12, 0x52,
0xc6, 0xc0, 0x88, 0x5d, 0x1a, 0xac, 0x24, 0x54, 0x1a, 0xd3, 0xe5, 0x93, 0xe1, 0xd2, 0xff, 0x43,
0x66, 0x61, 0xe8, 0xa6, 0xa5, 0x34, 0x03, 0xd0, 0x69, 0xef, 0x43, 0xfe, 0x41, 0xa5, 0xa7, 0x62,
0x48, 0x03, 0x15, 0xfc, 0x4f, 0xe0, 0x08, 0x79, 0x10, 0xf2, 0x17, 0x87, 0x34, 0x44, 0x01, 0x90,
0x7c, 0x81, 0xc5, 0x70, 0x98, 0x02, 0x1c, 0x76, 0x13, 0x07, 0x00, 0x91, 0x69, 0x5c, 0x4e, 0x04,
0xa5, 0x09, 0x33, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE small_edit_xpm[1] = {{ png, sizeof( png ), "small_edit_xpm" }};
//EOF

21
bitmaps_png/cpp_16/small_folder.cpp
View File

@ -1,21 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x41, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0xa0, 0x02, 0x08,
0xf5, 0x0e, 0x79, 0x1a, 0xf2, 0x1f, 0x04, 0x83, 0xef, 0x47, 0x28, 0x60, 0x51, 0x10, 0xf2, 0x18,
0x22, 0x8d, 0x53, 0x09, 0x42, 0x1a, 0x0d, 0x3e, 0x0e, 0xf1, 0xc4, 0xaf, 0xe0, 0x7f, 0xf0, 0x23,
0x02, 0x0a, 0x42, 0xfe, 0x0f, 0x21, 0x05, 0x8f, 0x09, 0x79, 0xd3, 0x13, 0xbb, 0x92, 0xe0, 0x47,
0xa1, 0x1e, 0xd4, 0x88, 0x4a, 0x00, 0xf9, 0x20, 0xc7, 0x91, 0x41, 0xad, 0xcf, 0x14, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE small_folder_xpm[1] = {{ png, sizeof( png ), "small_folder_xpm" }};
//EOF

25
bitmaps_png/cpp_16/small_library.cpp
View File

@ -1,25 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x87, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x20, 0x0c, 0x42,
0xda, 0x42, 0xbe, 0x87, 0xb4, 0x61, 0xd2, 0x08, 0x05, 0x3f, 0x43, 0xfe, 0x87, 0xfc, 0x44, 0xa2,
0xbf, 0x00, 0xe9, 0x3f, 0x51, 0x82, 0x08, 0x05, 0xff, 0x41, 0x10, 0x41, 0x87, 0x1e, 0x07, 0xd1,
0xc1, 0xc1, 0x38, 0x15, 0x04, 0x37, 0x82, 0x59, 0x33, 0x70, 0x9b, 0x60, 0x03, 0x36, 0xe1, 0x3e,
0x4e, 0x05, 0x0e, 0x2c, 0x21, 0x1f, 0x40, 0xac, 0x50, 0x15, 0x1c, 0x0a, 0x80, 0xac, 0x0d, 0x60,
0x76, 0x16, 0x4e, 0x05, 0xc1, 0xd9, 0x60, 0x13, 0xd6, 0xe3, 0x56, 0xa0, 0x0a, 0x66, 0x7f, 0x4a,
0x63, 0xc5, 0xa1, 0x00, 0xc8, 0xbe, 0x07, 0x36, 0xc3, 0x06, 0xa7, 0x82, 0xe0, 0x99, 0x60, 0x9f,
0x34, 0xe2, 0x54, 0x10, 0x1a, 0x02, 0xe6, 0x1d, 0xc3, 0x1a, 0xd4, 0x20, 0x10, 0x25, 0x18, 0xf2,
0x07, 0xc8, 0xfb, 0x82, 0x35, 0xb2, 0x50, 0xa3, 0x90, 0x20, 0x00, 0x00, 0xa7, 0xe8, 0xa6, 0x84,
0x88, 0xd9, 0xa3, 0x64, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE small_library_xpm[1] = {{ png, sizeof( png ), "small_library_xpm" }};
//EOF

20
bitmaps_png/cpp_16/small_plus.cpp
View File

@ -1,20 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x28, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x20, 0x0d, 0x84,
0x1c, 0x0e, 0x39, 0x8c, 0x5f, 0xc1, 0xff, 0x90, 0xff, 0x83, 0x52, 0x01, 0xd0, 0xe5, 0xff, 0x71,
0xc0, 0xc3, 0xc4, 0x29, 0x18, 0x12, 0xde, 0x24, 0x29, 0xb2, 0x30, 0x01, 0x00, 0x09, 0x8d, 0x42,
0xfd, 0xea, 0x15, 0xea, 0xb3, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60,
0x82,
};
const BITMAP_OPAQUE small_plus_xpm[1] = {{ png, sizeof( png ), "small_plus_xpm" }};
//EOF

33
bitmaps_png/cpp_16/small_refresh.cpp
View File

@ -1,33 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x01, 0x01, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x20, 0x16, 0x84,
0xf2, 0x84, 0x54, 0x86, 0x1c, 0x08, 0xf9, 0x18, 0xf2, 0x32, 0xe4, 0x62, 0x48, 0x53, 0xa8, 0x1c,
0x03, 0x43, 0xb0, 0x61, 0x88, 0x03, 0x5c, 0x3a, 0xd8, 0x1d, 0x28, 0xf1, 0x1f, 0x09, 0x7e, 0x0b,
0x4d, 0x08, 0x79, 0x11, 0xf2, 0x3b, 0x81, 0x03, 0x22, 0xed, 0x15, 0xf2, 0x03, 0x28, 0xb8, 0x3f,
0xd8, 0x2b, 0x54, 0x28, 0x54, 0x28, 0xc4, 0x36, 0x78, 0x29, 0x54, 0xd9, 0x2b, 0xb0, 0xb4, 0x1f,
0x2f, 0x50, 0xed, 0xff, 0x90, 0x0e, 0x98, 0x69, 0x9e, 0xec, 0x21, 0x7b, 0x42, 0x1e, 0x82, 0x15,
0x1c, 0x03, 0x0b, 0x84, 0x54, 0x85, 0xfc, 0x0f, 0xdd, 0x87, 0x70, 0x4d, 0x94, 0x20, 0xd0, 0x25,
0x10, 0x13, 0xf6, 0x42, 0x2c, 0x88, 0x09, 0xbe, 0x1f, 0xa8, 0x8f, 0xec, 0xe0, 0x00, 0x81, 0x50,
0xe3, 0x60, 0xdf, 0x90, 0xb6, 0x48, 0x11, 0x06, 0x8a, 0x40, 0x90, 0x63, 0x68, 0x20, 0x24, 0x04,
0xf8, 0x43, 0x57, 0x84, 0xb6, 0x87, 0x24, 0x86, 0xda, 0xa3, 0x5a, 0x13, 0xf2, 0x39, 0xe4, 0x4f,
0x1a, 0x2b, 0x90, 0x19, 0xd6, 0x0f, 0xf3, 0x7d, 0xa8, 0x19, 0x42, 0x41, 0x48, 0x2d, 0x50, 0x64,
0x33, 0x84, 0xb9, 0x18, 0x24, 0x19, 0x7c, 0x33, 0x64, 0x6e, 0x28, 0x0f, 0x5c, 0xda, 0x3f, 0xe4,
0x77, 0xc8, 0xbf, 0x20, 0x3b, 0x08, 0xe7, 0x3c, 0x50, 0xef, 0x2f, 0xa0, 0xa2, 0x93, 0xa1, 0xe1,
0x91, 0xe2, 0xd1, 0x7c, 0xc0, 0x80, 0x9a, 0x1f, 0xf2, 0x0f, 0xc8, 0xaf, 0x82, 0xa9, 0xbe, 0x12,
0xf2, 0x29, 0xc8, 0x3a, 0xe4, 0x1e, 0x4a, 0x50, 0x7f, 0x0d, 0x29, 0x83, 0xdb, 0x16, 0x29, 0x12,
0x2a, 0x0d, 0x0a, 0xcf, 0xe0, 0xd4, 0xd0, 0x83, 0xc1, 0x8f, 0x42, 0xde, 0x87, 0x9e, 0x0d, 0xe9,
0x0e, 0x55, 0x24, 0xda, 0xb3, 0x00, 0x5c, 0xc0, 0x7b, 0x87, 0x52, 0x03, 0xb1, 0x79, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE small_refresh_xpm[1] = {{ png, sizeof( png ), "small_refresh_xpm" }};
//EOF

25
bitmaps_png/cpp_16/small_trash.cpp
View File

@ -1,25 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x84, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x20, 0x1e, 0x04,
0x2b, 0x85, 0x7c, 0x09, 0xf9, 0x0f, 0x84, 0x3f, 0x83, 0x4d, 0xd0, 0xa4, 0x42, 0x3e, 0x81, 0x25,
0xd0, 0xe1, 0xcf, 0x00, 0x01, 0x98, 0x82, 0x8f, 0x58, 0x15, 0xfc, 0x80, 0x2b, 0x20, 0x08, 0x1a,
0x98, 0x42, 0xfe, 0x62, 0xe8, 0xff, 0xdb, 0xc0, 0x84, 0xec, 0x8a, 0x6f, 0xe8, 0x0a, 0x82, 0xbf,
0xa2, 0x3a, 0xf3, 0x35, 0x86, 0x09, 0xaf, 0x50, 0x15, 0xdc, 0x45, 0x57, 0x10, 0x7a, 0x07, 0x55,
0xc1, 0x39, 0x0c, 0x2b, 0xce, 0xa2, 0x28, 0x08, 0xdd, 0x8d, 0x61, 0xc2, 0x2e, 0x14, 0x05, 0x41,
0xcb, 0x31, 0xdc, 0xb0, 0x0c, 0xd5, 0x8a, 0x89, 0x18, 0x26, 0x4c, 0x40, 0x55, 0x90, 0x8b, 0xea,
0xd1, 0xd0, 0xef, 0xc1, 0x79, 0x28, 0x0a, 0xfc, 0x78, 0x43, 0x4f, 0x05, 0xff, 0x83, 0x3b, 0xf0,
0x5f, 0xe8, 0xa9, 0x68, 0x3e, 0x22, 0x43, 0x19, 0x00, 0xa3, 0xeb, 0xa5, 0x87, 0x9e, 0x7e, 0xaa,
0xb0, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE small_trash_xpm[1] = {{ png, sizeof( png ), "small_trash_xpm" }};
//EOF

25
bitmaps_png/cpp_16/small_up.cpp
View File

@ -1,25 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x7d, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x20, 0x05, 0x04,
0xc9, 0x84, 0x7c, 0x0e, 0xf9, 0x1c, 0x24, 0x83, 0x43, 0x3a, 0x54, 0x2b, 0xe4, 0x61, 0xc8, 0x7f,
0x20, 0x7c, 0x18, 0xaa, 0x85, 0x4d, 0xb7, 0x75, 0xc8, 0x5b, 0xb0, 0x34, 0x08, 0xbe, 0x0d, 0xb2,
0x46, 0x93, 0x0e, 0xf6, 0x0d, 0xf9, 0x0a, 0x94, 0xd8, 0x00, 0x96, 0x5e, 0x09, 0xc4, 0x3f, 0x42,
0x43, 0x90, 0xa5, 0x93, 0x42, 0xfe, 0x00, 0x05, 0xa7, 0x87, 0x32, 0x83, 0x14, 0x00, 0xc9, 0xe9,
0x40, 0xfa, 0x4f, 0x70, 0x12, 0x5c, 0x41, 0xc8, 0x07, 0xa0, 0x70, 0x1d, 0x98, 0x05, 0x54, 0x00,
0x76, 0x4f, 0x1d, 0x90, 0xf5, 0x01, 0xa1, 0xc0, 0x33, 0xd8, 0x17, 0xca, 0x82, 0x2a, 0x00, 0x5b,
0xea, 0x89, 0xc5, 0xa9, 0x08, 0x05, 0x38, 0xc0, 0xd0, 0x50, 0x70, 0x38, 0xe4, 0x30, 0x03, 0x69,
0x00, 0x00, 0xba, 0xfb, 0x4a, 0x14, 0x4a, 0xdc, 0xac, 0x14, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45,
0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE small_up_xpm[1] = {{ png, sizeof( png ), "small_up_xpm" }};
//EOF

38
bitmaps_png/cpp_16/small_warning.cpp
View File

@ -1,38 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x01, 0x49, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0xb5, 0x93, 0xbd, 0x4a, 0xc4,
0x40, 0x14, 0x85, 0x03, 0x82, 0x36, 0x2a, 0x5a, 0x58, 0x6b, 0x91, 0xcc, 0x18, 0x54, 0x14, 0xb4,
0x14, 0x2c, 0x44, 0xb0, 0x13, 0xf4, 0x11, 0xac, 0x7c, 0x01, 0xdf, 0xc0, 0xc6, 0xc6, 0x4e, 0x2c,
0xac, 0x2d, 0xac, 0xec, 0xec, 0x65, 0x0b, 0x75, 0x26, 0xb3, 0xb2, 0x92, 0x42, 0xf6, 0x01, 0x74,
0x8d, 0x90, 0x25, 0xd9, 0x3b, 0x13, 0x15, 0xbc, 0x4e, 0xfe, 0x96, 0xcd, 0xee, 0x46, 0x77, 0x05,
0x03, 0x07, 0x02, 0xf7, 0x9c, 0x6f, 0xe6, 0x90, 0x1b, 0xc3, 0xf8, 0xaf, 0x47, 0xdd, 0x9b, 0x1b,
0x92, 0x93, 0x17, 0xad, 0x1b, 0xbf, 0x3a, 0x37, 0x35, 0x54, 0x18, 0xdd, 0x85, 0x51, 0x1d, 0xac,
0x4b, 0x77, 0x0f, 0xa1, 0xb6, 0x8d, 0x92, 0x59, 0x27, 0x43, 0x01, 0x24, 0xa3, 0x87, 0x52, 0xac,
0x20, 0xb4, 0x02, 0x04, 0xff, 0x09, 0x35, 0xec, 0x23, 0xba, 0x9b, 0x27, 0x03, 0x85, 0x43, 0x61,
0xce, 0x28, 0x4e, 0x9a, 0xb2, 0xba, 0x86, 0x00, 0x80, 0x10, 0x3c, 0xc7, 0x80, 0x58, 0x57, 0x83,
0x75, 0xe7, 0xd6, 0x69, 0x12, 0x10, 0xab, 0x29, 0x20, 0x6c, 0xe4, 0x00, 0x8c, 0x98, 0xb5, 0xf5,
0x63, 0xf8, 0xdd, 0xb1, 0x6c, 0x6d, 0xfc, 0x8c, 0xcd, 0x10, 0x57, 0x48, 0x00, 0x5e, 0x1b, 0xa0,
0xf5, 0x80, 0x97, 0xc6, 0x48, 0xf9, 0xe9, 0x8c, 0x5c, 0xb7, 0xcd, 0x62, 0x39, 0x03, 0xbc, 0x75,
0x02, 0x50, 0x31, 0xba, 0xdf, 0x3f, 0x2c, 0xc8, 0x66, 0xa7, 0x51, 0x3a, 0x8b, 0x29, 0xa0, 0xe5,
0x17, 0x00, 0x5a, 0x0d, 0xbc, 0x35, 0x27, 0x8b, 0x9f, 0x4d, 0x5f, 0x4b, 0x77, 0x7f, 0x2c, 0x02,
0xec, 0x0c, 0x10, 0x74, 0x03, 0x10, 0x18, 0x39, 0x2a, 0x00, 0x80, 0xd3, 0x83, 0x6e, 0x93, 0xe4,
0x34, 0xed, 0x1f, 0xbe, 0x62, 0xef, 0x8c, 0x28, 0x25, 0xec, 0xd9, 0xf4, 0xf4, 0x0a, 0x9d, 0xc8,
0x36, 0xae, 0xd7, 0xa8, 0x17, 0x49, 0xba, 0xbb, 0xd8, 0x77, 0xc6, 0xc9, 0x45, 0xbe, 0x34, 0xc7,
0x25, 0x06, 0x04, 0xaf, 0x92, 0xa8, 0x64, 0xfe, 0xa5, 0xf7, 0x65, 0xdd, 0xd0, 0x2f, 0xde, 0x1f,
0x01, 0xa8, 0x1c, 0x7a, 0xa6, 0xfb, 0x93, 0xf3, 0x32, 0xc3, 0x2f, 0x8a, 0x80, 0xd1, 0x9d, 0xfc,
0xe7, 0x19, 0x6f, 0xd6, 0x96, 0xa6, 0x87, 0x11, 0xd6, 0xcd, 0xb1, 0x38, 0xfb, 0x0d, 0xe0, 0xc8,
0xd4, 0x7c, 0x8b, 0xdd, 0x33, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE small_warning_xpm[1] = {{ png, sizeof( png ), "small_warning_xpm" }};
//EOF

26
bitmaps_png/cpp_16/tree_nosel.cpp
View File

@ -1,26 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x8a, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x8d, 0x91, 0xe9, 0x0d, 0x80,
0x20, 0x14, 0x83, 0x9d, 0x40, 0xd7, 0x10, 0x07, 0xf4, 0x9a, 0x45, 0x25, 0xf1, 0x1a, 0xc1, 0x50,
0x98, 0x42, 0x9d, 0x47, 0x3c, 0x22, 0x8a, 0x44, 0x48, 0x78, 0xfd, 0xd9, 0x0f, 0xfa, 0x28, 0x41,
0xe0, 0x3f, 0x53, 0x82, 0x82, 0x51, 0x46, 0x51, 0x08, 0xf2, 0x33, 0x45, 0xc4, 0x46, 0x48, 0xec,
0x4a, 0x12, 0xc3, 0x14, 0x1a, 0x36, 0xd6, 0xd7, 0x7c, 0xb4, 0x7c, 0x90, 0xf3, 0xf4, 0x6e, 0x51,
0xa7, 0xb3, 0xa5, 0x15, 0x90, 0x6a, 0x17, 0x5e, 0x5a, 0xed, 0x4b, 0xf9, 0x1d, 0x40, 0x9d, 0x40,
0x7d, 0xdf, 0xd0, 0x38, 0x81, 0xca, 0x2f, 0x42, 0x10, 0xc7, 0x92, 0x1b, 0x62, 0xf5, 0x0e, 0x0c,
0x36, 0x80, 0xb7, 0xba, 0xe4, 0x10, 0xcb, 0x0f, 0x98, 0x8d, 0x2e, 0x4f, 0xa4, 0xff, 0x04, 0x6d,
0xbc, 0x35, 0x6c, 0x55, 0x38, 0x61, 0xd9, 0xf5, 0x59, 0x3c, 0x7d, 0xb3, 0x7d, 0xe6, 0x00, 0xea,
0x47, 0x00, 0xdc, 0xd2, 0x84, 0x60, 0x72, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE tree_nosel_xpm[1] = {{ png, sizeof( png ), "tree_nosel_xpm" }};
//EOF

29
bitmaps_png/cpp_16/tree_sel.cpp
View File

@ -1,29 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0xf3, 0xff,
0x61, 0x00, 0x00, 0x00, 0xbf, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0xa0, 0x05, 0x90,
0x68, 0x38, 0xa4, 0x25, 0xd9, 0x78, 0xa4, 0x52, 0xaa, 0xe1, 0xc8, 0x7c, 0x10, 0x06, 0xb1, 0x25,
0x9b, 0x8f, 0x6b, 0x12, 0xd4, 0xa8, 0xd4, 0x71, 0x86, 0x5f, 0xaa, 0xf1, 0xe8, 0x32, 0xa9, 0xc6,
0x23, 0xff, 0x80, 0xf8, 0x3f, 0x1a, 0xfe, 0x07, 0x34, 0x6c, 0xa9, 0x50, 0xc3, 0x09, 0x3e, 0x9c,
0x9a, 0xa5, 0x1b, 0x8f, 0x5c, 0xc6, 0xa2, 0x11, 0x1d, 0x5f, 0xc2, 0x6a, 0x08, 0xd4, 0xe6, 0xff,
0xc4, 0x60, 0xe9, 0x86, 0x23, 0x8b, 0x31, 0xfc, 0x8c, 0xc3, 0xd9, 0xb8, 0xf0, 0x3f, 0x94, 0x30,
0x91, 0x6c, 0x3a, 0x52, 0x45, 0x82, 0x66, 0x08, 0x6e, 0x3a, 0x52, 0x81, 0x70, 0x3e, 0x28, 0xb4,
0x49, 0x35, 0xa0, 0xe1, 0xe8, 0x5c, 0x24, 0xff, 0x1f, 0x9e, 0x47, 0xb2, 0x01, 0x8d, 0x47, 0xe6,
0x50, 0xcf, 0x0b, 0xa0, 0x00, 0x21, 0x31, 0x10, 0xff, 0x4a, 0x35, 0x1c, 0xd3, 0x40, 0x8d, 0x46,
0x60, 0x22, 0x21, 0x3a, 0x1a, 0x1b, 0x8f, 0x2e, 0xc2, 0x48, 0x07, 0xa0, 0xc4, 0x01, 0x4a, 0x24,
0x44, 0x18, 0x70, 0x11, 0x67, 0x6a, 0x84, 0x1a, 0xb2, 0x04, 0x87, 0x77, 0xfe, 0x82, 0x6c, 0xc6,
0xa9, 0x19, 0x19, 0x40, 0xc2, 0xe4, 0x70, 0x39, 0x2c, 0x33, 0x49, 0x35, 0x1d, 0x2d, 0xc3, 0xf0,
0x33, 0xb5, 0x00, 0x00, 0xa5, 0xe5, 0x6b, 0x5a, 0x58, 0xd3, 0x35, 0x83, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE tree_sel_xpm[1] = {{ png, sizeof( png ), "tree_sel_xpm" }};
//EOF

19
bitmaps_png/cpp_16/triangle_down.cpp
View File

@ -1,19 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x24, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x18, 0x05, 0xc8,
0xa0, 0x9c, 0xe1, 0x3f, 0x1a, 0xac, 0xc7, 0xaf, 0xa4, 0x1e, 0xbf, 0x29, 0xf5, 0xf8, 0x2d, 0xaa,
0xc7, 0xe7, 0x96, 0x06, 0x20, 0xa4, 0x37, 0x00, 0x00, 0x13, 0xe8, 0x18, 0xc5, 0xba, 0x45, 0x45,
0xda, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE triangle_down_xpm[1] = {{ png, sizeof( png ), "triangle_down_xpm" }};
//EOF

20
bitmaps_png/cpp_16/triangle_right.cpp
View File

@ -1,20 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x00, 0x30, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x63, 0x60, 0x18, 0x00, 0xd0,
0x41, 0x48, 0xc1, 0x7f, 0x42, 0x4a, 0xfe, 0x13, 0x52, 0xf2, 0x9f, 0x90, 0x92, 0xff, 0x84, 0x94,
0xc0, 0x14, 0xd4, 0xe3, 0x57, 0x50, 0x8f, 0xdf, 0x8a, 0x7a, 0xfc, 0x8e, 0xac, 0xc7, 0xef, 0xcd,
0x06, 0xba, 0x47, 0x0d, 0x00, 0x87, 0xf7, 0x19, 0x11, 0xb1, 0x1b, 0x8d, 0xb6, 0x00, 0x00, 0x00,
0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE triangle_right_xpm[1] = {{ png, sizeof( png ), "triangle_right_xpm" }};
//EOF

34
bitmaps_png/cpp_16/visibility.cpp
View File

@ -1,34 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x01, 0x10, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x75, 0x91, 0xbd, 0x4e, 0x42,
0x51, 0x10, 0x84, 0x4f, 0x23, 0xbe, 0x0b, 0xe8, 0x83, 0x58, 0x92, 0x33, 0x27, 0x04, 0x4b, 0x4c,
0xcc, 0x7d, 0x04, 0x23, 0x2d, 0x24, 0xa2, 0x40, 0xb8, 0x81, 0x68, 0xa3, 0xf0, 0x20, 0xfe, 0x54,
0x42, 0x8f, 0x40, 0x2d, 0x96, 0x68, 0xc5, 0x81, 0xd3, 0x61, 0x3e, 0x8b, 0x7b, 0x2f, 0x81, 0x04,
0x67, 0xbb, 0x9d, 0xc9, 0xce, 0xee, 0x8e, 0x31, 0x29, 0xdc, 0xa9, 0x62, 0x4d, 0xb5, 0xd6, 0x5a,
0x53, 0xdb, 0x29, 0x9e, 0x98, 0x5d, 0x9c, 0x1d, 0xdb, 0x7b, 0xfd, 0x8a, 0x9d, 0xda, 0xa8, 0xe7,
0x72, 0x5b, 0xda, 0xbd, 0xed, 0x91, 0x59, 0xbd, 0xa6, 0x12, 0x3d, 0x1c, 0xa4, 0x11, 0xb6, 0x9b,
0x78, 0xa7, 0xc3, 0xcf, 0xa9, 0x33, 0x60, 0x40, 0x9d, 0xf2, 0xd6, 0xc8, 0x16, 0x8c, 0x62, 0x21,
0x4a, 0x0c, 0xf8, 0xc1, 0xf3, 0xce, 0x10, 0xcf, 0x37, 0x03, 0x4a, 0x89, 0xa4, 0x6d, 0x34, 0x13,
0x17, 0x4c, 0x08, 0x2c, 0xb9, 0xe2, 0x8e, 0x26, 0x55, 0x3c, 0x81, 0x0f, 0x2a, 0x08, 0x37, 0x31,
0x5a, 0x45, 0x7c, 0x11, 0x08, 0x0c, 0xb9, 0x25, 0x10, 0x68, 0x32, 0x22, 0x10, 0x98, 0x13, 0x21,
0x6f, 0xe4, 0x23, 0xe6, 0x7b, 0x82, 0x46, 0x2a, 0xf8, 0x24, 0x42, 0x4b, 0xa3, 0x99, 0xa8, 0x30,
0x26, 0xe0, 0xa9, 0xd2, 0xe0, 0x86, 0x6b, 0x3c, 0x81, 0x71, 0x66, 0x61, 0x3b, 0xc9, 0x92, 0x4f,
0x2c, 0xf0, 0x0c, 0x19, 0xe1, 0x59, 0xf0, 0x98, 0x2e, 0x69, 0x5b, 0xa6, 0x78, 0xa2, 0x4d, 0x72,
0x54, 0x99, 0x1a, 0x7d, 0xfa, 0xd4, 0x76, 0xce, 0x74, 0x79, 0x63, 0x8c, 0x7a, 0xff, 0x3d, 0x4a,
0x71, 0x12, 0x53, 0x4e, 0x2f, 0x87, 0x68, 0xf7, 0x7c, 0x79, 0x94, 0x25, 0x99, 0xb3, 0xdd, 0xcc,
0x68, 0x1b, 0x56, 0xbc, 0xa5, 0x13, 0xd8, 0x82, 0xda, 0x6e, 0xa2, 0x95, 0x56, 0x6e, 0x62, 0x5b,
0x2e, 0x9f, 0xf5, 0xff, 0x00, 0xf4, 0xb2, 0x2f, 0xaf, 0x5b, 0x43, 0x74, 0xea, 0x00, 0x00, 0x00,
0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE visibility_xpm[1] = {{ png, sizeof( png ), "visibility_xpm" }};
//EOF

33
bitmaps_png/cpp_16/visibility_off.cpp
View File

@ -1,33 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x01, 0x07, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x6d, 0x91, 0xbd, 0x4e, 0x02,
0x51, 0x10, 0x85, 0xa7, 0x11, 0xdf, 0x05, 0xf0, 0x79, 0xf6, 0x31, 0x78, 0x0f, 0x13, 0x08, 0x1b,
0x88, 0x36, 0x58, 0x6b, 0xb6, 0x33, 0x41, 0xbc, 0xe7, 0xae, 0x42, 0x68, 0x8c, 0x09, 0x76, 0xec,
0x3e, 0x00, 0x95, 0x24, 0x86, 0x02, 0x96, 0xdb, 0x61, 0x3e, 0x8b, 0x5d, 0x7e, 0xe3, 0x99, 0xee,
0x7e, 0x27, 0x73, 0x66, 0xee, 0x98, 0x55, 0x4a, 0x6f, 0x14, 0x2b, 0xd3, 0x56, 0x5b, 0x65, 0xae,
0xab, 0xa6, 0x9d, 0x6a, 0x74, 0xad, 0x3b, 0xfd, 0x8a, 0x93, 0xda, 0xb9, 0x7e, 0x52, 0x3b, 0xe2,
0xf1, 0x19, 0x44, 0x24, 0x0c, 0xd1, 0x7b, 0x65, 0xf1, 0xf7, 0x97, 0x78, 0x40, 0x44, 0x1b, 0xe1,
0x7b, 0x65, 0x76, 0xd5, 0x3c, 0x65, 0x46, 0x4e, 0xce, 0x23, 0x11, 0x2d, 0x5e, 0xca, 0xa0, 0x86,
0x29, 0x16, 0xc2, 0x93, 0xb3, 0xa6, 0x60, 0xc1, 0x90, 0x88, 0x16, 0xaf, 0xf8, 0xb2, 0x5b, 0xc7,
0x7c, 0x2e, 0x26, 0x2c, 0x09, 0x14, 0x7c, 0xf0, 0x40, 0x44, 0x0b, 0xcf, 0x0f, 0x4b, 0xc6, 0x08,
0xcd, 0x4d, 0xc5, 0x94, 0x15, 0x81, 0xc0, 0x82, 0xc1, 0x01, 0x07, 0x02, 0x2b, 0xa6, 0x68, 0x63,
0xda, 0xec, 0x0d, 0xc3, 0x33, 0x5c, 0x19, 0xd6, 0xe6, 0x73, 0x31, 0x66, 0xc9, 0xe4, 0x02, 0x7f,
0xef, 0x23, 0x5c, 0x57, 0xe8, 0x24, 0x3b, 0x10, 0x58, 0x93, 0x55, 0x43, 0xba, 0xb6, 0xa9, 0xa9,
0xdd, 0x53, 0xb5, 0xd8, 0x27, 0x19, 0x19, 0x33, 0xd2, 0xc3, 0x7f, 0x8e, 0xea, 0x66, 0xe6, 0xfa,
0xcf, 0xdc, 0x96, 0x7b, 0x5f, 0x56, 0x6c, 0x66, 0x66, 0x49, 0xcd, 0xbd, 0xe9, 0x3f, 0x9c, 0x7e,
0x5d, 0x55, 0xd7, 0x48, 0x6a, 0xbe, 0xa7, 0xdd, 0xf9, 0xb1, 0x14, 0x1f, 0x70, 0x29, 0xd7, 0x50,
0x47, 0x73, 0x15, 0x2a, 0x34, 0x77, 0xed, 0x51, 0x7d, 0xff, 0xfe, 0x07, 0x23, 0x85, 0x6a, 0x56,
0xd7, 0x11, 0x97, 0x8f, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE visibility_off_xpm[1] = {{ png, sizeof( png ), "visibility_off_xpm" }};
//EOF

39
bitmaps_png/cpp_16/www.cpp
View File

@ -1,39 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0xb5, 0xfa, 0x37,
0xea, 0x00, 0x00, 0x01, 0x67, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x65, 0x51, 0x4d, 0x4b, 0x42,
0x51, 0x10, 0x7d, 0xe8, 0xa6, 0x2f, 0x5c, 0xd7, 0x2a, 0xc8, 0xe8, 0x0f, 0x18, 0xfd, 0x82, 0x20,
0x5a, 0xb4, 0x71, 0xce, 0xbc, 0xb7, 0x30, 0x35, 0xa2, 0xa4, 0x5d, 0xe4, 0x2a, 0xa4, 0xf0, 0x2d,
0x0c, 0xfd, 0x07, 0xed, 0x22, 0x94, 0xd6, 0x6d, 0x4a, 0x9f, 0x3e, 0x5b, 0xf8, 0x8c, 0x50, 0x68,
0x57, 0x52, 0x41, 0x09, 0x56, 0xb4, 0x0c, 0x35, 0x82, 0x74, 0x63, 0xd3, 0xc5, 0x42, 0xe9, 0x1e,
0xb8, 0xcc, 0xcc, 0x3d, 0xf3, 0x71, 0xcf, 0x68, 0xda, 0xc0, 0x31, 0xe6, 0x60, 0x62, 0xcf, 0xf0,
0x6a, 0xff, 0x0f, 0xbb, 0x69, 0x0b, 0x35, 0x7a, 0xc1, 0x17, 0x3a, 0x78, 0xc5, 0x2d, 0xad, 0xb3,
0x7b, 0xe0, 0x39, 0xe0, 0x41, 0x11, 0x87, 0x7a, 0x98, 0x6f, 0x70, 0x20, 0xa8, 0xe9, 0x9b, 0x38,
0x42, 0x36, 0xe0, 0xe9, 0x3f, 0x9b, 0x2e, 0x14, 0x39, 0x22, 0x55, 0x6c, 0x22, 0xc4, 0x11, 0x67,
0x20, 0x2f, 0x5e, 0x94, 0xcf, 0x4d, 0x97, 0x22, 0xd0, 0x2e, 0x17, 0x78, 0xc1, 0xf0, 0xa2, 0xb5,
0x32, 0xf6, 0x43, 0x08, 0x8e, 0xa3, 0xe9, 0x9f, 0xa6, 0x79, 0x94, 0x39, 0xaa, 0x08, 0x78, 0xa2,
0x53, 0x54, 0xf1, 0x8e, 0x1e, 0x3e, 0x15, 0x3e, 0xc4, 0x6a, 0xe1, 0x9a, 0xcf, 0xe8, 0x51, 0x4d,
0xce, 0xb6, 0xaa, 0x13, 0xc6, 0xf1, 0xda, 0x08, 0x52, 0x48, 0xf1, 0x28, 0x32, 0xb4, 0xaa, 0x52,
0x2b, 0x34, 0xa3, 0x61, 0x99, 0x6d, 0xc4, 0x04, 0x39, 0x72, 0xe4, 0x2e, 0x0a, 0x62, 0x28, 0x23,
0xab, 0x62, 0x17, 0xb4, 0x28, 0x04, 0x38, 0x94, 0x10, 0xd8, 0x54, 0xa1, 0x04, 0x97, 0xb8, 0x24,
0x76, 0x45, 0x3c, 0x89, 0xf1, 0x25, 0x2d, 0x69, 0x3c, 0x0b, 0x47, 0x29, 0x11, 0xa4, 0xb4, 0x14,
0x95, 0x21, 0xa5, 0xdd, 0x09, 0x02, 0xaa, 0x85, 0xa3, 0x44, 0x43, 0x9d, 0x32, 0xd2, 0xa0, 0x21,
0x12, 0x35, 0x65, 0xbc, 0x1e, 0x9a, 0xdc, 0x45, 0x43, 0x22, 0x69, 0xd4, 0xd5, 0x2f, 0xf4, 0x38,
0xae, 0x64, 0x12, 0x1f, 0xb5, 0xfd, 0x53, 0x4a, 0x87, 0x49, 0x6a, 0xb3, 0x4f, 0x22, 0x55, 0x7d,
0xff, 0x57, 0xa8, 0x02, 0xed, 0x48, 0x13, 0x8b, 0x74, 0x45, 0x30, 0x90, 0x13, 0x6f, 0x9b, 0xad,
0xbe, 0x50, 0x4a, 0xea, 0x82, 0xf4, 0x0d, 0xe1, 0x9e, 0x93, 0x9c, 0xa4, 0x07, 0xb1, 0x32, 0x6c,
0xf1, 0xc4, 0xc0, 0x36, 0x4c, 0x17, 0x47, 0x50, 0xc3, 0x1b, 0x3a, 0xdc, 0xa5, 0x67, 0xdc, 0x61,
0xe3, 0x2f, 0x7b, 0x68, 0xdd, 0x5e, 0xc9, 0x0d, 0x0d, 0xaf, 0xfb, 0x1b, 0x15, 0xae, 0xa6, 0x09,
0xab, 0x9d, 0x52, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE www_xpm[1] = {{ png, sizeof( png ), "www_xpm" }};
//EOF

42
bitmaps_png/cpp_24/about.cpp
View File

@ -1,42 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x01, 0x97, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x95, 0x94, 0xb1, 0x4e, 0x1b,
0x41, 0x10, 0x86, 0x87, 0x1a, 0x2b, 0x1d, 0x05, 0xd8, 0x44, 0x28, 0xe0, 0x98, 0x3c, 0x4b, 0x08,
0x42, 0xde, 0x6f, 0xe4, 0x43, 0x0e, 0x2f, 0x80, 0xb1, 0x22, 0x25, 0x22, 0xe2, 0x35, 0xd2, 0x41,
0xa2, 0x34, 0xa9, 0xc0, 0x96, 0x4c, 0x28, 0x4c, 0x78, 0x13, 0x3b, 0x4a, 0x0b, 0x3d, 0xf8, 0x68,
0xce, 0xdc, 0x6a, 0x52, 0x00, 0xc6, 0xb7, 0x3e, 0xc0, 0xcc, 0x56, 0xb3, 0xb3, 0xdf, 0xbf, 0xff,
0xee, 0x68, 0x57, 0x24, 0x13, 0xfa, 0x9a, 0xa6, 0x9e, 0xd1, 0xe7, 0x9a, 0x6b, 0xfa, 0x7a, 0xa6,
0x3b, 0xd1, 0xa2, 0x3c, 0x16, 0x5a, 0x74, 0x07, 0xa4, 0x58, 0x30, 0x3c, 0xad, 0x68, 0x29, 0x67,
0xb9, 0xdb, 0x20, 0xc6, 0x48, 0xdc, 0x21, 0x91, 0x56, 0xb6, 0x66, 0xb7, 0x66, 0xb5, 0xe2, 0x36,
0x39, 0x22, 0xc1, 0x18, 0xe8, 0x7a, 0xa8, 0xfe, 0x09, 0x8f, 0xd1, 0x76, 0x6f, 0x42, 0xa1, 0xda,
0x32, 0x1d, 0x0c, 0x4f, 0x33, 0xab, 0xee, 0x49, 0xf5, 0xf3, 0x7d, 0xce, 0x1a, 0x17, 0x5c, 0xb0,
0x36, 0x92, 0xdb, 0xc5, 0xe3, 0x47, 0xbb, 0x54, 0x4b, 0xc4, 0x18, 0x5f, 0x1e, 0x04, 0x38, 0xc7,
0x30, 0xce, 0xc7, 0x66, 0xbe, 0x62, 0x0c, 0xa2, 0x85, 0xdb, 0xe4, 0x27, 0x46, 0x7b, 0xdc, 0xc6,
0x24, 0x20, 0xa2, 0xc7, 0x18, 0xdf, 0x6f, 0x2f, 0x32, 0x25, 0xc9, 0x7a, 0x0f, 0x2d, 0x89, 0x88,
0xe8, 0x0a, 0x09, 0x69, 0xb5, 0x24, 0x34, 0x31, 0x77, 0x28, 0x53, 0x04, 0x2d, 0xcc, 0x35, 0x84,
0x3f, 0x98, 0xdb, 0x0c, 0x4a, 0x39, 0x3b, 0x88, 0x50, 0xc7, 0xb4, 0x2b, 0xfc, 0xc3, 0x5c, 0x39,
0x28, 0xe5, 0x9c, 0x41, 0x44, 0x2b, 0x18, 0x7d, 0x21, 0xc6, 0xb4, 0x10, 0x00, 0x77, 0x5d, 0x0e,
0x80, 0x02, 0x46, 0xfc, 0x02, 0xa0, 0xfe, 0x0a, 0xe3, 0x4a, 0xdc, 0x5f, 0xac, 0xf6, 0x76, 0x1a,
0xc0, 0xad, 0x62, 0xf4, 0xf2, 0x0f, 0x9d, 0x0f, 0x7c, 0xc4, 0xb4, 0x2b, 0xba, 0x83, 0x71, 0x34,
0x0d, 0x40, 0x1b, 0x63, 0x5b, 0xa2, 0x45, 0x52, 0x92, 0xda, 0xf2, 0x73, 0x80, 0x2b, 0x33, 0xe4,
0x46, 0x8b, 0x22, 0xc2, 0x0f, 0x8c, 0xce, 0x33, 0xc0, 0x0c, 0xbf, 0x31, 0xf6, 0xef, 0x1e, 0x0e,
0x03, 0x4c, 0x77, 0x9f, 0xea, 0x83, 0xee, 0x61, 0x5c, 0x56, 0xe7, 0xef, 0xd3, 0x75, 0x3c, 0xfe,
0x01, 0x09, 0x3a, 0x3d, 0xa3, 0x7b, 0x78, 0xbc, 0xbe, 0x1f, 0x37, 0xd1, 0xc4, 0x63, 0x74, 0x74,
0x65, 0xe2, 0x25, 0x96, 0x39, 0xc1, 0xf0, 0xae, 0x11, 0x16, 0x3e, 0x30, 0xc0, 0x18, 0xd2, 0xa2,
0xee, 0x56, 0xb5, 0xa0, 0x85, 0xda, 0x3b, 0xea, 0xb4, 0x19, 0x62, 0x5c, 0x65, 0xd4, 0x47, 0x3e,
0xe7, 0xf8, 0xc6, 0xcd, 0xe4, 0x27, 0xe0, 0x7e, 0x8d, 0xbc, 0x4f, 0x46, 0xb5, 0xe4, 0x1a, 0x9c,
0xd2, 0x23, 0x26, 0xa6, 0xa7, 0x5d, 0xb6, 0xb5, 0x98, 0x5d, 0xf1, 0x1f, 0x21, 0x75, 0x15, 0xb0,
0xa8, 0xaf, 0xf2, 0x24, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE about_xpm[1] = {{ png, sizeof( png ), "about_xpm" }};
//EOF

40
bitmaps_png/cpp_24/add_aligned_dimension.cpp
View File

@ -1,40 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0x6c, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x20, 0x13, 0x84,
0x84, 0x84, 0x9c, 0x06, 0x62, 0x5b, 0x06, 0x5a, 0x81, 0xa0, 0xa0, 0x20, 0x6b, 0xa0, 0x05, 0x2f,
0x80, 0xb4, 0x23, 0x4d, 0x2c, 0x08, 0x0e, 0x0e, 0xd6, 0x00, 0xe2, 0x52, 0xaa, 0x5b, 0x12, 0x10,
0x10, 0x20, 0x00, 0x34, 0xb4, 0x03, 0x88, 0x9f, 0x07, 0x06, 0x06, 0x0a, 0x53, 0xd3, 0x27, 0x8c,
0x40, 0x83, 0xd2, 0x81, 0xf8, 0x2d, 0x10, 0xff, 0x07, 0xba, 0x3e, 0x1b, 0x3d, 0xb8, 0xb4, 0x4a,
0x97, 0xf5, 0x48, 0x35, 0x1e, 0x79, 0x02, 0xc4, 0x5f, 0x24, 0x1b, 0x8e, 0x2c, 0x14, 0x6d, 0xd8,
0xcf, 0x43, 0x92, 0x0d, 0xa1, 0xa1, 0xa1, 0x8b, 0x40, 0x86, 0x03, 0xf1, 0x0d, 0x07, 0x07, 0x07,
0x16, 0x64, 0x39, 0xe3, 0xc2, 0x19, 0xf9, 0x52, 0x0d, 0x87, 0xff, 0x03, 0x0d, 0x87, 0x63, 0x90,
0x25, 0xa4, 0xa4, 0x9a, 0x20, 0x20, 0x7e, 0x09, 0xc4, 0xd3, 0x81, 0xd8, 0x19, 0x5d, 0x5e, 0xaa,
0xe1, 0xe8, 0x54, 0x64, 0xc3, 0xa1, 0xf8, 0x23, 0x49, 0x86, 0x03, 0x83, 0xc5, 0x04, 0x97, 0x1a,
0xe9, 0x86, 0x23, 0xad, 0x58, 0x2c, 0x78, 0x40, 0x15, 0xc3, 0x41, 0x40, 0xb6, 0xe1, 0x88, 0x14,
0xd0, 0xc0, 0x37, 0x28, 0x41, 0xd4, 0x78, 0x34, 0x95, 0x2a, 0x86, 0xc3, 0x80, 0x64, 0xcb, 0x51,
0x79, 0xa9, 0x86, 0x23, 0xed, 0x40, 0xc3, 0xa7, 0x00, 0x83, 0xcc, 0x0d, 0x67, 0x6a, 0x81, 0x46,
0xa8, 0x37, 0x28, 0x65, 0x10, 0x6b, 0x38, 0x29, 0x29, 0x25, 0x33, 0x2c, 0x2c, 0x6c, 0x09, 0x4d,
0x0c, 0x87, 0x66, 0xa2, 0x77, 0xa0, 0xa4, 0x08, 0xb4, 0x68, 0x1a, 0xd5, 0xb3, 0x3f, 0xd0, 0xe0,
0x7e, 0x68, 0x3a, 0xbf, 0x05, 0xc4, 0x9e, 0xd4, 0x0a, 0x92, 0xb3, 0xa0, 0x9c, 0x08, 0x2a, 0x5b,
0x40, 0x11, 0x0a, 0xe4, 0xe7, 0xa3, 0x67, 0x22, 0x4a, 0x2d, 0xb0, 0x01, 0x85, 0x37, 0x90, 0xae,
0x00, 0x62, 0x21, 0x9a, 0x94, 0x8c, 0x30, 0x4b, 0x80, 0xd8, 0x81, 0x66, 0xe5, 0x3b, 0x5d, 0x2d,
0xd1, 0xcf, 0x9f, 0x51, 0x0e, 0x2a, 0xa8, 0x24, 0x1b, 0x8f, 0xf4, 0xc9, 0x36, 0x1f, 0x55, 0xa6,
0xaa, 0x25, 0x3a, 0xa5, 0x4b, 0xd1, 0xcb, 0x94, 0xf7, 0x32, 0x0d, 0xc7, 0x54, 0xa8, 0x66, 0x01,
0xd0, 0xc0, 0xdb, 0x98, 0x85, 0xd6, 0xd1, 0x1e, 0x6a, 0x5a, 0xf0, 0x12, 0x4b, 0xa9, 0x38, 0x87,
0x9a, 0x16, 0x4c, 0x41, 0xb7, 0x40, 0xa2, 0xf1, 0x88, 0x27, 0xf5, 0x2c, 0x68, 0x38, 0xc3, 0x05,
0x8c, 0xdc, 0x19, 0x40, 0x83, 0x5f, 0x49, 0x37, 0x1e, 0xb9, 0x0b, 0xa4, 0x93, 0x29, 0x31, 0x0f,
0x00, 0xf0, 0xd4, 0xf6, 0xde, 0xf4, 0x01, 0x5f, 0x30, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_aligned_dimension_xpm[1] = {{ png, sizeof( png ), "add_aligned_dimension_xpm" }};
//EOF

30
bitmaps_png/cpp_24/add_arc.cpp
View File

@ -1,30 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x00, 0xd3, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x18, 0x60, 0x10,
0x6a, 0x10, 0x5a, 0x14, 0xb2, 0x2a, 0xe4, 0x62, 0xc8, 0xbb, 0x90, 0x5f, 0x21, 0x87, 0xf1, 0x2a,
0xf5, 0xe3, 0x0d, 0x29, 0x09, 0xb9, 0x1e, 0xf2, 0x1f, 0x09, 0xe2, 0xd6, 0x90, 0xc6, 0x1a, 0x52,
0x0c, 0x34, 0x13, 0xa4, 0xe8, 0x59, 0xc8, 0xdc, 0x90, 0xb8, 0x50, 0xe3, 0x48, 0x91, 0x34, 0x56,
0x9c, 0xca, 0xc3, 0x35, 0x43, 0x2f, 0x80, 0x15, 0xef, 0x0f, 0xf5, 0x0e, 0x65, 0x26, 0xe8, 0xea,
0x10, 0xff, 0x90, 0x2f, 0x40, 0xc5, 0xb7, 0x83, 0xdd, 0x89, 0xf2, 0x64, 0x48, 0x5c, 0xc8, 0x6f,
0xa0, 0xf2, 0xc5, 0xa1, 0x3c, 0xc4, 0x29, 0xf7, 0x07, 0x2b, 0xaf, 0x27, 0x32, 0x08, 0x83, 0x55,
0x43, 0x3e, 0x85, 0xfc, 0x0f, 0xad, 0x23, 0x52, 0xb9, 0x03, 0x0b, 0xc8, 0xab, 0xc1, 0x8b, 0x88,
0x8e, 0x22, 0x60, 0x40, 0x02, 0xbd, 0x1a, 0xcb, 0x4d, 0xa4, 0xf2, 0x68, 0x3e, 0x50, 0xb8, 0x87,
0x7a, 0x10, 0x6f, 0x7e, 0x09, 0xd0, 0xfc, 0x03, 0x24, 0xa4, 0x99, 0xe0, 0x6b, 0x40, 0xf3, 0xbd,
0x89, 0x56, 0x1e, 0xa8, 0x0f, 0x4a, 0x04, 0x0e, 0x2c, 0xc4, 0xa7, 0xc9, 0x22, 0xa0, 0x86, 0xd9,
0x24, 0x38, 0x08, 0x98, 0x80, 0xff, 0x87, 0xc4, 0x91, 0xa2, 0xe1, 0x52, 0xc8, 0xff, 0x20, 0x23,
0x52, 0x34, 0xbc, 0x0d, 0xf9, 0x1f, 0x29, 0x42, 0x8a, 0x86, 0x9f, 0xc0, 0x30, 0x62, 0x23, 0x45,
0xc3, 0x61, 0x02, 0xd9, 0x8f, 0xae, 0x00, 0x00, 0xc3, 0x88, 0x59, 0x96, 0x0a, 0x1e, 0x95, 0x6a,
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_arc_xpm[1] = {{ png, sizeof( png ), "add_arc_xpm" }};
//EOF

66
bitmaps_png/cpp_24/add_board.cpp
View File

@ -1,66 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x03, 0x0c, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0xad, 0x95, 0x5d, 0x48, 0x93,
0x51, 0x18, 0xc7, 0xdf, 0x92, 0xd4, 0x6a, 0x60, 0x98, 0x9b, 0xd8, 0x92, 0x2e, 0xb2, 0x29, 0x78,
0x61, 0xa6, 0x77, 0x2a, 0xb5, 0x85, 0x53, 0x33, 0x35, 0x85, 0xba, 0x88, 0x20, 0x4a, 0xad, 0x39,
0x14, 0xab, 0xa9, 0xf3, 0xa6, 0x0c, 0x6f, 0x4d, 0x97, 0xb4, 0x59, 0x90, 0x8a, 0x97, 0x75, 0x93,
0x90, 0x74, 0x21, 0xd8, 0x36, 0x8c, 0xba, 0x68, 0xe6, 0x90, 0xac, 0xfc, 0x20, 0x09, 0xa1, 0xa2,
0xe5, 0xfc, 0xda, 0xa6, 0xdb, 0x24, 0xff, 0x9d, 0xf3, 0xea, 0x5e, 0xdf, 0x77, 0x1f, 0xba, 0x59,
0x07, 0x1e, 0xce, 0x39, 0xcf, 0x39, 0xfc, 0x7f, 0xe7, 0x3c, 0xe7, 0x39, 0xe7, 0x30, 0x0c, 0x2d,
0x55, 0x4c, 0x19, 0xb1, 0x91, 0xf8, 0xdb, 0xf1, 0xde, 0xc2, 0xae, 0x42, 0x50, 0x23, 0x6d, 0x10,
0x1f, 0x6b, 0x3e, 0x1f, 0x6d, 0x27, 0x36, 0x24, 0x72, 0x7d, 0x9e, 0x79, 0x8b, 0xba, 0x8a, 0x46,
0x48, 0x5d, 0xca, 0x04, 0x94, 0x6a, 0xa6, 0xd4, 0x27, 0x44, 0x45, 0x77, 0x09, 0xd8, 0x32, 0x43,
0x61, 0x85, 0x10, 0x40, 0x56, 0xfe, 0x9f, 0x01, 0x16, 0x7f, 0x80, 0x27, 0x12, 0x40, 0x5c, 0x7d,
0x1c, 0x0a, 0x0c, 0x05, 0xdb, 0x41, 0x3c, 0xfe, 0x00, 0x84, 0x0b, 0x88, 0x56, 0x45, 0xb3, 0xfd,
0xe4, 0xe6, 0x64, 0xce, 0x97, 0x6f, 0xc8, 0x67, 0xfb, 0x7c, 0x9d, 0xb0, 0x00, 0x52, 0xad, 0x94,
0xf3, 0xe7, 0xb6, 0xe7, 0xb2, 0x3e, 0x5a, 0xfb, 0x20, 0x74, 0x5c, 0xd6, 0x22, 0x83, 0xa8, 0x4e,
0xc4, 0xf6, 0xf7, 0xdf, 0xd8, 0x83, 0xa8, 0x9d, 0x00, 0xa2, 0x5a, 0x11, 0x94, 0x06, 0x25, 0x2b,
0x46, 0x6b, 0xb1, 0x46, 0xcc, 0xfa, 0xa9, 0x68, 0x4e, 0x47, 0x0e, 0xeb, 0xcf, 0xeb, 0xc8, 0x43,
0x4c, 0x4d, 0x8c, 0x60, 0xc5, 0x0f, 0x5a, 0x25, 0x98, 0xd4, 0x1d, 0xc1, 0x27, 0x9d, 0x14, 0xe5,
0x8d, 0x07, 0x42, 0x03, 0xa8, 0x25, 0xdc, 0x49, 0x80, 0x52, 0xbf, 0x09, 0x21, 0xb5, 0x44, 0x23,
0xe1, 0x20, 0xbe, 0x9d, 0xf0, 0x4d, 0xad, 0xcf, 0xc5, 0x54, 0x77, 0x36, 0xd6, 0xd7, 0x56, 0xe0,
0x9d, 0x9f, 0x66, 0x21, 0xdb, 0x02, 0x76, 0x82, 0xf8, 0x76, 0xb2, 0x05, 0xc8, 0xc3, 0xd4, 0xd3,
0x2c, 0xac, 0x7b, 0x5d, 0xf0, 0xda, 0x27, 0xc3, 0x03, 0x50, 0xa3, 0xe1, 0xe1, 0x87, 0x8b, 0x86,
0xcf, 0x37, 0x96, 0x7e, 0x2f, 0x1d, 0x9d, 0x43, 0x9d, 0x18, 0xff, 0x3e, 0x0e, 0xa7, 0xdb, 0x89,
0xb5, 0x35, 0x37, 0x3c, 0x73, 0x13, 0xb0, 0x5b, 0x7b, 0x51, 0xdb, 0x96, 0x15, 0x1a, 0x90, 0x59,
0xb7, 0x0f, 0xe5, 0x9a, 0x58, 0x88, 0x55, 0x7b, 0xb9, 0x83, 0xe4, 0x67, 0x55, 0x6c, 0x4d, 0x2c,
0xfa, 0xde, 0xf5, 0x61, 0xd5, 0xf6, 0x1b, 0x33, 0x1d, 0xdd, 0xb0, 0x94, 0x54, 0x62, 0x38, 0xa3,
0x90, 0x35, 0xda, 0xa6, 0xbe, 0x55, 0xdb, 0x9c, 0x10, 0xe0, 0x13, 0x68, 0x7f, 0x94, 0x8d, 0x89,
0xc7, 0xe9, 0xf8, 0xfa, 0xe2, 0x0a, 0xc6, 0x74, 0x47, 0x91, 0xac, 0x8e, 0x12, 0x64, 0x55, 0x52,
0x63, 0x12, 0x8c, 0x5f, 0x8c, 0xf8, 0xf5, 0xca, 0x88, 0xe1, 0x93, 0xe7, 0x60, 0x92, 0xc9, 0x83,
0x1a, 0x1d, 0x33, 0xa6, 0xca, 0x2f, 0x05, 0x00, 0xac, 0xfa, 0x34, 0x78, 0x6c, 0xe3, 0xa0, 0xe5,
0xe7, 0xeb, 0x66, 0xdc, 0xd4, 0x1e, 0x14, 0x00, 0x7a, 0xde, 0xf6, 0xb0, 0xe2, 0xa6, 0x54, 0x85,
0x40, 0xd0, 0x5a, 0xa5, 0x85, 0xf5, 0x7a, 0xa3, 0x3f, 0x68, 0xdd, 0x9c, 0xaa, 0xb8, 0x28, 0x00,
0x0c, 0xe8, 0x33, 0xf0, 0x63, 0xf0, 0x16, 0x56, 0xbe, 0x99, 0xf0, 0xf9, 0x49, 0x06, 0x4e, 0xd7,
0x47, 0x73, 0x00, 0xf5, 0x73, 0x35, 0xbb, 0xf5, 0x80, 0x95, 0x13, 0x98, 0x63, 0x71, 0x09, 0x0e,
0xfb, 0x7c, 0xb0, 0xdd, 0x2c, 0x0f, 0x1e, 0x57, 0x4a, 0xb8, 0x33, 0x38, 0x44, 0xe2, 0xde, 0xd6,
0x2a, 0xc6, 0xcb, 0xb6, 0x63, 0xb8, 0x4c, 0x73, 0x99, 0x77, 0x06, 0x03, 0x1f, 0x07, 0x30, 0xa3,
0xeb, 0x09, 0x14, 0x49, 0x53, 0xc0, 0xe5, 0x72, 0xc1, 0xe9, 0x70, 0x06, 0x0d, 0x97, 0xf1, 0x84,
0xbc, 0x35, 0xac, 0x2c, 0x9a, 0x9d, 0x9f, 0x85, 0xa5, 0xb4, 0x2a, 0x62, 0x80, 0x49, 0xa6, 0x18,
0x0d, 0xeb, 0x1e, 0xb8, 0x49, 0x1a, 0xfa, 0xc2, 0x63, 0xad, 0xd6, 0xb2, 0x61, 0xa1, 0xc2, 0xc1,
0x8c, 0x8e, 0xf1, 0xce, 0x64, 0x59, 0xf0, 0x9a, 0x86, 0xba, 0x64, 0x0e, 0xb7, 0x03, 0xc3, 0x99,
0xc5, 0x1b, 0x80, 0xca, 0x26, 0x38, 0x16, 0x16, 0x43, 0x03, 0xc8, 0xd8, 0xe8, 0x55, 0x0d, 0x3b,
0xd7, 0x2c, 0x93, 0x2f, 0x09, 0xfe, 0x83, 0x50, 0x6f, 0xd1, 0xb4, 0x6d, 0x1a, 0x96, 0xb2, 0xea,
0x88, 0x43, 0x64, 0x4e, 0x95, 0x7f, 0xa0, 0x3f, 0xda, 0xf9, 0xed, 0x5e, 0x53, 0x69, 0x93, 0x14,
0xfd, 0x63, 0xfd, 0x98, 0x79, 0xd8, 0xbb, 0x9b, 0x33, 0xb8, 0xbf, 0x71, 0x19, 0x2a, 0x99, 0x12,
0x22, 0xf6, 0x9e, 0x00, 0x3c, 0xfe, 0xff, 0x41, 0xca, 0xdd, 0x14, 0xa8, 0x9e, 0xa9, 0xe0, 0x9e,
0xb3, 0xe3, 0xcd, 0xa9, 0xe2, 0xc0, 0x34, 0x25, 0x21, 0x59, 0x9e, 0x0b, 0x9a, 0xa6, 0x8b, 0x26,
0xd9, 0x99, 0x04, 0x26, 0x92, 0x42, 0xd2, 0xae, 0xc2, 0x28, 0x93, 0xff, 0xe1, 0x0b, 0x8d, 0x5e,
0x6b, 0xe0, 0x62, 0xce, 0xa5, 0x27, 0x99, 0x63, 0x96, 0x29, 0xca, 0x99, 0xdd, 0x14, 0x0a, 0xd9,
0x58, 0x9d, 0x3c, 0xd4, 0x73, 0xb1, 0x40, 0x56, 0x7e, 0x81, 0xf9, 0x97, 0x42, 0xb7, 0x4e, 0xe3,
0x4b, 0xc4, 0x46, 0x36, 0x61, 0xd4, 0x2c, 0xc4, 0xdf, 0x32, 0x94, 0x76, 0xf6, 0x30, 0x7f, 0xee,
0x5f, 0x1f, 0x02, 0x0e, 0xea, 0xe5, 0x49, 0x1f, 0x35, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_board_xpm[1] = {{ png, sizeof( png ), "add_board_xpm" }};
//EOF

24
bitmaps_png/cpp_24/add_bus.cpp
View File

@ -1,24 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0x70, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x18, 0x05, 0x50,
0x20, 0xd9, 0x78, 0x38, 0x50, 0xaa, 0xf1, 0xc8, 0x53, 0x10, 0x96, 0x6e, 0x38, 0xec, 0x43, 0x55,
0xc3, 0x81, 0x86, 0x86, 0x03, 0xf1, 0x6f, 0x20, 0xfe, 0x0f, 0xc5, 0x4f, 0x68, 0x69, 0x38, 0xf5,
0x2c, 0xc0, 0x61, 0xf8, 0x6f, 0x50, 0x70, 0x51, 0x6c, 0xb8, 0x74, 0xe3, 0xe1, 0x50, 0x2c, 0x86,
0xff, 0x91, 0x6c, 0x3c, 0x12, 0x3d, 0x6a, 0xf8, 0xa8, 0xe1, 0xa3, 0x86, 0x8f, 0x1a, 0x4e, 0x7e,
0x79, 0x7e, 0x34, 0x18, 0x5b, 0xc1, 0x05, 0x2a, 0xd0, 0xa8, 0x55, 0x32, 0x3e, 0xa1, 0x99, 0xe1,
0x58, 0x2c, 0xa0, 0xae, 0xe1, 0xe0, 0xf0, 0x07, 0x56, 0x73, 0xb0, 0x2a, 0x0f, 0x14, 0x5c, 0xa3,
0x8d, 0x00, 0x18, 0x00, 0x00, 0x73, 0x13, 0x16, 0x04, 0xbe, 0xfe, 0xeb, 0xae, 0x00, 0x00, 0x00,
0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_bus_xpm[1] = {{ png, sizeof( png ), "add_bus_xpm" }};
//EOF

47
bitmaps_png/cpp_24/add_bus2bus.cpp
View File

@ -1,47 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0xd9, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0xa0, 0x22, 0xf0,
0xf5, 0xf5, 0xf5, 0xf7, 0xf3, 0xf3, 0x6b, 0x80, 0x61, 0x20, 0x9f, 0x8b, 0xc1, 0xd3, 0xd3, 0x93,
0xdd, 0xc7, 0xc7, 0xc7, 0x97, 0x10, 0x76, 0x70, 0x48, 0x09, 0x17, 0x14, 0x5c, 0xbd, 0x8c, 0x81,
0xe1, 0x78, 0x03, 0x03, 0xc3, 0x31, 0x21, 0xa2, 0x2d, 0x70, 0x73, 0x73, 0xe3, 0x46, 0x16, 0xc4,
0x85, 0x05, 0x05, 0xd7, 0x5d, 0x62, 0x60, 0x38, 0xf1, 0x1f, 0x82, 0x8f, 0x3f, 0x64, 0x60, 0x38,
0x69, 0x49, 0x94, 0x05, 0x20, 0x82, 0x18, 0x0b, 0x38, 0x39, 0x77, 0x3d, 0x41, 0x58, 0x00, 0xc6,
0xbf, 0x80, 0xb8, 0x84, 0x81, 0xe1, 0x3f, 0x23, 0x55, 0x2c, 0xd0, 0xd4, 0x6c, 0x5b, 0xc6, 0xc8,
0x78, 0xec, 0x37, 0x9a, 0x25, 0x40, 0x7c, 0x72, 0x13, 0x2c, 0xc8, 0xb0, 0x5a, 0xf0, 0xff, 0xff,
0x7f, 0x46, 0x6f, 0x6f, 0x6f, 0x41, 0x64, 0x1c, 0x10, 0x10, 0x20, 0x10, 0x1a, 0x1a, 0xca, 0x89,
0x8e, 0x39, 0x39, 0xb7, 0x59, 0x00, 0x0d, 0xbd, 0x8d, 0x69, 0xc9, 0x89, 0x47, 0xc0, 0x60, 0xb3,
0xc6, 0x6a, 0x01, 0xe9, 0xe0, 0x08, 0x2f, 0xd0, 0xc0, 0xe5, 0x58, 0x2c, 0xf9, 0x2d, 0x24, 0xb4,
0x7a, 0xb9, 0xaf, 0x6f, 0x60, 0x23, 0x85, 0x16, 0xc0, 0xc0, 0xc9, 0x38, 0xa0, 0xa1, 0x5f, 0xd1,
0x2d, 0xe2, 0xe3, 0xdb, 0x7c, 0xd3, 0xd9, 0x39, 0xbe, 0x93, 0x0a, 0x16, 0x80, 0xc0, 0x31, 0x43,
0x6c, 0x41, 0xc6, 0xca, 0x7a, 0xe0, 0x83, 0xb1, 0x71, 0xf9, 0x2c, 0x2a, 0x58, 0x00, 0x02, 0x27,
0xf8, 0x80, 0xbe, 0x59, 0x89, 0x6e, 0x09, 0x0b, 0xcb, 0xc1, 0xcf, 0x0e, 0x0e, 0x59, 0x3c, 0x0c,
0x09, 0x09, 0x09, 0x1c, 0x40, 0x9b, 0x72, 0x09, 0x61, 0x33, 0xb3, 0xd2, 0x56, 0x6e, 0xee, 0x1d,
0x37, 0x80, 0x9a, 0x77, 0x33, 0x30, 0x9c, 0x32, 0xc5, 0xb4, 0xe8, 0x78, 0x26, 0x23, 0xe3, 0x89,
0x9f, 0x30, 0x0b, 0x80, 0x29, 0xee, 0x8f, 0xae, 0x6e, 0x85, 0x20, 0xd1, 0xc9, 0x94, 0x87, 0x67,
0xeb, 0x5d, 0x24, 0x17, 0x82, 0x0c, 0xca, 0x47, 0xce, 0x03, 0x20, 0xa0, 0xad, 0xdd, 0x58, 0x08,
0xcc, 0x2f, 0xcf, 0x98, 0x98, 0x8e, 0xfc, 0x90, 0x97, 0x9f, 0xb6, 0x8d, 0xa4, 0x7c, 0x80, 0x66,
0x01, 0x2c, 0x47, 0xaf, 0x63, 0x60, 0x38, 0x2f, 0x80, 0x37, 0xa3, 0x91, 0x12, 0x44, 0x2c, 0x2c,
0x07, 0xde, 0x60, 0x49, 0x9e, 0xf7, 0x60, 0x41, 0x46, 0x85, 0x7c, 0x80, 0x3d, 0x42, 0x41, 0x79,
0x00, 0xe8, 0x9b, 0x72, 0x5f, 0xdf, 0x80, 0x00, 0x2a, 0x64, 0x34, 0xb0, 0x45, 0x69, 0xd0, 0x78,
0x40, 0xb1, 0x88, 0x93, 0x73, 0xe7, 0x49, 0x17, 0x97, 0x98, 0x0e, 0x2a, 0x65, 0xb4, 0x13, 0xc6,
0x40, 0xdf, 0xdc, 0xc1, 0x96, 0x07, 0x0c, 0x0d, 0xab, 0xe7, 0x50, 0x29, 0xa3, 0x81, 0x22, 0x18,
0x14, 0xd1, 0xa8, 0x96, 0x80, 0x92, 0xa8, 0xb2, 0x72, 0xff, 0x06, 0x2a, 0x65, 0x34, 0x50, 0x52,
0x3d, 0x9e, 0x87, 0x1e, 0x64, 0x4c, 0x4c, 0xc7, 0x7e, 0x19, 0x18, 0x34, 0x08, 0x50, 0xb1, 0xc2,
0x3c, 0x65, 0xca, 0xcc, 0x7c, 0xf8, 0x05, 0xcc, 0x02, 0x20, 0xfb, 0x9b, 0xb5, 0x75, 0x12, 0x2f,
0x35, 0xab, 0x64, 0x06, 0x3b, 0xbb, 0xe4, 0x28, 0x31, 0xb1, 0xe5, 0x27, 0x79, 0x79, 0x37, 0xdd,
0x32, 0x30, 0xa8, 0x9b, 0x47, 0xa5, 0x20, 0x22, 0x50, 0x65, 0x0e, 0x79, 0x0b, 0x00, 0xc2, 0x97,
0xbc, 0xc0, 0x3f, 0xc7, 0x52, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE add_bus2bus_xpm[1] = {{ png, sizeof( png ), "add_bus2bus_xpm" }};
//EOF

32
bitmaps_png/cpp_24/add_center_dimension.cpp
View File

@ -1,32 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0xec, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x18, 0x4c, 0x20,
0x38, 0x38, 0xf8, 0x3e, 0x4d, 0x2d, 0x08, 0x09, 0x09, 0xf9, 0x3f, 0x6a, 0xc1, 0xa8, 0x05, 0x64,
0x82, 0x86, 0xff, 0x4c, 0xd2, 0x0d, 0x87, 0x7d, 0xac, 0x32, 0xda, 0xfe, 0x4b, 0x35, 0x1c, 0x75,
0xc3, 0xa6, 0x44, 0xba, 0xe1, 0x84, 0x8c, 0x54, 0xd3, 0x91, 0x1c, 0xc9, 0xa6, 0xc3, 0x69, 0xf2,
0xad, 0x87, 0x24, 0x89, 0x37, 0xfc, 0xff, 0x7f, 0x46, 0xa9, 0xc6, 0x23, 0xeb, 0x80, 0xf8, 0x3f,
0x12, 0x5e, 0x82, 0xac, 0x44, 0xaa, 0xe9, 0x90, 0x35, 0x50, 0xec, 0x0b, 0x92, 0xfc, 0x3b, 0x89,
0xa6, 0xa3, 0xa6, 0x44, 0x99, 0x2f, 0xdd, 0x78, 0xd4, 0x1b, 0xcd, 0x70, 0x18, 0x76, 0x85, 0x5b,
0xd0, 0x78, 0xe4, 0x34, 0x16, 0xf9, 0x23, 0x28, 0x39, 0x14, 0x14, 0xbe, 0xd8, 0xb0, 0x45, 0x56,
0x17, 0x36, 0xc3, 0xff, 0x5b, 0x65, 0xb6, 0xc3, 0xd5, 0x48, 0x37, 0x1c, 0xc2, 0xa6, 0xe6, 0x0b,
0x51, 0x3e, 0x90, 0x6a, 0x3c, 0xec, 0x8b, 0xcd, 0x02, 0x99, 0x86, 0x23, 0x5e, 0x08, 0x35, 0x47,
0xcf, 0xa2, 0xcb, 0x4b, 0x36, 0x1e, 0x3e, 0x49, 0x7c, 0x1c, 0x34, 0x1c, 0x59, 0x89, 0x6a, 0xc0,
0xd1, 0x55, 0x20, 0x71, 0x78, 0x30, 0x36, 0x1d, 0xb5, 0x04, 0x8a, 0x7f, 0x40, 0x52, 0xf3, 0x09,
0x24, 0x46, 0x52, 0x44, 0x83, 0x52, 0x91, 0x65, 0x66, 0xc7, 0x7f, 0xc9, 0x86, 0xc3, 0x1e, 0xc8,
0x86, 0xc3, 0x80, 0x4c, 0xcb, 0x31, 0x69, 0xa0, 0xc5, 0xb9, 0x52, 0x4d, 0x87, 0xb3, 0x64, 0x1b,
0x8e, 0x48, 0x8d, 0xe6, 0xe4, 0x51, 0x0b, 0x06, 0xc8, 0x02, 0x9a, 0xd7, 0xc9, 0x83, 0x12, 0x00,
0x00, 0x63, 0x85, 0xd8, 0x50, 0x69, 0xfd, 0x9e, 0x82, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_center_dimension_xpm[1] = {{ png, sizeof( png ), "add_center_dimension_xpm" }};
//EOF

34
bitmaps_png/cpp_24/add_circle.cpp
View File

@ -1,34 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x01, 0x0d, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0xbd, 0x53, 0x51, 0x0e, 0xc1,
0x40, 0x10, 0x15, 0x89, 0x5e, 0x8f, 0xd8, 0xb7, 0x3d, 0x02, 0xd7, 0xf0, 0x8b, 0x1f, 0x8a, 0x0b,
0xc8, 0xe2, 0xaf, 0x0e, 0x80, 0xa4, 0x4e, 0xa1, 0xd2, 0x3a, 0x84, 0xd4, 0xff, 0x98, 0xa9, 0x48,
0x6d, 0x5b, 0x2b, 0x7c, 0x98, 0x97, 0x34, 0x9b, 0x76, 0x5e, 0x67, 0xde, 0xcc, 0xdb, 0x46, 0xe3,
0xcf, 0xa1, 0x3d, 0xe5, 0x63, 0x8d, 0x18, 0x37, 0x46, 0x8c, 0xb5, 0xf2, 0xb5, 0xe7, 0x48, 0x57,
0x0a, 0x17, 0x90, 0x0d, 0x95, 0xa2, 0x5b, 0x9b, 0x3c, 0x68, 0x62, 0x2c, 0x09, 0x7d, 0x0a, 0x68,
0x4b, 0x07, 0x46, 0xc8, 0xa7, 0xfe, 0x83, 0x34, 0x1a, 0x34, 0x2b, 0x04, 0x49, 0xf7, 0x69, 0x41,
0x11, 0x1d, 0x5f, 0x10, 0xd1, 0x9c, 0xdf, 0x32, 0x69, 0x58, 0x6d, 0x86, 0x3f, 0xac, 0xac, 0xe4,
0x27, 0x4c, 0x4e, 0x51, 0x1d, 0x4b, 0xaa, 0xf4, 0x3e, 0xaf, 0x4d, 0x17, 0xcc, 0xa4, 0x46, 0xd2,
0x6b, 0x15, 0xff, 0xf7, 0xa5, 0xf7, 0xe8, 0x2d, 0x21, 0xca, 0xb5, 0x68, 0x14, 0xfd, 0x6f, 0xc0,
0x02, 0x8f, 0x0e, 0x4c, 0xa4, 0x86, 0x29, 0x2a, 0x9c, 0xc1, 0x93, 0x71, 0x11, 0x42, 0x21, 0xc4,
0x45, 0x85, 0x0c, 0xb4, 0x77, 0x12, 0x76, 0x42, 0xc8, 0xbe, 0x25, 0x5c, 0x7f, 0x6f, 0x49, 0xad,
0x3e, 0x89, 0x9e, 0xca, 0x26, 0x96, 0xbf, 0x8f, 0x95, 0x3d, 0x9a, 0x82, 0xd7, 0xf3, 0x8e, 0x10,
0x94, 0x17, 0xc7, 0xb2, 0xbb, 0x62, 0x0d, 0xe3, 0xb0, 0x06, 0xda, 0x65, 0x37, 0x8d, 0x84, 0x32,
0xab, 0x98, 0x2f, 0xa8, 0x37, 0x9f, 0xd8, 0x5b, 0x28, 0xa2, 0x65, 0xc2, 0x33, 0xd9, 0x33, 0x42,
0x3e, 0x3d, 0xec, 0x8d, 0x61, 0x8d, 0xbd, 0xf3, 0x2a, 0x1d, 0x24, 0xe5, 0x0b, 0x84, 0xc4, 0xf2,
0x69, 0x39, 0x7a, 0x2d, 0x0d, 0x18, 0x9c, 0x78, 0x95, 0x19, 0x3f, 0x8d, 0x86, 0x25, 0xf5, 0x2f,
0x71, 0x07, 0x25, 0x48, 0xfd, 0xed, 0x14, 0x76, 0x05, 0x8f, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45,
0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_circle_xpm[1] = {{ png, sizeof( png ), "add_circle_xpm" }};
//EOF

33
bitmaps_png/cpp_24/add_component.cpp
View File

@ -1,33 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x00, 0xff, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x00, 0x83, 0x90,
0xc3, 0x21, 0x97, 0x82, 0x2c, 0x18, 0x88, 0x07, 0x21, 0xff, 0x81, 0xf0, 0x4f, 0x48, 0x4f, 0x28,
0x27, 0x29, 0x1a, 0x7e, 0x87, 0xfc, 0x0f, 0xbe, 0x19, 0x6a, 0x43, 0xb4, 0x86, 0x40, 0xfd, 0x90,
0x73, 0x40, 0xfa, 0x5f, 0xf0, 0xcc, 0x50, 0x1e, 0xa2, 0x34, 0x30, 0x30, 0xa4, 0xb1, 0x86, 0x94,
0x87, 0xfc, 0x04, 0xb2, 0xef, 0x85, 0x38, 0xe3, 0x56, 0x7a, 0x18, 0xec, 0x1c, 0xb0, 0x06, 0x10,
0x08, 0xd5, 0x0d, 0x39, 0x03, 0xb1, 0xc7, 0x8f, 0x97, 0x28, 0x0d, 0x0c, 0x0c, 0x0e, 0x2c, 0x40,
0x7b, 0x7e, 0x00, 0x45, 0x1e, 0x84, 0xba, 0x12, 0x70, 0x52, 0xa8, 0x71, 0xb0, 0x0b, 0x08, 0x86,
0x1a, 0x07, 0xea, 0x84, 0x9e, 0x02, 0x1b, 0xb3, 0x2a, 0x54, 0x08, 0x8f, 0x86, 0x90, 0xfd, 0x50,
0xdb, 0xf6, 0x23, 0xd9, 0xf3, 0x2c, 0xc4, 0x9f, 0x08, 0x1b, 0xa0, 0xfe, 0x51, 0x09, 0x3d, 0x08,
0xb1, 0x27, 0x50, 0x18, 0xab, 0x06, 0x4c, 0xd0, 0xc0, 0x14, 0x9a, 0x16, 0xf2, 0x05, 0x28, 0xfb,
0x3c, 0x34, 0x90, 0x28, 0x0d, 0x60, 0x7b, 0xd4, 0x43, 0x8f, 0xc0, 0x02, 0x26, 0xe4, 0x24, 0x9a,
0x86, 0x10, 0x07, 0x20, 0xcb, 0x81, 0x68, 0x0d, 0xc1, 0x2e, 0x41, 0xc5, 0x21, 0xff, 0x83, 0x8a,
0x83, 0x5d, 0x88, 0x74, 0x12, 0xdc, 0x1c, 0x58, 0x24, 0x6a, 0x85, 0x9c, 0xc0, 0xeb, 0xe9, 0x50,
0x63, 0xa0, 0x79, 0x50, 0x1b, 0x10, 0xc1, 0x1a, 0xea, 0x87, 0x33, 0x58, 0x11, 0x7e, 0x80, 0x46,
0xdc, 0xbf, 0xe0, 0x45, 0x51, 0x82, 0x24, 0x24, 0x0d, 0x84, 0x5f, 0xf0, 0x68, 0x08, 0xd6, 0x23,
0x90, 0xf8, 0xb0, 0x27, 0xef, 0x50, 0x27, 0x5a, 0x64, 0x20, 0x92, 0xb3, 0x28, 0x69, 0x85, 0x00,
0xd1, 0xc5, 0x0c, 0x00, 0x60, 0xff, 0xe5, 0x78, 0x1c, 0xde, 0x84, 0xf5, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_component_xpm[1] = {{ png, sizeof( png ), "add_component_xpm" }};
//EOF

47
bitmaps_png/cpp_24/add_corner.cpp
View File

@ -1,47 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0xda, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0xd0, 0x6e, 0xb8, 0xca,
0x26, 0xdd, 0x78, 0x74, 0x82, 0x54, 0xe3, 0x91, 0xb7, 0x40, 0xfc, 0x54, 0xaa, 0xf1, 0x68, 0x07,
0x48, 0x8c, 0x01, 0x07, 0x20, 0x55, 0x3d, 0x03, 0x54, 0xf1, 0x7f, 0x54, 0x7c, 0xb4, 0x83, 0x5a,
0xea, 0x19, 0x80, 0x0a, 0xde, 0xa1, 0x6b, 0x50, 0xa8, 0xdd, 0xf9, 0x3f, 0x24, 0x24, 0x04, 0x2b,
0x96, 0xab, 0xdb, 0xfb, 0x1f, 0xd3, 0x82, 0x23, 0x4f, 0x49, 0xb2, 0x40, 0xbe, 0x6e, 0x0f, 0x49,
0x16, 0x48, 0x03, 0x83, 0x0b, 0xa7, 0x05, 0x92, 0x8d, 0x47, 0xfa, 0xd0, 0x35, 0x48, 0x36, 0x1c,
0xee, 0x25, 0x45, 0xbd, 0x7e, 0xc1, 0xac, 0x07, 0x40, 0x29, 0x46, 0xac, 0x1a, 0x54, 0x26, 0x6d,
0x63, 0x07, 0x86, 0x61, 0x0f, 0xc8, 0xd5, 0x72, 0xb5, 0xbb, 0xc1, 0x86, 0x1b, 0xcf, 0x3c, 0xc3,
0x8a, 0xcb, 0x02, 0x98, 0x7a, 0xad, 0xce, 0xe3, 0xff, 0x35, 0xda, 0x8f, 0xfe, 0x37, 0xce, 0x9d,
0xf2, 0x3d, 0x38, 0x34, 0x0c, 0xe4, 0xbb, 0x44, 0x06, 0x7c, 0x00, 0x16, 0x04, 0x0c, 0x44, 0x82,
0xa7, 0x4f, 0x9f, 0xfe, 0x07, 0xe1, 0xe0, 0xe0, 0xe0, 0x18, 0xa8, 0xde, 0x0f, 0xa1, 0xa1, 0xa1,
0x72, 0x54, 0xb3, 0xe0, 0xc9, 0x93, 0xc7, 0xff, 0x41, 0x18, 0xaa, 0x77, 0x2d, 0x48, 0x2f, 0xd0,
0x82, 0xdd, 0x38, 0x83, 0x8a, 0x54, 0x0b, 0x1e, 0x3d, 0x7a, 0xf8, 0x1f, 0x84, 0x41, 0x6c, 0xa0,
0xc1, 0xa2, 0x40, 0xbd, 0xaf, 0xa0, 0x66, 0xa4, 0x50, 0xc5, 0x82, 0x07, 0x0f, 0xee, 0xff, 0x07,
0x61, 0x18, 0x3f, 0x2a, 0x30, 0x24, 0x6e, 0xa2, 0x95, 0xd7, 0xff, 0x9d, 0x9a, 0x4e, 0xff, 0xf6,
0xa9, 0x39, 0xbe, 0xd8, 0xaf, 0xe6, 0xd4, 0xb1, 0x4a, 0x3b, 0x94, 0x8d, 0x6c, 0x0b, 0xee, 0xdd,
0xbb, 0xf7, 0x1f, 0x84, 0x61, 0xfc, 0xfd, 0xaa, 0x4e, 0x13, 0xf6, 0xab, 0x39, 0xfe, 0x47, 0xc5,
0x4e, 0x1d, 0x64, 0x5b, 0x70, 0xe7, 0xce, 0x9d, 0xff, 0x20, 0x0c, 0xb7, 0x40, 0xcd, 0xf1, 0x1d,
0xba, 0x05, 0x07, 0xd4, 0x1c, 0x9f, 0x92, 0x6d, 0xc1, 0xad, 0x5b, 0xb7, 0xfe, 0x83, 0x30, 0x3e,
0x0b, 0x80, 0xf8, 0x35, 0xd9, 0x16, 0xdc, 0xb8, 0x71, 0xe3, 0x3f, 0x08, 0xc3, 0xf8, 0xc0, 0x70,
0xef, 0xc3, 0xe2, 0x83, 0x5e, 0xb2, 0x2d, 0xb8, 0x76, 0xed, 0xda, 0x7f, 0x10, 0x86, 0x47, 0x72,
0x40, 0x70, 0x5a, 0xbf, 0xb5, 0xd7, 0xff, 0xed, 0xc0, 0x48, 0xde, 0xaf, 0xee, 0xf8, 0x0e, 0x64,
0xf8, 0x19, 0x63, 0x63, 0x56, 0xb2, 0x2d, 0xb8, 0x7a, 0xf5, 0xca, 0x7f, 0x10, 0x06, 0xb1, 0x23,
0x22, 0x22, 0xa4, 0x80, 0x7a, 0xdf, 0x41, 0xf3, 0x42, 0x14, 0x55, 0x92, 0xe9, 0xe5, 0xcb, 0x97,
0xfe, 0x83, 0x30, 0x54, 0xef, 0x06, 0xa8, 0xe1, 0x9b, 0xa8, 0x96, 0x93, 0x2f, 0x5e, 0xbc, 0xf0,
0x1f, 0x84, 0x81, 0x86, 0x26, 0x40, 0xf5, 0xbe, 0x07, 0xb2, 0xa5, 0x71, 0xd6, 0x50, 0x72, 0xc0,
0xc2, 0x0e, 0x54, 0x0f, 0x10, 0x5b, 0xa3, 0xa9, 0x03, 0x0b, 0x3a, 0xed, 0x8e, 0x23, 0xff, 0x4d,
0x72, 0x26, 0x01, 0x0b, 0xbb, 0x70, 0x70, 0x99, 0x44, 0xb3, 0x1a, 0xcd, 0xb0, 0x60, 0xd6, 0x1d,
0x1a, 0xd7, 0x68, 0x87, 0x5f, 0xd0, 0xb4, 0x46, 0x03, 0xe2, 0xd7, 0x34, 0xad, 0xd1, 0xf0, 0xa9,
0x87, 0xd7, 0x50, 0x20, 0x57, 0x00, 0xf1, 0x1b, 0x62, 0x6b, 0x34, 0x62, 0xd5, 0x03, 0x00, 0x40,
0xd7, 0x5b, 0x9c, 0x17, 0x9b, 0x87, 0xa7, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_corner_xpm[1] = {{ png, sizeof( png ), "add_corner_xpm" }};
//EOF

40
bitmaps_png/cpp_24/add_dashed_line.cpp
View File

@ -1,40 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x01, 0x6c, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0xa0, 0x0b, 0x08,
0x39, 0x1c, 0xf2, 0x2c, 0x58, 0x8f, 0x81, 0xc1, 0x97, 0x2b, 0xc8, 0x2e, 0x42, 0x8a, 0x08, 0x0d,
0xa1, 0x67, 0x43, 0xfe, 0x87, 0xcc, 0x00, 0x6a, 0x9c, 0x08, 0xa4, 0xff, 0x87, 0x3c, 0x09, 0x55,
0x04, 0x8a, 0xf1, 0x87, 0xda, 0x07, 0x49, 0xe2, 0xd0, 0x10, 0xac, 0x17, 0xf2, 0x3d, 0xf8, 0x26,
0x03, 0x43, 0x90, 0x63, 0xc8, 0xa1, 0x90, 0x77, 0x21, 0x5f, 0xc2, 0x35, 0x81, 0x9a, 0x97, 0x83,
0x35, 0xdf, 0x0b, 0x15, 0x65, 0x60, 0x88, 0x14, 0xc7, 0xd0, 0x1c, 0xae, 0x16, 0x2a, 0x07, 0x63,
0x3b, 0xb0, 0x80, 0x0d, 0xf1, 0x0d, 0x3d, 0x02, 0xd4, 0xfc, 0x16, 0xa4, 0x30, 0x64, 0x2f, 0x48,
0x73, 0xe8, 0x41, 0x74, 0x7b, 0x94, 0x82, 0x53, 0x43, 0x99, 0xb1, 0xfa, 0x31, 0x02, 0xe8, 0xcb,
0x4f, 0x20, 0x37, 0xa0, 0x6a, 0x58, 0x04, 0x34, 0xa7, 0x09, 0xa7, 0x3f, 0x79, 0x62, 0xb9, 0xd1,
0x85, 0xec, 0x43, 0xfe, 0x84, 0xfc, 0x09, 0x35, 0x23, 0x25, 0x78, 0xeb, 0x81, 0x76, 0x84, 0x62,
0x35, 0xdf, 0x3e, 0xf4, 0x72, 0x90, 0x05, 0x16, 0x89, 0x48, 0x71, 0x1c, 0x46, 0x4d, 0x02, 0x7a,
0x3a, 0x1f, 0xab, 0x54, 0x03, 0x53, 0x68, 0x5d, 0x88, 0x0f, 0x86, 0x86, 0x8d, 0x40, 0xbb, 0x83,
0xb0, 0x6a, 0x08, 0x92, 0x04, 0x4a, 0x7d, 0x07, 0xc5, 0x3b, 0x8a, 0x86, 0xe9, 0x21, 0x5f, 0x22,
0x14, 0x70, 0x45, 0xe3, 0x4c, 0xa0, 0xf5, 0x67, 0xd1, 0x04, 0x19, 0x43, 0x39, 0x71, 0x28, 0x4f,
0x63, 0x0d, 0xd9, 0x0c, 0xb4, 0xe3, 0x30, 0xf1, 0x21, 0x35, 0x17, 0xa8, 0xfc, 0x59, 0x28, 0x0f,
0x4a, 0x18, 0x49, 0x84, 0xdc, 0x08, 0x29, 0xc1, 0x1e, 0x3d, 0xa2, 0x40, 0xe5, 0x5f, 0x42, 0x8d,
0xd1, 0x0c, 0x09, 0x02, 0x8a, 0x6e, 0xc0, 0xe5, 0x83, 0x30, 0x64, 0xe5, 0xbe, 0x5c, 0x60, 0x0d,
0x25, 0x40, 0x0d, 0x93, 0x30, 0x94, 0x06, 0xea, 0x04, 0xa7, 0x32, 0x30, 0xc2, 0x79, 0xc2, 0x21,
0xb3, 0x43, 0x6e, 0x87, 0xfc, 0x0b, 0x4d, 0x00, 0xa7, 0xa5, 0xaf, 0xa1, 0xde, 0xe8, 0x26, 0x6b,
0x84, 0xbc, 0x0d, 0xf9, 0x1f, 0x1c, 0x1f, 0x5a, 0x1a, 0xb2, 0x2c, 0xd4, 0x03, 0xe8, 0xb8, 0x10,
0x70, 0xf2, 0xfe, 0x80, 0xa1, 0x10, 0xea, 0x76, 0xe6, 0xe0, 0x3b, 0x40, 0xe9, 0x2b, 0x60, 0x45,
0xff, 0x43, 0xe6, 0x82, 0x44, 0x42, 0xfd, 0x42, 0x0d, 0xb0, 0xa7, 0x5e, 0xb0, 0x86, 0xd0, 0xcb,
0x21, 0x7b, 0x23, 0x45, 0x82, 0x97, 0x06, 0x4f, 0x0b, 0x8e, 0xf1, 0xe3, 0x65, 0x18, 0x40, 0x00,
0x00, 0x29, 0x93, 0x85, 0x77, 0xb1, 0x42, 0x4c, 0x09, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_dashed_line_xpm[1] = {{ png, sizeof( png ), "add_dashed_line_xpm" }};
//EOF

59
bitmaps_png/cpp_24/add_document.cpp
View File

@ -1,59 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x02, 0xa1, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0xad, 0x95, 0xcb, 0x6f, 0x12,
0x51, 0x14, 0xc6, 0xe7, 0x8f, 0xd0, 0x60, 0x5c, 0x2b, 0xb8, 0x53, 0x03, 0x0e, 0xf8, 0x68, 0x52,
0x48, 0x44, 0x1e, 0x11, 0xb4, 0x11, 0xb1, 0x18, 0x13, 0x6b, 0xb0, 0xeb, 0xc6, 0xd8, 0xb8, 0x71,
0x61, 0x31, 0x26, 0x26, 0x1a, 0x35, 0xba, 0xaa, 0x86, 0x2a, 0xad, 0x53, 0x2d, 0xd2, 0xa8, 0x8b,
0xa6, 0x49, 0xdb, 0x74, 0x28, 0xd2, 0x96, 0x48, 0x04, 0xb4, 0x1b, 0x4d, 0xa4, 0xec, 0xd4, 0x08,
0xb6, 0xc0, 0x00, 0xa9, 0x94, 0x78, 0xbc, 0xf7, 0xea, 0x4c, 0x66, 0x80, 0xa9, 0x03, 0x72, 0x93,
0x2f, 0x73, 0x66, 0x26, 0xf7, 0xfc, 0xee, 0xf9, 0xee, 0x8b, 0xa2, 0x50, 0x7b, 0xcb, 0x06, 0x77,
0xa4, 0x16, 0x43, 0xa3, 0xa9, 0x68, 0x88, 0x43, 0x4f, 0xe0, 0xa5, 0xd5, 0x6a, 0x25, 0x12, 0xff,
0x93, 0x08, 0xf5, 0x4b, 0x46, 0x27, 0x03, 0x2b, 0xb1, 0x71, 0x15, 0x55, 0xdf, 0x56, 0x62, 0xaf,
0x55, 0x72, 0x1d, 0x15, 0x03, 0x44, 0x4a, 0x44, 0x9f, 0xed, 0x94, 0x00, 0xd0, 0xc7, 0xb1, 0x4e,
0x02, 0x70, 0x25, 0x52, 0x40, 0x9d, 0x2d, 0x62, 0xdd, 0xb8, 0x76, 0x09, 0xac, 0x56, 0x0b, 0x11,
0x8e, 0x95, 0x00, 0x90, 0x8a, 0xf5, 0x15, 0x6c, 0xd9, 0xc1, 0xe3, 0xf1, 0x10, 0x29, 0x4c, 0x4e,
0xa4, 0x18, 0x90, 0x78, 0x13, 0x04, 0x87, 0xc3, 0x01, 0x4e, 0xa7, 0x13, 0xc5, 0x2f, 0x3a, 0x0f,
0x38, 0x7f, 0xee, 0xb4, 0xe0, 0xbf, 0xb7, 0xaf, 0xf7, 0x9f, 0x73, 0xc4, 0x4b, 0x11, 0x60, 0xe6,
0xd5, 0xa3, 0x86, 0x8e, 0x2e, 0x97, 0x4b, 0xb0, 0x0c, 0xeb, 0xbf, 0x00, 0xd1, 0x99, 0x31, 0xd0,
0xeb, 0x69, 0xa1, 0x93, 0x4e, 0xa7, 0x03, 0xb7, 0xdb, 0xdd, 0x39, 0x00, 0xd6, 0xf0, 0x7d, 0x1f,
0xd0, 0x34, 0x8d, 0x40, 0x7a, 0x78, 0xf8, 0xe0, 0xba, 0xf0, 0xfd, 0x63, 0x72, 0x16, 0xb2, 0x5f,
0x3e, 0x43, 0x26, 0x93, 0x81, 0x5a, 0xad, 0x06, 0xd5, 0x6a, 0x95, 0xc4, 0xc1, 0x60, 0x90, 0x0c,
0x62, 0x4b, 0xc0, 0xfc, 0xd4, 0x08, 0x11, 0x8e, 0xe3, 0x0b, 0x13, 0x60, 0x36, 0x9b, 0xc1, 0x62,
0xb1, 0x90, 0xf7, 0x0f, 0xcb, 0x2f, 0x21, 0xf7, 0x2d, 0x0d, 0x3f, 0x73, 0xeb, 0xb0, 0x7a, 0xd7,
0x0f, 0x71, 0xe7, 0x45, 0x88, 0xec, 0xb5, 0x12, 0xc5, 0x4f, 0xf4, 0xc3, 0xea, 0x3d, 0x3f, 0xfa,
0xb7, 0x26, 0x0f, 0xc0, 0x89, 0x0d, 0x06, 0x3d, 0x11, 0xe3, 0xbf, 0x05, 0xc7, 0xed, 0xc7, 0x48,
0xc9, 0x06, 0x54, 0x01, 0x4e, 0x5e, 0x2a, 0x64, 0xe1, 0xfb, 0x74, 0x18, 0x22, 0xfb, 0xed, 0xc0,
0xaa, 0x8d, 0x4d, 0x45, 0xfe, 0x69, 0xba, 0x4f, 0x35, 0x05, 0x4c, 0x04, 0xee, 0x08, 0x3e, 0xd2,
0xf4, 0x01, 0xf2, 0xb4, 0x59, 0x8f, 0x02, 0x33, 0x72, 0x9b, 0x8c, 0x1c, 0x27, 0x67, 0x35, 0x26,
0x49, 0xc2, 0xe4, 0x85, 0x41, 0x48, 0xf4, 0x5d, 0xae, 0x07, 0xfd, 0x12, 0x20, 0x7c, 0xf2, 0xc5,
0xd9, 0xa7, 0x10, 0x18, 0xbe, 0x29, 0x99, 0xd4, 0xc1, 0x81, 0x7e, 0x88, 0x87, 0x9f, 0xc3, 0xa7,
0xd4, 0x1c, 0x29, 0xbd, 0x61, 0xe4, 0x08, 0xc6, 0xad, 0xe7, 0x81, 0xfb, 0xb1, 0xd6, 0x50, 0x49,
0x58, 0x6d, 0x2c, 0x44, 0x76, 0x75, 0x6d, 0xa7, 0xe4, 0x56, 0x84, 0xef, 0xea, 0x80, 0x50, 0x59,
0xee, 0x6b, 0x9a, 0x78, 0xde, 0x60, 0xc9, 0x1e, 0x13, 0x94, 0xcb, 0x65, 0x28, 0x71, 0xa5, 0xa6,
0x76, 0xcd, 0xef, 0x36, 0xfa, 0x64, 0x01, 0xbd, 0xee, 0x93, 0xc0, 0x4e, 0x3d, 0x26, 0x80, 0x8d,
0x4a, 0x11, 0xe2, 0x0e, 0x6f, 0xcb, 0x00, 0x56, 0x6d, 0x4a, 0xc8, 0x5a, 0x84, 0x75, 0xe8, 0xa0,
0x01, 0xdc, 0x2e, 0x27, 0x6c, 0x6e, 0x56, 0x21, 0xb2, 0xcf, 0xf6, 0xc7, 0x73, 0xef, 0x15, 0xe0,
0xf2, 0x05, 0x92, 0xb8, 0x99, 0xb0, 0x65, 0xa2, 0x39, 0x29, 0x4a, 0x4e, 0x53, 0xf1, 0x24, 0x9f,
0x3d, 0xd3, 0x23, 0xc4, 0x95, 0x4a, 0x45, 0xf0, 0xbf, 0x15, 0x00, 0x9e, 0x07, 0x2a, 0xb5, 0x34,
0x39, 0xca, 0x03, 0x16, 0xa6, 0x03, 0xd0, 0x75, 0xe4, 0x30, 0x11, 0x8e, 0xed, 0x36, 0x33, 0x01,
0xa4, 0xd3, 0x69, 0xb2, 0xe6, 0xdb, 0xb2, 0x28, 0x86, 0xae, 0x39, 0xf1, 0x52, 0x5d, 0x9e, 0x63,
0x88, 0xf8, 0xe3, 0x02, 0x03, 0x18, 0x86, 0x21, 0x9b, 0xa8, 0x55, 0x00, 0xaa, 0x60, 0xe8, 0xef,
0xb5, 0x39, 0xae, 0x7a, 0xbf, 0x14, 0x7a, 0xd2, 0xec, 0xf2, 0xe1, 0x0f, 0xb9, 0x8d, 0x6c, 0x6b,
0xcb, 0x14, 0x29, 0xcf, 0xaa, 0xbb, 0xb7, 0x51, 0xad, 0x34, 0xbc, 0x79, 0xc8, 0x26, 0x52, 0xb0,
0xd1, 0xd0, 0x12, 0xed, 0xa1, 0xda, 0x69, 0x18, 0x82, 0x27, 0x4f, 0xee, 0xa8, 0xc0, 0x23, 0x6f,
0x3b, 0x39, 0xdf, 0xf0, 0x0e, 0xc5, 0x9b, 0x28, 0xac, 0x31, 0xbe, 0x43, 0x09, 0x39, 0x2c, 0x1c,
0x63, 0xcf, 0xeb, 0x6d, 0xf9, 0x0d, 0xc9, 0x8c, 0x17, 0xd7, 0xa0, 0x6e, 0x13, 0xb2, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_document_xpm[1] = {{ png, sizeof( png ), "add_document_xpm" }};
//EOF

39
bitmaps_png/cpp_24/add_glabel.cpp
View File

@ -1,39 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0x5b, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x18, 0x05, 0x84,
0x40, 0x48, 0x48, 0xc8, 0x61, 0x20, 0xfe, 0x4f, 0x06, 0x3e, 0x10, 0x1a, 0x1a, 0xca, 0x49, 0x8c,
0x05, 0xff, 0x29, 0xc0, 0xab, 0x80, 0x46, 0x30, 0x12, 0x65, 0x01, 0x29, 0xbe, 0x0e, 0x0f, 0x0f,
0xd7, 0x04, 0xea, 0x79, 0x0f, 0xd5, 0xdb, 0x44, 0xb6, 0x05, 0x40, 0x71, 0x2b, 0x20, 0x6e, 0x75,
0x70, 0x70, 0x60, 0xc1, 0x22, 0xe7, 0x06, 0xc4, 0xbf, 0x81, 0xf8, 0x1f, 0x30, 0xa8, 0x62, 0xc9,
0xb2, 0x00, 0xa8, 0x71, 0x07, 0x48, 0x2e, 0x38, 0x38, 0xd8, 0x17, 0x87, 0xde, 0x14, 0xa8, 0xfe,
0x9f, 0x40, 0xec, 0x40, 0x92, 0x05, 0x40, 0xc3, 0xe5, 0x80, 0xe2, 0x7f, 0x81, 0xf8, 0x0a, 0x90,
0xbd, 0x1e, 0x8f, 0x03, 0x27, 0x41, 0xcd, 0x78, 0x03, 0x54, 0xa7, 0x42, 0x8a, 0x05, 0x75, 0x40,
0xf1, 0x5b, 0x40, 0xda, 0x03, 0x14, 0x14, 0x40, 0x5a, 0x02, 0x87, 0x2f, 0x99, 0x81, 0x78, 0x13,
0xd4, 0xa7, 0xd7, 0x02, 0x02, 0x02, 0x04, 0x88, 0xb1, 0x80, 0x11, 0xa8, 0xf8, 0x0e, 0x50, 0xbc,
0x06, 0x64, 0x00, 0x90, 0x7e, 0x0e, 0xe4, 0x17, 0xe2, 0xf2, 0x85, 0x9f, 0x9f, 0x1f, 0x2f, 0x50,
0xcd, 0x45, 0xa8, 0x59, 0x3b, 0x51, 0xe2, 0x0c, 0x9b, 0x05, 0x40, 0xc3, 0x5c, 0xa0, 0x91, 0xa7,
0x08, 0x55, 0xd3, 0x07, 0x64, 0x5f, 0xc6, 0x97, 0x58, 0x22, 0x22, 0x22, 0x14, 0x82, 0x43, 0x43,
0xdf, 0x80, 0xcc, 0x32, 0xcf, 0xee, 0xf9, 0x2f, 0xd5, 0x78, 0x04, 0x84, 0x0f, 0x63, 0xb5, 0x00,
0xc8, 0x5f, 0x0e, 0xc4, 0xfb, 0x91, 0x2c, 0x34, 0x84, 0x06, 0x81, 0x09, 0xc5, 0x16, 0x00, 0x5d,
0x2a, 0x04, 0xe4, 0x7f, 0x07, 0xe2, 0x7b, 0x40, 0xf6, 0x6e, 0x18, 0x06, 0xf2, 0xff, 0x00, 0x2d,
0x98, 0x46, 0x71, 0x10, 0x01, 0xd9, 0xb9, 0x40, 0xfc, 0x15, 0x88, 0x3b, 0x90, 0x31, 0xd0, 0x92,
0xad, 0x40, 0xfa, 0x5d, 0x42, 0x42, 0x02, 0x07, 0x45, 0x91, 0x0c, 0x64, 0x9f, 0x07, 0xe2, 0x25,
0x78, 0x92, 0x6d, 0x04, 0xd9, 0xc9, 0x14, 0xa8, 0xc0, 0x18, 0xca, 0x77, 0xc3, 0x91, 0xe6, 0x0f,
0x80, 0x82, 0x80, 0xec, 0x8c, 0x06, 0xb4, 0x40, 0x1d, 0xc8, 0x0e, 0x05, 0x79, 0x1b, 0x9b, 0x5a,
0x60, 0x10, 0x68, 0x03, 0x71, 0x30, 0x28, 0x19, 0x53, 0xa5, 0xa8, 0xa0, 0x6a, 0x61, 0x47, 0x26,
0x5e, 0x49, 0x4c, 0x71, 0x4d, 0x6e, 0x85, 0x73, 0x92, 0xa8, 0x0a, 0x67, 0x14, 0x10, 0x02, 0x00,
0x48, 0x66, 0x7b, 0x37, 0xb5, 0xc6, 0x96, 0x48, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44,
0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_glabel_xpm[1] = {{ png, sizeof( png ), "add_glabel_xpm" }};
//EOF

39
bitmaps_png/cpp_24/add_graphical_polygon.cpp
View File

@ -1,39 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x01, 0x58, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0xbd, 0x94, 0x3f, 0x28, 0xc4,
0x61, 0x18, 0xc7, 0x4f, 0x98, 0x4c, 0x6e, 0x50, 0x06, 0x65, 0x34, 0x29, 0x76, 0x91, 0x6c, 0x26,
0xf7, 0x7e, 0xdf, 0x5c, 0xe7, 0x74, 0x83, 0xc8, 0x7f, 0xb9, 0xdc, 0xe8, 0x14, 0x16, 0x93, 0x50,
0xfe, 0x15, 0x19, 0x28, 0x62, 0x38, 0x25, 0xba, 0x52, 0xfc, 0x62, 0x35, 0xc8, 0xae, 0x94, 0xd5,
0x85, 0xc5, 0x0d, 0xf8, 0x18, 0x9c, 0xdc, 0xfd, 0xee, 0x77, 0xdc, 0xc2, 0xfb, 0xac, 0xdf, 0xcf,
0xf3, 0xd6, 0xf7, 0xfb, 0x3c, 0x8f, 0xcf, 0xf7, 0x2f, 0x4f, 0x17, 0x4a, 0xe9, 0xc2, 0xac, 0x99,
0x51, 0xd3, 0x16, 0xa8, 0x2e, 0x02, 0xb0, 0x57, 0x22, 0xab, 0x7e, 0x87, 0x4d, 0xbd, 0x5e, 0x44,
0x94, 0x29, 0x46, 0xe8, 0xa2, 0x28, 0xd8, 0x0c, 0x89, 0x2e, 0x8e, 0x70, 0x70, 0x38, 0x66, 0x9b,
0x45, 0x0f, 0xd8, 0x3a, 0xd9, 0x44, 0x89, 0x12, 0x62, 0x94, 0x33, 0x9c, 0x9c, 0xfa, 0x82, 0x87,
0x11, 0x7a, 0xcc, 0xf9, 0x23, 0x54, 0xa9, 0x3b, 0x31, 0xe7, 0x02, 0xbe, 0x6a, 0x1f, 0xa1, 0x6b,
0xb7, 0x57, 0x4d, 0x7a, 0x15, 0x3b, 0x9e, 0xc0, 0x26, 0x42, 0x87, 0xf9, 0xf6, 0x4e, 0x8b, 0x08,
0x49, 0x0f, 0x60, 0x01, 0xa1, 0x85, 0x3c, 0xa0, 0xa5, 0xcc, 0x5e, 0x8a, 0x09, 0xce, 0xf3, 0x80,
0x19, 0x84, 0x8d, 0x7a, 0x18, 0x1c, 0xac, 0xd1, 0x83, 0x58, 0xca, 0x03, 0x62, 0x08, 0x05, 0xbc,
0x33, 0x31, 0xa2, 0x93, 0x03, 0x17, 0xd0, 0x8f, 0x08, 0x34, 0x16, 0x1a, 0x94, 0x75, 0x31, 0xe0,
0x02, 0x42, 0x08, 0xeb, 0xf7, 0x94, 0xf7, 0x95, 0xeb, 0x54, 0x0c, 0xe6, 0xc8, 0x93, 0x08, 0x3d,
0x15, 0xea, 0xbf, 0x2a, 0x22, 0x99, 0xcc, 0x7f, 0x4c, 0x21, 0x33, 0x86, 0x71, 0x11, 0x64, 0xaf,
0xb8, 0x14, 0x7c, 0x3e, 0x13, 0xd6, 0xbb, 0x65, 0x2b, 0x4b, 0x7a, 0xc2, 0x06, 0xb3, 0xf4, 0x7a,
0xa7, 0x60, 0x9b, 0x95, 0xfe, 0xb4, 0xf4, 0x9c, 0x04, 0xcb, 0x4c, 0xd2, 0xf3, 0x3d, 0x7a, 0x69,
0xdb, 0xee, 0xee, 0x5e, 0xa7, 0x94, 0x18, 0x63, 0x9e, 0x18, 0xe1, 0x6f, 0xe1, 0xb3, 0x92, 0x36,
0x6e, 0x5b, 0xbb, 0x2b, 0x5c, 0xf2, 0x8e, 0x2a, 0xdd, 0xe6, 0xec, 0xc1, 0xbd, 0xd9, 0xd5, 0x88,
0x69, 0xb0, 0xa5, 0x85, 0x56, 0x68, 0x5c, 0x08, 0xbd, 0xd9, 0x1b, 0xad, 0x98, 0x70, 0xb0, 0xf6,
0xf7, 0x25, 0xf5, 0x9b, 0x71, 0xdb, 0x1e, 0xaa, 0xfc, 0x83, 0x83, 0xf1, 0x01, 0xfa, 0xb2, 0x96,
0xeb, 0x74, 0x7d, 0xf2, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60,
0x82,
};
const BITMAP_OPAQUE add_graphical_polygon_xpm[1] = {{ png, sizeof( png ), "add_graphical_polygon_xpm" }};
//EOF

21
bitmaps_png/cpp_24/add_graphical_segments.cpp
View File

@ -1,21 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x00, 0x43, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x18, 0x24, 0x20,
0x50, 0x2c, 0xe4, 0x4c, 0xc8, 0x61, 0x12, 0x94, 0x87, 0x5e, 0x0e, 0xf9, 0x1f, 0x7a, 0x8a, 0x48,
0xe5, 0xa1, 0xa2, 0x21, 0x97, 0x42, 0xfe, 0x87, 0x5c, 0x0f, 0x95, 0x18, 0x55, 0x3e, 0xaa, 0x7c,
0xf8, 0x2b, 0x07, 0x6a, 0x38, 0x05, 0xcc, 0x1e, 0x97, 0x03, 0xc5, 0x88, 0xce, 0x51, 0x21, 0x87,
0x43, 0xce, 0x90, 0xa0, 0x9c, 0xc6, 0x00, 0x00, 0x15, 0xc6, 0x54, 0xef, 0x26, 0x2f, 0x8d, 0xc0,
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_graphical_segments_xpm[1] = {{ png, sizeof( png ), "add_graphical_segments_xpm" }};
//EOF

41
bitmaps_png/cpp_24/add_hierar_pin.cpp
View File

@ -1,41 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0x7b, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x18, 0x05, 0x84,
0x80, 0x54, 0xe3, 0x91, 0xc3, 0x40, 0xfc, 0x9f, 0x54, 0x2c, 0xdd, 0x78, 0xf4, 0x80, 0x4c, 0xdf,
0x31, 0x4e, 0x62, 0x2c, 0xf8, 0x4f, 0x3e, 0x3e, 0xba, 0x8a, 0xe1, 0xff, 0x7f, 0x46, 0xa2, 0x2c,
0x20, 0xc5, 0xd7, 0x92, 0xcd, 0xc7, 0x35, 0x81, 0x7a, 0xde, 0x43, 0xf5, 0x36, 0x91, 0x6d, 0x41,
0x48, 0x48, 0x88, 0x15, 0x10, 0xb7, 0x3a, 0x38, 0x38, 0xb0, 0x60, 0xe8, 0x6b, 0x38, 0xea, 0x06,
0xd4, 0xf7, 0x1b, 0x88, 0xff, 0x49, 0x36, 0x1e, 0x8e, 0x25, 0xcb, 0x82, 0xd0, 0xd0, 0xd0, 0x1d,
0x40, 0x0b, 0xfe, 0x07, 0x07, 0x07, 0xfb, 0x62, 0xd5, 0xdb, 0x74, 0x24, 0x05, 0xaa, 0xff, 0xa7,
0x4c, 0xc3, 0x61, 0x07, 0x92, 0x2c, 0x00, 0x1a, 0x2e, 0x07, 0x34, 0xfc, 0x2f, 0x10, 0x5f, 0x01,
0xb2, 0xd7, 0xe3, 0x71, 0xe0, 0x24, 0xa8, 0x19, 0x6f, 0x64, 0x1a, 0x8e, 0xa9, 0x90, 0x62, 0x41,
0x1d, 0xd0, 0xf0, 0x5b, 0x40, 0xda, 0x03, 0x48, 0xff, 0x06, 0xd2, 0x12, 0x58, 0x6d, 0x58, 0xb5,
0x8a, 0x19, 0xa8, 0x7f, 0x13, 0xc4, 0x9c, 0xc3, 0xd7, 0x14, 0x1a, 0xf6, 0x0b, 0x10, 0x63, 0x01,
0x23, 0x30, 0x58, 0xee, 0x00, 0x0d, 0xae, 0x01, 0x1a, 0xcc, 0x0c, 0xa4, 0x9f, 0x03, 0xf9, 0x85,
0xb8, 0x7c, 0x21, 0xd2, 0x79, 0x84, 0x17, 0x68, 0xc6, 0x45, 0xb0, 0x59, 0x4d, 0x47, 0x76, 0x32,
0x34, 0xec, 0x67, 0xc1, 0x6b, 0x01, 0xd0, 0x30, 0x17, 0xa0, 0xa1, 0xff, 0x80, 0x86, 0x2b, 0x42,
0x23, 0xbb, 0x0f, 0xc8, 0xbe, 0x8c, 0x2f, 0xb1, 0x48, 0x34, 0x1c, 0x57, 0x00, 0x1a, 0xfe, 0x06,
0x2d, 0x29, 0x1f, 0xc6, 0x6a, 0x01, 0xd0, 0xc0, 0xe5, 0x40, 0xbc, 0x1f, 0xc9, 0x42, 0x43, 0x68,
0x64, 0x9b, 0x50, 0x6c, 0x01, 0xd0, 0xa5, 0x42, 0x40, 0xc3, 0xbe, 0x03, 0xf1, 0x3d, 0x20, 0x7b,
0x37, 0x0c, 0x03, 0xf9, 0x7f, 0x80, 0x16, 0x4c, 0xa3, 0x38, 0x88, 0x80, 0x06, 0xe5, 0x02, 0xf1,
0x57, 0x20, 0xee, 0x40, 0xc6, 0x40, 0x4b, 0xb6, 0x02, 0xe9, 0x77, 0x09, 0x09, 0x09, 0x1c, 0x14,
0x45, 0x32, 0xd0, 0x90, 0xf3, 0x40, 0xbc, 0x04, 0x4f, 0xb2, 0x8d, 0x20, 0x3b, 0x99, 0x02, 0x0d,
0x31, 0x06, 0x85, 0x35, 0x10, 0xbb, 0xe1, 0xc8, 0xd9, 0x07, 0x80, 0x78, 0x27, 0xd9, 0x19, 0x0d,
0x68, 0x81, 0x3a, 0xd0, 0x80, 0x50, 0x50, 0xd2, 0xc4, 0xa6, 0x16, 0x18, 0x07, 0xda, 0x40, 0x1c,
0x0c, 0x4a, 0xc6, 0x54, 0x29, 0x2a, 0xa8, 0x5a, 0xd8, 0x91, 0x85, 0x1b, 0x8e, 0xac, 0x24, 0xa6,
0xb8, 0x26, 0xab, 0xc2, 0x01, 0x06, 0xcb, 0x49, 0xa2, 0x2a, 0x9c, 0x51, 0x40, 0x08, 0x00, 0x00,
0x2d, 0xbf, 0xb9, 0xe5, 0x5b, 0xb1, 0x7f, 0x42, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44,
0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_hierar_pin_xpm[1] = {{ png, sizeof( png ), "add_hierar_pin_xpm" }};
//EOF

34
bitmaps_png/cpp_24/add_hierarchical_label.cpp
View File

@ -1,34 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x01, 0x12, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x18, 0x05, 0x98,
0x20, 0xc8, 0x02, 0xa7, 0x54, 0xc8, 0xf5, 0x90, 0xff, 0xa1, 0x7e, 0xa8, 0x62, 0xc1, 0x31, 0x21,
0xff, 0x82, 0xf3, 0xb0, 0x2a, 0x0f, 0x36, 0x09, 0xf9, 0x1f, 0xf2, 0x3d, 0x64, 0x15, 0xb2, 0x58,
0xa8, 0x77, 0xc8, 0x6f, 0xa0, 0xe8, 0x9f, 0x90, 0x20, 0x6c, 0x1a, 0x26, 0x84, 0x7c, 0x0b, 0x99,
0x12, 0xf2, 0x3d, 0x94, 0x1f, 0xe1, 0x98, 0x90, 0xaf, 0x40, 0x3b, 0x8f, 0x80, 0x0d, 0xb2, 0x45,
0x53, 0xee, 0xc0, 0x12, 0xf2, 0x22, 0x64, 0x4b, 0x90, 0x1d, 0x50, 0x41, 0x32, 0xd4, 0x74, 0x95,
0x90, 0x97, 0x40, 0xa5, 0xb3, 0xc1, 0x46, 0xfd, 0x0f, 0xf9, 0x18, 0xa8, 0x8f, 0x6a, 0xbe, 0x17,
0x50, 0x30, 0xae, 0x81, 0x29, 0xe4, 0x49, 0xc8, 0x5e, 0x10, 0x3f, 0x42, 0x2a, 0xf8, 0x3e, 0x50,
0x64, 0xb3, 0x03, 0x0b, 0x03, 0x03, 0x50, 0x74, 0x15, 0x90, 0xfd, 0x34, 0x48, 0x1e, 0x59, 0xc3,
0xd2, 0x90, 0x1f, 0x20, 0xc7, 0x00, 0x4d, 0xfb, 0x1b, 0x21, 0x1b, 0xca, 0x1f, 0x72, 0x11, 0xa8,
0xe4, 0x68, 0x28, 0x27, 0x44, 0xd6, 0x93, 0x3d, 0x64, 0x3f, 0x90, 0x0f, 0x86, 0x60, 0x81, 0x58,
0xee, 0x90, 0xcf, 0x21, 0xeb, 0xc0, 0x0e, 0xb1, 0x04, 0x0a, 0x96, 0x11, 0xd4, 0x10, 0x1c, 0x0f,
0xe3, 0x82, 0xe1, 0x15, 0x82, 0x4e, 0x0a, 0xd9, 0x15, 0xf2, 0x3d, 0x78, 0x26, 0x04, 0x86, 0x9c,
0x0e, 0xf9, 0x0f, 0xf2, 0x20, 0xc4, 0xd3, 0xc1, 0x8b, 0x18, 0x18, 0xc1, 0x9e, 0xfe, 0x80, 0xe4,
0xe9, 0x08, 0x29, 0x60, 0x48, 0xaf, 0x85, 0x6b, 0x76, 0x00, 0x4a, 0x77, 0xe2, 0x0d, 0xd6, 0x90,
0x12, 0xa0, 0x70, 0x08, 0x8c, 0x07, 0x74, 0xc0, 0xe3, 0x90, 0xa7, 0xa1, 0xcc, 0x78, 0x22, 0x2e,
0xe4, 0x7c, 0xc8, 0x47, 0x98, 0xf7, 0xc0, 0xfc, 0x6e, 0xa0, 0x01, 0x4e, 0x88, 0xa4, 0x11, 0x92,
0x4b, 0xad, 0xc4, 0x37, 0x72, 0x00, 0x00, 0x6e, 0xff, 0x9c, 0x83, 0x44, 0x6c, 0xf2, 0xa7, 0x00,
0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_hierarchical_label_xpm[1] = {{ png, sizeof( png ), "add_hierarchical_label_xpm" }};
//EOF

63
bitmaps_png/cpp_24/add_hierarchical_subsheet.cpp
View File

@ -1,63 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x02, 0xe5, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x9d, 0x55, 0xef, 0x4b, 0x13,
0x71, 0x18, 0x5f, 0x6f, 0xa2, 0x97, 0x41, 0xf5, 0x1f, 0xd4, 0x7c, 0x59, 0xfd, 0x01, 0x81, 0xf3,
0x5d, 0x05, 0x35, 0x65, 0x3f, 0x6e, 0x77, 0x5b, 0x68, 0x64, 0x42, 0x10, 0xe2, 0x30, 0x42, 0xc1,
0x7e, 0x4c, 0xfa, 0x41, 0xa1, 0x2e, 0x8b, 0xcc, 0x68, 0x99, 0xa8, 0xcc, 0xe6, 0x08, 0xca, 0xc6,
0x52, 0x63, 0x9b, 0x9b, 0x96, 0xb5, 0xdc, 0xb2, 0x57, 0x46, 0xe4, 0x8b, 0x84, 0x84, 0xa9, 0x73,
0x36, 0x6e, 0x53, 0x36, 0x7d, 0xfa, 0x3e, 0xdf, 0xba, 0xd3, 0x3b, 0xcf, 0xb1, 0xdb, 0x17, 0x3e,
0xdc, 0xf7, 0xc7, 0xdd, 0xf3, 0xb9, 0xe7, 0xf3, 0x79, 0x9e, 0x3b, 0x8d, 0x86, 0x8c, 0xea, 0xea,
0xea, 0x7d, 0x36, 0x2b, 0xdb, 0xce, 0x30, 0xa6, 0x05, 0x83, 0xc1, 0x00, 0xa5, 0xc0, 0xc2, 0x98,
0x7f, 0xd9, 0x6c, 0x5c, 0xa7, 0x5e, 0xaf, 0xdf, 0xaf, 0xd9, 0x3e, 0x8c, 0x46, 0xe3, 0x5e, 0x72,
0x98, 0xec, 0x7e, 0x78, 0x2b, 0x3f, 0x31, 0xda, 0x0f, 0x5f, 0x27, 0xbd, 0x3b, 0x20, 0x04, 0x51,
0x3a, 0x13, 0x10, 0x19, 0xe9, 0x83, 0x9e, 0x27, 0xf7, 0x36, 0x59, 0x0b, 0x93, 0xae, 0xac, 0xac,
0x3c, 0x20, 0x12, 0xd8, 0x38, 0xae, 0xe9, 0x51, 0xbb, 0x23, 0x57, 0xe8, 0xe1, 0x62, 0x08, 0x04,
0xb8, 0x5f, 0x74, 0x80, 0x95, 0x63, 0x47, 0x44, 0x02, 0x8e, 0xb5, 0xc4, 0x03, 0xbe, 0x1e, 0x28,
0x86, 0x40, 0x05, 0x72, 0x22, 0x81, 0xd9, 0x64, 0x4a, 0x7c, 0x0a, 0xba, 0x15, 0x03, 0xc7, 0x27,
0x86, 0x60, 0xb0, 0xd7, 0x59, 0x92, 0x27, 0x5b, 0x04, 0x66, 0xf3, 0xe2, 0xe7, 0xd0, 0xe0, 0x0e,
0x29, 0x86, 0x3d, 0x5d, 0x50, 0x7f, 0xb9, 0x4e, 0xdc, 0xab, 0xab, 0xad, 0x29, 0x4a, 0x22, 0x21,
0x8e, 0x48, 0x60, 0x32, 0x19, 0x97, 0xa3, 0xa1, 0x97, 0x12, 0x82, 0x96, 0xe6, 0x06, 0x20, 0xe6,
0xd3, 0x39, 0xa9, 0x2e, 0x78, 0xec, 0x6c, 0x85, 0xe9, 0xb0, 0xa7, 0x64, 0x82, 0x95, 0xa8, 0x2c,
0x03, 0x04, 0xa9, 0x06, 0x78, 0x70, 0xff, 0x3a, 0x08, 0xd9, 0xa9, 0x81, 0x8c, 0xc0, 0x94, 0xfa,
0x32, 0x2e, 0xcd, 0xe0, 0xb6, 0xe3, 0x2a, 0xec, 0x56, 0xb2, 0xaa, 0x09, 0xc8, 0x82, 0xb7, 0x72,
0x16, 0x40, 0x14, 0x2a, 0xc7, 0xed, 0x12, 0xcd, 0xc6, 0xc7, 0x60, 0xf1, 0xf7, 0x0f, 0xc8, 0xf2,
0xab, 0xb0, 0x91, 0xcf, 0x51, 0xe0, 0x1c, 0xf7, 0x66, 0xe3, 0xa3, 0x3b, 0x08, 0x32, 0xf2, 0x0a,
0xf0, 0x79, 0xbb, 0x25, 0xc1, 0xd1, 0x03, 0xc4, 0xcc, 0xc7, 0x57, 0xb0, 0xb4, 0xf0, 0x13, 0xd6,
0x97, 0x92, 0x30, 0xd7, 0xe1, 0x82, 0xe8, 0xd9, 0x5a, 0x08, 0x1f, 0x3d, 0x49, 0x11, 0xd5, 0x5f,
0x84, 0x39, 0xa7, 0x0b, 0xd6, 0x16, 0x93, 0xe0, 0xf7, 0xfb, 0x61, 0x7b, 0x27, 0xf3, 0x93, 0x63,
0x03, 0x30, 0x15, 0x70, 0x8b, 0x04, 0x68, 0xb0, 0xe3, 0x5a, 0x23, 0x91, 0xa9, 0x0f, 0xde, 0x90,
0x6a, 0xc2, 0xf5, 0x9d, 0xd6, 0x66, 0x48, 0xa7, 0x12, 0x90, 0xf0, 0x87, 0x20, 0x7c, 0xfc, 0x34,
0x04, 0xb5, 0x3a, 0x45, 0xe0, 0x59, 0xe2, 0x5d, 0x48, 0x42, 0x90, 0x89, 0x45, 0x86, 0x24, 0x1e,
0x30, 0x8c, 0x59, 0x34, 0xfa, 0x9c, 0x8d, 0xa3, 0xf3, 0xa9, 0x0f, 0x11, 0x1a, 0x3c, 0x58, 0x56,
0x21, 0x09, 0x18, 0xab, 0x69, 0xa4, 0x90, 0x10, 0xe1, 0x3d, 0x65, 0xe5, 0x86, 0x7f, 0x04, 0x06,
0xc3, 0x5a, 0x2c, 0xe2, 0x91, 0x10, 0x8c, 0xfb, 0x7b, 0xa1, 0xa5, 0xa9, 0x41, 0x5c, 0xdb, 0xed,
0x76, 0x9a, 0xba, 0xd2, 0x9b, 0xa7, 0x93, 0x2b, 0x14, 0xf2, 0xfd, 0x90, 0x56, 0xb7, 0x1a, 0x3e,
0x7c, 0xe2, 0x10, 0x66, 0xb0, 0x8e, 0x1d, 0x2b, 0x6f, 0x34, 0x57, 0xd7, 0xdd, 0x2d, 0x4f, 0x7c,
0x3e, 0xaa, 0xb9, 0x92, 0x24, 0x3c, 0xcf, 0x53, 0x28, 0x9d, 0x05, 0x8e, 0xe8, 0x1c, 0x68, 0x72,
0x2e, 0x3e, 0x21, 0xad, 0x98, 0xd1, 0xd7, 0xcf, 0x44, 0x99, 0x10, 0xf3, 0xf3, 0xf3, 0x10, 0x3d,
0x73, 0x41, 0x35, 0x41, 0x50, 0x5b, 0x11, 0x43, 0x82, 0xbc, 0x90, 0x81, 0x80, 0x01, 0x57, 0x1b,
0x74, 0xb6, 0xdd, 0x80, 0x7e, 0x72, 0xf5, 0x79, 0x9f, 0x42, 0x36, 0x9b, 0x85, 0xf0, 0xb1, 0x53,
0xf4, 0xa1, 0xf8, 0xf9, 0x2b, 0xc4, 0xec, 0x55, 0x31, 0xb0, 0x1c, 0x78, 0x86, 0xf7, 0xfc, 0x27,
0xf9, 0x83, 0x04, 0x9b, 0x85, 0x9a, 0x06, 0xb3, 0xcb, 0x64, 0x32, 0xa2, 0xfe, 0x6a, 0x08, 0xd0,
0x07, 0xf4, 0x60, 0x43, 0x9e, 0x81, 0x9c, 0x80, 0x4a, 0x44, 0x6a, 0xbe, 0x24, 0x89, 0x58, 0x96,
0xf9, 0x1e, 0x78, 0xdb, 0x53, 0x90, 0x80, 0x9a, 0xec, 0x54, 0x6f, 0x32, 0xc9, 0xe0, 0xa6, 0x86,
0x61, 0x18, 0xd6, 0x5e, 0x7f, 0x89, 0x7f, 0x3f, 0xfc, 0x5c, 0xf1, 0x8b, 0x89, 0x04, 0x58, 0xa6,
0xd9, 0xc4, 0xb2, 0xaa, 0x32, 0x25, 0x48, 0x05, 0xb5, 0xe5, 0x07, 0xb1, 0x15, 0xf6, 0xb0, 0x2c,
0x5b, 0xc5, 0xb2, 0xe6, 0x6f, 0x44, 0xae, 0xfc, 0x6e, 0x3f, 0x10, 0x6c, 0x7f, 0xec, 0xd0, 0xa2,
0x1a, 0x4d, 0xab, 0xdb, 0x24, 0x25, 0x5a, 0xa5, 0x29, 0x65, 0x60, 0x87, 0xa2, 0x79, 0xbb, 0x7d,
0x2a, 0xf0, 0xcd, 0x4b, 0x0e, 0x2e, 0x0c, 0xec, 0x50, 0x6c, 0xa2, 0x50, 0x99, 0x6e, 0x9a, 0x04,
0x4c, 0x23, 0x70, 0x8e, 0x9a, 0x0b, 0xb2, 0x08, 0xe3, 0x2f, 0xc1, 0xc1, 0x51, 0xad, 0x8a, 0x03,
0x26, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_hierarchical_subsheet_xpm[1] = {{ png, sizeof( png ), "add_hierarchical_subsheet_xpm" }};
//EOF

28
bitmaps_png/cpp_24/add_junction.cpp
View File

@ -1,28 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0xa8, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x20, 0x01, 0x84,
0x84, 0x84, 0x1c, 0x06, 0x61, 0x06, 0x5a, 0x01, 0xa0, 0xe1, 0xff, 0x41, 0x78, 0xd4, 0x82, 0x51,
0x0b, 0x06, 0xa1, 0x05, 0x52, 0x0d, 0xc7, 0x34, 0xa4, 0x9b, 0x8e, 0xac, 0x95, 0xab, 0xdd, 0xfd,
0x5f, 0xb6, 0x6e, 0xdf, 0x7f, 0xa9, 0xa6, 0xa3, 0xeb, 0xa5, 0x9a, 0x8f, 0xa8, 0x53, 0xc5, 0x70,
0xe9, 0x86, 0xc3, 0x6a, 0x52, 0x8d, 0x47, 0xde, 0x02, 0xf1, 0x7f, 0x34, 0xfc, 0x4e, 0xaa, 0xe5,
0xa0, 0x2c, 0xe5, 0x16, 0x34, 0x1e, 0x59, 0x83, 0xc5, 0x70, 0x28, 0x3e, 0xba, 0x8a, 0xd8, 0xec,
0xff, 0x1f, 0x17, 0x96, 0xab, 0xdf, 0xf7, 0x1f, 0xb7, 0x05, 0x47, 0x3e, 0x52, 0x6c, 0x01, 0x38,
0xcc, 0x71, 0x5b, 0xf0, 0x9a, 0xf2, 0x20, 0x02, 0x46, 0x2e, 0x45, 0x41, 0x44, 0x08, 0x88, 0x37,
0x1f, 0x54, 0xc4, 0x11, 0xc9, 0xaf, 0x41, 0x09, 0x80, 0x2a, 0x29, 0x09, 0x64, 0x89, 0x64, 0xd3,
0xe1, 0xd5, 0xf2, 0x75, 0x7b, 0xfe, 0xcb, 0x01, 0xb1, 0x54, 0xc3, 0x91, 0x95, 0x32, 0x0d, 0xc7,
0x54, 0x46, 0x73, 0xf2, 0xa8, 0x05, 0x23, 0xd4, 0x02, 0x92, 0x9b, 0x2d, 0x00, 0xf4, 0x16, 0xe1,
0xae, 0xde, 0x0d, 0xa3, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60,
0x82,
};
const BITMAP_OPAQUE add_junction_xpm[1] = {{ png, sizeof( png ), "add_junction_xpm" }};
//EOF

34
bitmaps_png/cpp_24/add_keepout_area.cpp
View File

@ -1,34 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x01, 0x11, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0xa0, 0x3b, 0x08,
0xf9, 0x8f, 0x1b, 0xe2, 0xd6, 0xf0, 0x30, 0x54, 0x91, 0x81, 0x21, 0x4a, 0x30, 0xe4, 0x4c, 0xc8,
0xff, 0xe0, 0x6b, 0xa1, 0x12, 0x30, 0x36, 0x0e, 0x0d, 0xc1, 0x77, 0x80, 0x5a, 0x1e, 0x44, 0x28,
0xa0, 0x6a, 0x89, 0x14, 0xc1, 0xa9, 0x21, 0x42, 0x16, 0xbb, 0x16, 0x9c, 0x1a, 0x18, 0x18, 0x22,
0x64, 0x43, 0x6e, 0x03, 0xb5, 0xdc, 0x0e, 0x95, 0x46, 0xd6, 0x82, 0x47, 0x03, 0x03, 0x43, 0x90,
0x0c, 0x58, 0xcb, 0x2d, 0x64, 0x2d, 0xb8, 0xfd, 0xd0, 0x05, 0xa2, 0x43, 0x25, 0x40, 0x4a, 0x42,
0x6e, 0x45, 0x48, 0x81, 0xdd, 0x7f, 0x11, 0x6f, 0x28, 0x05, 0x4f, 0x63, 0x60, 0x04, 0x69, 0x09,
0xb9, 0x0a, 0x64, 0xdf, 0x04, 0x69, 0x21, 0x18, 0x4a, 0xc1, 0x33, 0x1b, 0x98, 0x80, 0x26, 0x8b,
0x83, 0xb4, 0x84, 0xdc, 0x08, 0x92, 0x24, 0x26, 0x94, 0x96, 0x84, 0x32, 0x83, 0xb5, 0x5c, 0x81,
0x69, 0x41, 0xd2, 0x80, 0x1e, 0x9f, 0xd0, 0x50, 0x5a, 0xee, 0xc0, 0xc2, 0xc0, 0x10, 0x28, 0x16,
0x7a, 0x19, 0xc8, 0xbe, 0x8e, 0x12, 0x4a, 0x21, 0xff, 0x23, 0x45, 0x50, 0xc3, 0x1c, 0x1a, 0x4a,
0xab, 0xd2, 0x58, 0x11, 0x5a, 0x50, 0x34, 0x20, 0x27, 0x00, 0x08, 0x1b, 0xe2, 0xe5, 0x90, 0x2d,
0x09, 0x1c, 0x20, 0x2d, 0x60, 0x87, 0xa1, 0x39, 0xe9, 0x22, 0xba, 0x2d, 0x50, 0x2f, 0x6f, 0x0f,
0xe5, 0x04, 0x6a, 0x17, 0x0d, 0xb9, 0x84, 0xaa, 0xe1, 0x0c, 0x36, 0x5b, 0xa0, 0x5e, 0x3e, 0x10,
0xca, 0x03, 0xd6, 0x82, 0xac, 0x01, 0x33, 0x65, 0xa2, 0x68, 0x39, 0x1c, 0xcd, 0x87, 0x16, 0x4a,
0xd8, 0x12, 0x33, 0x84, 0x0d, 0xf5, 0xf2, 0xe9, 0x50, 0x21, 0x14, 0x0d, 0x41, 0xf2, 0xf8, 0xb4,
0x80, 0xdc, 0x1f, 0x7a, 0x16, 0xd5, 0x0f, 0xb7, 0x40, 0x51, 0x83, 0x5f, 0x0b, 0xce, 0x88, 0x23,
0x31, 0x8b, 0x52, 0x1d, 0x00, 0x00, 0x05, 0x4b, 0x26, 0xd9, 0xa9, 0xed, 0xf8, 0x6b, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_keepout_area_xpm[1] = {{ png, sizeof( png ), "add_keepout_area_xpm" }};
//EOF

28
bitmaps_png/cpp_24/add_label.cpp
View File

@ -1,28 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x00, 0xb6, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x18, 0xa6, 0x20,
0x94, 0x39, 0xe4, 0x46, 0xc8, 0xbb, 0x50, 0x75, 0xa2, 0x35, 0x84, 0xb8, 0x85, 0xfc, 0x0f, 0xf9,
0x1e, 0xd2, 0x4a, 0xb4, 0x86, 0xe0, 0xa5, 0x21, 0x0f, 0x43, 0x96, 0x85, 0x3c, 0x6c, 0x60, 0x22,
0x4a, 0x79, 0x34, 0x5f, 0xc8, 0xd7, 0x90, 0xa9, 0xa1, 0xe1, 0x21, 0xff, 0x43, 0x9d, 0x88, 0xf3,
0x41, 0x32, 0x50, 0xa9, 0x8d, 0x2f, 0x57, 0xc8, 0xe7, 0xe0, 0xf9, 0xc4, 0xf9, 0xe0, 0x50, 0xf0,
0x23, 0x90, 0x63, 0x42, 0x16, 0x87, 0x7c, 0x09, 0xe5, 0x21, 0xec, 0x7e, 0xa5, 0x90, 0x7f, 0xa1,
0x9b, 0x82, 0x5d, 0x82, 0x5d, 0x42, 0x9a, 0x81, 0x36, 0xc5, 0x12, 0x36, 0xbf, 0x1e, 0x18, 0x42,
0x08, 0xb8, 0x8b, 0x90, 0x7a, 0xc6, 0xe0, 0x3b, 0x40, 0xe8, 0x02, 0x81, 0x21, 0x5b, 0x42, 0xfe,
0x06, 0xc9, 0xe0, 0x37, 0xdf, 0x16, 0x68, 0x6a, 0x3d, 0x9c, 0xe7, 0x09, 0x74, 0x54, 0x05, 0x7e,
0x1f, 0xcc, 0x09, 0xf9, 0x1f, 0xae, 0x06, 0xe3, 0x39, 0xb0, 0x84, 0x3c, 0x0f, 0xbe, 0x86, 0xdf,
0x86, 0xca, 0xd0, 0x52, 0x14, 0x7e, 0x44, 0x48, 0x47, 0x94, 0x20, 0xa5, 0x49, 0x2d, 0xe4, 0x30,
0x4a, 0xb8, 0xe0, 0x83, 0x87, 0xc9, 0xd3, 0x30, 0xf2, 0x00, 0x00, 0xa7, 0xc9, 0x7b, 0xe2, 0x09,
0x75, 0x3c, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_label_xpm[1] = {{ png, sizeof( png ), "add_label_xpm" }};
//EOF

44
bitmaps_png/cpp_24/add_leader.cpp
View File

@ -1,44 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0xb1, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0xed, 0x94, 0xbd, 0x4b, 0x03,
0x41, 0x10, 0xc5, 0x63, 0xe3, 0x47, 0x61, 0x23, 0x58, 0x24, 0xc1, 0x58, 0xf8, 0x41, 0x24, 0x55,
0xb0, 0x10, 0x44, 0x54, 0xd4, 0x42, 0x2c, 0x52, 0x5c, 0x12, 0xee, 0x3a, 0x83, 0xbd, 0xad, 0xa5,
0xde, 0x81, 0x45, 0x0a, 0x11, 0xa3, 0xf1, 0xef, 0xb0, 0x50, 0x02, 0x22, 0x58, 0x68, 0x62, 0xa3,
0xad, 0xa0, 0x58, 0xa8, 0x68, 0x48, 0x34, 0x6a, 0xa1, 0x85, 0xa0, 0xc8, 0xf9, 0x1e, 0xcc, 0xc1,
0x19, 0xf5, 0x94, 0xf3, 0xd4, 0x26, 0x0b, 0x8f, 0x1b, 0x66, 0x77, 0xe7, 0xb7, 0x3b, 0x33, 0x7b,
0x3e, 0x5f, 0x6d, 0xfc, 0xfb, 0x88, 0xe8, 0x87, 0xf5, 0x41, 0xa3, 0xb0, 0x14, 0x30, 0xf2, 0xb7,
0x50, 0x31, 0x60, 0x14, 0xd2, 0xf4, 0x79, 0x06, 0x90, 0xe0, 0xe6, 0x5b, 0x15, 0xd2, 0x9e, 0x01,
0x10, 0xf0, 0xee, 0x3d, 0x20, 0x5f, 0xfc, 0x15, 0x40, 0x68, 0x6e, 0xdb, 0x0c, 0xea, 0x3b, 0xb4,
0x2b, 0x9e, 0x01, 0xfc, 0x46, 0x7e, 0xd1, 0x02, 0x30, 0xf8, 0xe8, 0xd4, 0x8c, 0xd9, 0x3b, 0xbd,
0xb2, 0xe6, 0x19, 0xa0, 0x73, 0x39, 0xd7, 0x80, 0x9c, 0x2f, 0xf0, 0xd4, 0xd0, 0x0d, 0x83, 0x27,
0x12, 0x09, 0x33, 0x99, 0x4c, 0x6e, 0xc5, 0xe3, 0xf1, 0x88, 0xd3, 0x5e, 0x45, 0x51, 0xda, 0xb1,
0x36, 0x03, 0x9d, 0x43, 0xf7, 0xd0, 0x09, 0x94, 0x85, 0xdf, 0xef, 0x08, 0xc5, 0xa2, 0x1c, 0x21,
0xd0, 0x13, 0x20, 0xd1, 0x8f, 0xd6, 0xc0, 0x3f, 0x86, 0xf9, 0x0b, 0x48, 0x57, 0x55, 0xb5, 0x3b,
0x95, 0x4a, 0x35, 0xe2, 0xdb, 0x81, 0x83, 0xcd, 0xc2, 0x57, 0x86, 0x86, 0x3f, 0x05, 0x60, 0x73,
0x18, 0x7a, 0xc6, 0xa2, 0x07, 0x6c, 0x18, 0xaa, 0x9e, 0x87, 0x2f, 0x84, 0xb9, 0x4b, 0xa8, 0x1f,
0xf6, 0x00, 0x6f, 0x22, 0xfe, 0x16, 0xd8, 0x83, 0xf4, 0x43, 0x25, 0x4d, 0xd3, 0xda, 0x9c, 0x20,
0x51, 0x6e, 0xe6, 0x69, 0xf0, 0x1d, 0xa9, 0xba, 0x61, 0x06, 0xf3, 0x86, 0xd8, 0xeb, 0xd0, 0x2e,
0xcc, 0x3a, 0xf8, 0xfa, 0x60, 0x6f, 0x8a, 0x5f, 0xe7, 0xba, 0x2f, 0x6b, 0x24, 0x90, 0x2b, 0x3b,
0x04, 0x81, 0x4e, 0x99, 0x16, 0x1b, 0x60, 0x0f, 0xbe, 0x49, 0x3b, 0x00, 0x76, 0x17, 0xec, 0xa3,
0x6f, 0x35, 0x02, 0xf3, 0x29, 0x45, 0x34, 0x45, 0x2f, 0xcc, 0xb9, 0x05, 0x00, 0x7c, 0x1c, 0xdf,
0x03, 0x04, 0x9d, 0xb0, 0x00, 0xf0, 0x35, 0xc1, 0x7e, 0x74, 0xd5, 0x79, 0xec, 0x16, 0x16, 0xd4,
0x02, 0x48, 0xde, 0x15, 0x68, 0xdf, 0x76, 0x83, 0x30, 0xec, 0x33, 0xb7, 0x80, 0x2c, 0x73, 0x6c,
0x07, 0x88, 0xbd, 0x61, 0x03, 0xcc, 0xc3, 0x5e, 0x75, 0x05, 0x60, 0x9f, 0x63, 0x73, 0x85, 0xf5,
0x11, 0xb5, 0xd2, 0x8f, 0xae, 0x09, 0x10, 0x26, 0x37, 0x2a, 0xb1, 0xdb, 0x5c, 0x3f, 0x50, 0xa9,
0xcb, 0x35, 0xbb, 0x89, 0x05, 0x8d, 0xc5, 0x62, 0xcd, 0x48, 0x5b, 0x8f, 0x9c, 0xbc, 0xcc, 0x77,
0xf2, 0xe3, 0xbf, 0x80, 0xbc, 0x07, 0xb6, 0xec, 0x31, 0x0b, 0xca, 0x9c, 0x33, 0x2d, 0x8e, 0xfd,
0x5f, 0x1b, 0x7f, 0x3e, 0x5e, 0x01, 0x9f, 0x5b, 0xf9, 0xa7, 0xf7, 0x73, 0x6c, 0xe4, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_leader_xpm[1] = {{ png, sizeof( png ), "add_leader_xpm" }};
//EOF

50
bitmaps_png/cpp_24/add_library.cpp
View File

@ -1,50 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x02, 0x09, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x18, 0xec, 0xc0,
0x24, 0xab, 0x3f, 0x44, 0xbf, 0x60, 0xd6, 0x12, 0xbc, 0x8a, 0x42, 0x42, 0x42, 0xfe, 0xa3, 0x63,
0x7c, 0xe2, 0xc6, 0x39, 0x93, 0xb3, 0x74, 0x4a, 0x16, 0x9d, 0x56, 0xaa, 0xd9, 0xf1, 0x4b, 0xaa,
0xf1, 0xc8, 0x7f, 0xa9, 0x86, 0xc3, 0xff, 0x2d, 0xf2, 0x27, 0x98, 0x53, 0xcd, 0x02, 0xa5, 0xaa,
0xcd, 0xdf, 0xc1, 0x06, 0x03, 0xb1, 0x46, 0xdb, 0x61, 0x30, 0x36, 0x28, 0x9a, 0xb3, 0x0a, 0xaf,
0x05, 0x6b, 0xd7, 0xae, 0xfd, 0xbf, 0x73, 0xe7, 0x4e, 0x30, 0x8d, 0x6c, 0x01, 0x36, 0x71, 0xdd,
0xa2, 0x79, 0x07, 0x0c, 0x3a, 0x0f, 0xfd, 0x9f, 0xbc, 0x7a, 0xf7, 0xff, 0xf5, 0xdb, 0x76, 0xfd,
0x0f, 0x9b, 0x76, 0xe0, 0xbf, 0x5a, 0xf9, 0x9a, 0xb7, 0x54, 0xf3, 0x81, 0x69, 0xce, 0xe4, 0x70,
0xe5, 0x96, 0xc3, 0xff, 0x5d, 0x26, 0x1c, 0xfc, 0xaf, 0x04, 0xa5, 0xe5, 0x1a, 0x0f, 0xfd, 0x37,
0xcb, 0xee, 0x55, 0xa3, 0x8a, 0x0f, 0xc0, 0xc1, 0x04, 0x0c, 0xff, 0x94, 0xd9, 0xfb, 0xff, 0x6f,
0x00, 0xfa, 0x60, 0xc2, 0xaa, 0x3d, 0xff, 0x55, 0x5b, 0x0f, 0xff, 0x37, 0x2a, 0x9c, 0x39, 0x93,
0x2a, 0x3e, 0x00, 0x01, 0x60, 0x24, 0x9f, 0xd5, 0xef, 0x00, 0x85, 0xff, 0x91, 0xff, 0x56, 0x3d,
0x87, 0xfe, 0x3b, 0x03, 0x7d, 0xa1, 0x51, 0xb6, 0xf2, 0x29, 0xd5, 0x7c, 0x60, 0x98, 0x33, 0x39,
0x57, 0xa1, 0xf9, 0xf0, 0xff, 0xa5, 0x9b, 0x76, 0xff, 0x5f, 0xb8, 0x71, 0xf7, 0xff, 0xa8, 0xe9,
0xfb, 0xff, 0xcb, 0xd4, 0xef, 0xff, 0x6f, 0x55, 0xd2, 0x2d, 0x46, 0x15, 0x1f, 0x68, 0x37, 0x34,
0xb0, 0xc9, 0xd5, 0xee, 0xfe, 0xab, 0x09, 0x4c, 0x41, 0xb0, 0x14, 0x05, 0xc2, 0x86, 0x79, 0x53,
0xdb, 0x29, 0xb6, 0x60, 0xa7, 0xb2, 0x9b, 0xd8, 0x7e, 0x75, 0x87, 0xe6, 0x65, 0xc6, 0x41, 0x3f,
0x76, 0x68, 0xb9, 0xfd, 0x07, 0xe1, 0xf9, 0x16, 0xd1, 0xff, 0xf3, 0x83, 0x1b, 0xfe, 0x5b, 0xe4,
0xce, 0xbd, 0x4f, 0x91, 0x05, 0x40, 0x83, 0x43, 0xf6, 0xab, 0x39, 0x7e, 0x02, 0xe2, 0xff, 0xd8,
0xf0, 0x76, 0x2d, 0x8f, 0xff, 0x3b, 0xb4, 0xdd, 0xa3, 0xc8, 0xb2, 0xa0, 0xdc, 0xd5, 0x17, 0x64,
0xc8, 0x3f, 0x64, 0x03, 0xcf, 0x25, 0x96, 0x80, 0x31, 0x9a, 0x45, 0xff, 0x40, 0x0e, 0x21, 0xc9,
0x82, 0xd8, 0x80, 0xa0, 0xff, 0xbb, 0x34, 0x9d, 0x30, 0x5c, 0xfc, 0xf9, 0xdd, 0x7b, 0x30, 0xc6,
0xe2, 0x9b, 0x4f, 0xa0, 0xa0, 0x24, 0xda, 0x82, 0x2e, 0x1b, 0x2f, 0xac, 0x41, 0xf2, 0xf5, 0xeb,
0x57, 0x30, 0xc6, 0x1a, 0x64, 0xc0, 0x78, 0x22, 0xda, 0x82, 0x55, 0xfa, 0xae, 0xa4, 0x5b, 0xa0,
0xe6, 0x78, 0x81, 0x68, 0x0b, 0x76, 0x42, 0x83, 0xe7, 0x7c, 0x52, 0xe9, 0xff, 0xcf, 0x1f, 0x3e,
0xc2, 0x0d, 0x46, 0xc7, 0x20, 0x39, 0x90, 0x1a, 0xa8, 0x05, 0x5f, 0x68, 0x6d, 0xc1, 0x67, 0xb0,
0x05, 0x55, 0x55, 0x55, 0xe0, 0xdc, 0x0a, 0xc3, 0x20, 0x3e, 0xba, 0xf8, 0x3e, 0xe7, 0x08, 0x92,
0x83, 0x68, 0xbb, 0xb6, 0xeb, 0x5d, 0xa2, 0x7d, 0xd0, 0x6d, 0xeb, 0x4d, 0xb2, 0x05, 0xad, 0xae,
0xa9, 0xb7, 0x69, 0x96, 0x4c, 0xb7, 0x6b, 0xbb, 0xff, 0x77, 0xc8, 0x9c, 0xb8, 0x9d, 0xa4, 0x8c,
0x56, 0xe6, 0xea, 0xf7, 0x7f, 0x9f, 0x9a, 0xe3, 0x5f, 0x62, 0x32, 0xda, 0x1e, 0x75, 0xe7, 0x10,
0xb2, 0x2a, 0xf9, 0x7d, 0xaa, 0x8e, 0x41, 0x07, 0xd4, 0x1c, 0x3f, 0xe2, 0x2a, 0x2a, 0x40, 0x72,
0x40, 0x35, 0xc1, 0x14, 0xb5, 0x24, 0xf6, 0xab, 0x39, 0x88, 0x00, 0x0d, 0x6a, 0x3c, 0xa0, 0xee,
0x78, 0x16, 0x5a, 0x2e, 0x7d, 0x06, 0xb1, 0x41, 0x62, 0x20, 0x39, 0x64, 0xb5, 0x00, 0x21, 0x4f,
0x95, 0x87, 0x7b, 0x75, 0x69, 0xcd, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE add_library_xpm[1] = {{ png, sizeof( png ), "add_library_xpm" }};
//EOF

21
bitmaps_png/cpp_24/add_line.cpp
View File

@ -1,21 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x00, 0x43, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x18, 0x24, 0x20,
0x50, 0x2c, 0xe4, 0x4c, 0xc8, 0x61, 0x12, 0x94, 0x87, 0x5e, 0x0e, 0xf9, 0x1f, 0x7a, 0x8a, 0x48,
0xe5, 0xa1, 0xa2, 0x21, 0x97, 0x42, 0xfe, 0x87, 0x5c, 0x0f, 0x95, 0x18, 0x55, 0x3e, 0xaa, 0x7c,
0xf8, 0x2b, 0x07, 0x6a, 0x38, 0x05, 0xcc, 0x1e, 0x97, 0x03, 0xc5, 0x88, 0xce, 0x51, 0x21, 0x87,
0x43, 0xce, 0x90, 0xa0, 0x9c, 0xc6, 0x00, 0x00, 0x15, 0xc6, 0x54, 0xef, 0x26, 0x2f, 0x8d, 0xc0,
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_line_xpm[1] = {{ png, sizeof( png ), "add_line_xpm" }};
//EOF

27
bitmaps_png/cpp_24/add_line2bus.cpp
View File

@ -1,27 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0xa1, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0xa0, 0x22, 0x08,
0x09, 0x09, 0xf9, 0x0f, 0xc3, 0x0c, 0xb4, 0x00, 0x38, 0x2d, 0x00, 0x0a, 0x1c, 0x46, 0x96, 0xc4,
0x86, 0x5d, 0x12, 0x4b, 0xff, 0xcb, 0xd6, 0xed, 0xfb, 0xaf, 0x5d, 0xbc, 0x78, 0x2a, 0x4d, 0x2c,
0x70, 0x06, 0x5a, 0x20, 0xd5, 0x70, 0xf8, 0xbf, 0x54, 0xe3, 0x91, 0x7f, 0x52, 0x4d, 0x87, 0xb3,
0x68, 0x12, 0x44, 0x92, 0x8d, 0x47, 0x53, 0xc1, 0x16, 0x80, 0xf1, 0xd1, 0x5c, 0x9a, 0xc4, 0x01,
0x3e, 0x4b, 0xa8, 0x16, 0xc9, 0xb8, 0x2c, 0xa1, 0x6a, 0x2a, 0xc2, 0x66, 0x09, 0xd5, 0x93, 0x29,
0xba, 0x25, 0x34, 0xc9, 0x07, 0xc8, 0x96, 0x58, 0xa7, 0xb7, 0xd0, 0x26, 0x1f, 0xc0, 0x2d, 0x01,
0x26, 0x63, 0x98, 0x25, 0x54, 0xcf, 0x07, 0x20, 0x31, 0xb0, 0x3c, 0x10, 0x83, 0xd4, 0xd2, 0x24,
0x1f, 0xd8, 0xa4, 0x35, 0x81, 0x7d, 0xe9, 0x42, 0xae, 0x05, 0xa3, 0xf9, 0x60, 0x08, 0xe7, 0x03,
0xaa, 0x59, 0x82, 0x2b, 0x1f, 0x50, 0x03, 0x50, 0x25, 0x1f, 0x10, 0x02, 0x54, 0xc9, 0x07, 0x83,
0xb3, 0xd2, 0xa7, 0xa5, 0x05, 0x00, 0x2c, 0x1b, 0x62, 0xf2, 0xb8, 0x79, 0xb4, 0x9a, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_line2bus_xpm[1] = {{ png, sizeof( png ), "add_line2bus_xpm" }};
//EOF

38
bitmaps_png/cpp_24/add_line_label.cpp
View File

@ -1,38 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0x4d, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x18, 0x0c, 0x20,
0x24, 0x24, 0x24, 0x1a, 0x88, 0xff, 0x23, 0xe1, 0x1b, 0xd4, 0xb6, 0x60, 0x0f, 0x9a, 0x05, 0xff,
0x43, 0x43, 0x43, 0xcd, 0xa8, 0x62, 0x78, 0x50, 0x50, 0x90, 0x3c, 0xd0, 0xc0, 0xbf, 0x50, 0x83,
0xbf, 0x20, 0x59, 0x32, 0x83, 0x2a, 0x16, 0x00, 0x5d, 0x5a, 0x07, 0x33, 0x34, 0x38, 0x38, 0xb8,
0x05, 0x48, 0x7f, 0x83, 0xf2, 0x3f, 0x00, 0xe5, 0x38, 0x29, 0x35, 0x9f, 0x11, 0x68, 0xd0, 0x3d,
0xa4, 0x60, 0x31, 0x00, 0xd2, 0x1b, 0x91, 0xf8, 0x51, 0x94, 0x06, 0x8f, 0x23, 0x52, 0x90, 0x3c,
0x04, 0x59, 0x08, 0x34, 0x34, 0x16, 0xc9, 0x82, 0xdd, 0x14, 0x59, 0x00, 0x0c, 0x92, 0x45, 0x48,
0x16, 0xf4, 0x80, 0xc4, 0xfc, 0xfc, 0xfc, 0x78, 0x91, 0x82, 0xe9, 0x1f, 0xd0, 0x12, 0x45, 0xb2,
0x0c, 0x8f, 0x8e, 0x8e, 0xe6, 0x03, 0x1a, 0xf0, 0x15, 0x29, 0xfc, 0x0d, 0x91, 0x52, 0xd5, 0x6a,
0x24, 0x8b, 0x6b, 0xc9, 0x75, 0x7d, 0x2a, 0x92, 0x21, 0xd7, 0xd1, 0x92, 0x6d, 0x10, 0x92, 0xdc,
0xbd, 0x86, 0x86, 0x06, 0x26, 0x72, 0xd2, 0xfe, 0x31, 0xa4, 0xb0, 0xae, 0x46, 0x96, 0x4b, 0x48,
0x48, 0xe0, 0x00, 0x8a, 0xbf, 0x47, 0xb2, 0xc4, 0x81, 0xd4, 0xa4, 0xa9, 0x8e, 0x96, 0xb1, 0x16,
0x03, 0x71, 0x07, 0x1a, 0xbe, 0x8b, 0x24, 0xbf, 0x90, 0x54, 0xd7, 0x77, 0xa0, 0xe7, 0x5c, 0x02,
0xf8, 0x0b, 0x28, 0xce, 0x88, 0x75, 0x3d, 0x33, 0x50, 0xc3, 0x53, 0x12, 0x2d, 0x00, 0x05, 0x63,
0x32, 0xb1, 0x91, 0xeb, 0x85, 0xa4, 0xf1, 0x1f, 0x10, 0x87, 0x02, 0xc5, 0x5c, 0xb0, 0x61, 0xa0,
0xdc, 0x2e, 0x24, 0xb5, 0x47, 0x89, 0xf5, 0xc1, 0x1a, 0x24, 0x4d, 0xc7, 0x08, 0x04, 0x25, 0x72,
0x6a, 0x02, 0x25, 0x65, 0x0d, 0xbc, 0x86, 0x07, 0x06, 0x06, 0x0a, 0x03, 0x15, 0xfe, 0x40, 0xd2,
0x94, 0x4b, 0xc0, 0x31, 0x6c, 0x40, 0x35, 0x6f, 0x91, 0x2c, 0x68, 0x27, 0x14, 0x3c, 0x79, 0x48,
0x86, 0xff, 0x89, 0x8c, 0x8c, 0x14, 0x27, 0x22, 0x41, 0xcc, 0x46, 0xd2, 0xf3, 0x14, 0x14, 0x87,
0xf8, 0x14, 0x9f, 0x47, 0x8a, 0xb4, 0x1d, 0x44, 0xa6, 0x38, 0x07, 0xb4, 0x60, 0xf2, 0xa2, 0x7f,
0x95, 0x28, 0xd5, 0x78, 0xe4, 0x30, 0x10, 0xff, 0xa7, 0x32, 0x3e, 0x4c, 0x3f, 0x0b, 0x86, 0x34,
0x00, 0x00, 0x59, 0x95, 0x94, 0x84, 0x45, 0x27, 0x24, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45,
0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_line_label_xpm[1] = {{ png, sizeof( png ), "add_line_label_xpm" }};
//EOF

36
bitmaps_png/cpp_24/add_orthogonal_dimension.cpp
View File

@ -1,36 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0x32, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x00, 0x81, 0xff,
0xff, 0x19, 0xa5, 0x1a, 0x8e, 0xf8, 0x49, 0x35, 0x1e, 0x2e, 0x97, 0x69, 0x38, 0xe2, 0x05, 0xe2,
0x33, 0x50, 0x0d, 0x40, 0x0c, 0x5f, 0x29, 0xd5, 0x78, 0xe4, 0x3f, 0x0c, 0x4b, 0x37, 0x1e, 0x59,
0x43, 0x35, 0x4b, 0x20, 0x2e, 0x47, 0x18, 0x0e, 0xc3, 0x60, 0x9f, 0x50, 0x03, 0x48, 0x36, 0x1d,
0xa9, 0xc2, 0x66, 0x81, 0x55, 0x66, 0xfb, 0xff, 0x90, 0x90, 0x10, 0xb2, 0x71, 0x70, 0x70, 0xf0,
0x35, 0xb0, 0x05, 0x20, 0x97, 0x62, 0xb3, 0x00, 0x88, 0x5d, 0xc9, 0x71, 0x70, 0x68, 0x68, 0xa8,
0x1f, 0x46, 0x1c, 0x80, 0xc2, 0x1c, 0xcd, 0xf0, 0x25, 0xe4, 0x18, 0xee, 0xe0, 0xe0, 0xc0, 0x02,
0x74, 0xf9, 0xfd, 0xb4, 0xb4, 0x34, 0x56, 0x0c, 0x4b, 0x40, 0x3e, 0x91, 0x6e, 0x3c, 0x5c, 0x4c,
0xae, 0xcb, 0x41, 0x20, 0x28, 0x28, 0xc8, 0x11, 0x1a, 0x44, 0x0e, 0x0c, 0xb4, 0x00, 0x40, 0xd7,
0xf7, 0x42, 0x2d, 0xe8, 0xa1, 0x95, 0x05, 0x37, 0xa1, 0x16, 0xdc, 0x66, 0xa0, 0x15, 0x00, 0x59,
0xc0, 0x40, 0x4b, 0x30, 0x6a, 0xc1, 0x30, 0xb7, 0x00, 0x29, 0x99, 0xde, 0xa0, 0x95, 0xeb, 0x7b,
0xa0, 0x16, 0x74, 0x93, 0x5e, 0xac, 0xb7, 0x1c, 0x94, 0x95, 0x6a, 0x3a, 0x9a, 0x27, 0xd5, 0x74,
0x24, 0x47, 0xa6, 0xe5, 0x98, 0x34, 0x0e, 0x0b, 0x1c, 0x40, 0x16, 0x00, 0x0b, 0x3c, 0x7b, 0x92,
0x0c, 0x97, 0x6e, 0x3a, 0x6a, 0x09, 0x2c, 0xa3, 0x3e, 0x22, 0x15, 0x86, 0x9f, 0xa5, 0x1a, 0x8e,
0x59, 0x61, 0x29, 0x49, 0x99, 0x41, 0xb9, 0x18, 0x54, 0xe8, 0x91, 0xe6, 0xfa, 0xc6, 0x23, 0xe7,
0xd0, 0x8b, 0x73, 0x60, 0x09, 0x7c, 0x0a, 0x47, 0x3c, 0xf8, 0x92, 0x1e, 0x3c, 0x8d, 0x47, 0x7e,
0xa1, 0x5b, 0x20, 0x5b, 0x7f, 0x80, 0x50, 0xa5, 0x73, 0x91, 0xf8, 0x20, 0x02, 0xba, 0x16, 0x4b,
0x85, 0x74, 0x84, 0x6a, 0xa9, 0x03, 0x14, 0xde, 0xe0, 0x70, 0x47, 0x18, 0xfe, 0x4e, 0xa2, 0xe9,
0xa8, 0x29, 0x55, 0x93, 0x20, 0x28, 0xe5, 0x00, 0x9b, 0x35, 0xd9, 0x92, 0x8d, 0x47, 0x53, 0x45,
0x1b, 0xf6, 0x4b, 0x10, 0xab, 0x0f, 0x00, 0x23, 0x1a, 0x0e, 0x0f, 0x23, 0x53, 0x7a, 0xc2, 0x00,
0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_orthogonal_dimension_xpm[1] = {{ png, sizeof( png ), "add_orthogonal_dimension_xpm" }};
//EOF

33
bitmaps_png/cpp_24/add_pcb_target.cpp
View File

@ -1,33 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x01, 0x05, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0xc0, 0x0a, 0x8c,
0x0f, 0x1b, 0x1f, 0x66, 0x20, 0x05, 0x18, 0xff, 0x37, 0xfe, 0x4f, 0x94, 0xc2, 0x06, 0xa6, 0x9d,
0xae, 0x3b, 0xa7, 0xee, 0x3c, 0x06, 0xd2, 0x90, 0xf6, 0xa9, 0xe8, 0x42, 0x63, 0x71, 0x03, 0x13,
0x1e, 0xe5, 0x3b, 0x9d, 0x76, 0x9e, 0xdf, 0xf9, 0x1f, 0x04, 0x41, 0x1a, 0x42, 0xc0, 0x30, 0xed,
0x4b, 0x5d, 0x36, 0x0e, 0xe5, 0xbb, 0xf2, 0x77, 0xfe, 0x85, 0x28, 0x47, 0xd6, 0x10, 0xf2, 0x3f,
0xf4, 0x7f, 0xf9, 0x36, 0x6c, 0xa6, 0x57, 0xc0, 0x14, 0xa3, 0x6b, 0x00, 0xc1, 0xaa, 0x75, 0x98,
0x8e, 0xf9, 0x8b, 0x4f, 0x43, 0xd8, 0xff, 0x86, 0x0c, 0x14, 0xaf, 0xee, 0x38, 0x87, 0xac, 0x1c,
0x53, 0x43, 0xc8, 0xff, 0xd4, 0x2f, 0x48, 0xde, 0xdf, 0xe5, 0x86, 0xaa, 0x1c, 0x9b, 0x86, 0x90,
0xff, 0xb5, 0x39, 0x08, 0x0d, 0xd3, 0x89, 0xd1, 0x50, 0x7c, 0x06, 0xe1, 0x83, 0xd3, 0xc4, 0x68,
0xc8, 0xf8, 0x00, 0x4b, 0x04, 0xff, 0x49, 0x80, 0x87, 0x49, 0xd7, 0x00, 0x02, 0x29, 0x5f, 0xd0,
0xad, 0x07, 0x49, 0xa2, 0x3b, 0x73, 0xe7, 0x01, 0xb8, 0x1f, 0x8a, 0x2e, 0x13, 0xa5, 0xa1, 0x1b,
0xae, 0xa1, 0xb6, 0x8a, 0x18, 0x0d, 0x3b, 0x6c, 0xe1, 0x1a, 0x42, 0x99, 0x53, 0xbf, 0x12, 0xd4,
0x70, 0xf2, 0x3f, 0x23, 0x72, 0x5c, 0x17, 0x85, 0xe2, 0xd7, 0xf0, 0x7b, 0xa7, 0x15, 0x5a, 0x6a,
0x2a, 0xdf, 0x86, 0x57, 0x43, 0x1e, 0x96, 0xf4, 0x5a, 0xb5, 0x2e, 0x14, 0xbb, 0x86, 0x3f, 0x3b,
0xca, 0x71, 0xe4, 0x88, 0xc6, 0x7c, 0x98, 0x5f, 0x90, 0x34, 0x9c, 0xdc, 0x65, 0x8d, 0x27, 0xcf,
0x85, 0x32, 0x37, 0x94, 0x14, 0x5f, 0x4c, 0xff, 0x04, 0xd6, 0x70, 0x64, 0x67, 0xff, 0x76, 0x07,
0x14, 0xaf, 0x52, 0xa1, 0x10, 0x20, 0x5c, 0xcc, 0x00, 0x00, 0x8d, 0xa6, 0xe6, 0xf7, 0xfd, 0xba,
0x48, 0xa4, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_pcb_target_xpm[1] = {{ png, sizeof( png ), "add_pcb_target_xpm" }};
//EOF

20
bitmaps_png/cpp_24/add_power.cpp
View File

@ -1,20 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x00, 0x33, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0xa0, 0x0e, 0x08,
0x39, 0x1c, 0x72, 0x98, 0x34, 0x0d, 0xff, 0x43, 0xfe, 0x8f, 0x6a, 0x18, 0xd5, 0x00, 0x4a, 0x39,
0xff, 0x89, 0x80, 0x87, 0xc9, 0xd7, 0x40, 0x2f, 0x80, 0xc7, 0x61, 0x87, 0xa9, 0xa3, 0x61, 0x40,
0xfc, 0x72, 0x98, 0x36, 0x1a, 0xf0, 0x03, 0x00, 0x29, 0x14, 0x86, 0x71, 0xa7, 0xc1, 0x27, 0x7b,
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_power_xpm[1] = {{ png, sizeof( png ), "add_power_xpm" }};
//EOF

20
bitmaps_png/cpp_24/add_rectangle.cpp
View File

@ -1,20 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x04, 0x00, 0x00, 0x00, 0x4a, 0x7e, 0xf5,
0x73, 0x00, 0x00, 0x00, 0x2c, 0x49, 0x44, 0x41, 0x54, 0x38, 0xcb, 0x63, 0x60, 0x18, 0x9c, 0x20,
0xe4, 0x70, 0xc8, 0x7f, 0x22, 0xe0, 0x61, 0x84, 0x86, 0xff, 0xc4, 0x41, 0x14, 0x0d, 0x07, 0x09,
0xc0, 0x51, 0x0d, 0xa3, 0x1a, 0x06, 0x8f, 0x06, 0xd2, 0x92, 0x37, 0xa9, 0x19, 0x68, 0x70, 0x01,
0x00, 0xe9, 0x35, 0x3b, 0x47, 0xa7, 0xd2, 0x63, 0xb1, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_rectangle_xpm[1] = {{ png, sizeof( png ), "add_rectangle_xpm" }};
//EOF

53
bitmaps_png/cpp_24/add_symbol_to_schematic.cpp
View File

@ -1,53 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x02, 0x3b, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x40, 0x02, 0x21,
0x21, 0x21, 0x87, 0x81, 0xf8, 0x52, 0x50, 0x50, 0x90, 0x05, 0x03, 0x2d, 0x00, 0xd0, 0xf0, 0xff,
0x50, 0xfc, 0x07, 0x88, 0x7b, 0x42, 0x43, 0x43, 0x39, 0x69, 0x65, 0xc1, 0x6f, 0x10, 0x1d, 0x1c,
0x1c, 0x7c, 0x13, 0x68, 0x89, 0x0d, 0xd5, 0x2d, 0x08, 0x0c, 0x0c, 0xd4, 0x07, 0xd2, 0xe7, 0xa0,
0xfc, 0x7f, 0x40, 0x8b, 0x66, 0x02, 0x2d, 0xe2, 0xa1, 0x9a, 0x05, 0x20, 0x76, 0x5a, 0x5a, 0x1a,
0x2b, 0x90, 0x5d, 0x0e, 0xc4, 0x3f, 0xa1, 0xe2, 0xf7, 0x80, 0xd8, 0x99, 0x1c, 0x43, 0x0f, 0x23,
0x05, 0x0d, 0xdc, 0x02, 0x18, 0x00, 0xba, 0x5c, 0x17, 0x28, 0x76, 0x06, 0xd9, 0x37, 0x7e, 0x7e,
0x7e, 0xbc, 0x54, 0xb3, 0x00, 0x04, 0x1c, 0x1c, 0x1c, 0x58, 0xa0, 0xbe, 0xf9, 0x01, 0x55, 0xf3,
0x00, 0x68, 0xb1, 0x2b, 0x45, 0x41, 0x04, 0x34, 0xc0, 0x18, 0xe8, 0x5a, 0x17, 0x18, 0x06, 0xf1,
0x81, 0x71, 0xa3, 0x03, 0xa4, 0x4f, 0x21, 0x39, 0x66, 0x15, 0x90, 0x2f, 0x44, 0x96, 0x05, 0x40,
0x7a, 0x3f, 0x9a, 0xcf, 0xf6, 0xe3, 0xf0, 0xcd, 0x33, 0x20, 0xf6, 0xa7, 0x8a, 0x0f, 0xd0, 0xe2,
0x46, 0x05, 0x88, 0x0f, 0x22, 0xfb, 0x06, 0xe8, 0x43, 0x61, 0xa2, 0x2d, 0xc0, 0x07, 0x0e, 0x69,
0xda, 0x4a, 0xee, 0x53, 0x73, 0x6c, 0xdb, 0xaf, 0xe6, 0x74, 0x69, 0xaf, 0xba, 0xe3, 0xaf, 0x5d,
0xea, 0x8e, 0xff, 0x57, 0xe9, 0xbb, 0xfe, 0xef, 0xb5, 0xf6, 0xfc, 0x9c, 0xe7, 0x1d, 0x18, 0x4f,
0x91, 0x05, 0x40, 0x83, 0xbd, 0xf6, 0xab, 0x39, 0x7e, 0x02, 0xe2, 0xff, 0xd8, 0xf0, 0x2e, 0x4d,
0xa7, 0xff, 0xe5, 0xae, 0x7e, 0x30, 0x5f, 0x9d, 0xc4, 0x6b, 0x01, 0x90, 0xed, 0x00, 0x15, 0x73,
0x00, 0xf1, 0x0f, 0xa8, 0x3b, 0x85, 0x02, 0x0d, 0xf9, 0x8d, 0x6c, 0xe0, 0xed, 0xd6, 0x29, 0xff,
0x1f, 0xce, 0x58, 0xfa, 0x7f, 0xbf, 0xba, 0x13, 0x5c, 0x0c, 0xe8, 0x08, 0x98, 0x25, 0xb8, 0x2d,
0x00, 0x85, 0x3b, 0xb0, 0xd0, 0x2b, 0x06, 0xf1, 0x41, 0x74, 0xa1, 0xbb, 0x6f, 0x18, 0xba, 0xcb,
0x6f, 0xd6, 0xf5, 0xfd, 0x87, 0x81, 0x67, 0x2b, 0xb7, 0xa0, 0x58, 0x72, 0x40, 0xcd, 0xf1, 0xe3,
0x21, 0x15, 0x5b, 0x51, 0x7c, 0xa9, 0x08, 0x25, 0x6f, 0xf4, 0xd8, 0x78, 0xfd, 0xc7, 0x30, 0xfc,
0xdf, 0xbf, 0xff, 0xc8, 0x00, 0xdd, 0x92, 0x7d, 0xaa, 0x8e, 0x4d, 0x78, 0x53, 0x11, 0x10, 0xa7,
0xc1, 0x7c, 0xb0, 0x53, 0xc3, 0xe9, 0x3e, 0x4c, 0xe3, 0xd5, 0xc2, 0x66, 0x88, 0xe1, 0x48, 0x16,
0xfc, 0xf9, 0xf6, 0x03, 0x4c, 0x3f, 0x9a, 0xb3, 0x12, 0xc9, 0x21, 0x4e, 0xe7, 0x88, 0x8e, 0x03,
0xa0, 0x86, 0x2f, 0x30, 0x8d, 0x0f, 0xa6, 0x2f, 0x01, 0x1b, 0x7e, 0xab, 0x79, 0x12, 0xdc, 0x82,
0x0b, 0x71, 0x45, 0x40, 0x4b, 0xbe, 0xff, 0x7f, 0x77, 0xe4, 0x0c, 0xb2, 0x4f, 0x3f, 0x11, 0x5d,
0x54, 0xec, 0xd2, 0x70, 0x82, 0x5b, 0xb0, 0x5f, 0xc3, 0xe9, 0xff, 0x51, 0xab, 0x60, 0x30, 0x1b,
0x06, 0x40, 0xec, 0x23, 0xa6, 0x7e, 0xff, 0x0f, 0xea, 0xba, 0x23, 0x5b, 0xf0, 0x85, 0xa0, 0x05,
0xc0, 0xc8, 0xd6, 0x03, 0x15, 0x76, 0xa0, 0x74, 0x8e, 0x2d, 0x59, 0x22, 0x5b, 0x80, 0x05, 0x9f,
0x27, 0xba, 0xb8, 0xee, 0xb4, 0xf5, 0x7a, 0x4b, 0xba, 0x05, 0x4e, 0x15, 0x44, 0x57, 0x38, 0x0b,
0xac, 0x3c, 0x95, 0x81, 0x9a, 0x3e, 0xa0, 0x1b, 0xf2, 0xef, 0xcf, 0x1f, 0x30, 0xc6, 0x62, 0xc1,
0xfb, 0xdd, 0x4a, 0x2e, 0xfc, 0x24, 0x55, 0x99, 0xfb, 0xd4, 0x1d, 0x41, 0x79, 0xe1, 0x1f, 0x7a,
0x72, 0x05, 0x61, 0x34, 0xc3, 0x7f, 0xed, 0x57, 0x77, 0xf0, 0x20, 0xab, 0xd2, 0xdf, 0xaf, 0xe6,
0x10, 0x0e, 0xca, 0x44, 0xb8, 0x8a, 0x0a, 0x90, 0x2f, 0x81, 0xe9, 0x3f, 0x08, 0x5f, 0xe5, 0x43,
0xb0, 0xd9, 0xb2, 0x5f, 0xdb, 0x41, 0x02, 0xe8, 0x9b, 0x32, 0xa0, 0x61, 0x67, 0x80, 0xf8, 0x3b,
0x10, 0xff, 0x00, 0x45, 0x28, 0xd0, 0xd5, 0xcd, 0x7b, 0x14, 0x9d, 0xc5, 0x91, 0xd5, 0x02, 0x00,
0xec, 0x16, 0xb5, 0x03, 0x06, 0x1b, 0xcb, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44,
0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_symbol_to_schematic_xpm[1] = {{ png, sizeof( png ), "add_symbol_to_schematic_xpm" }};
//EOF

36
bitmaps_png/cpp_24/add_tracks.cpp
View File

@ -1,36 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0x29, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x18, 0x72, 0x60,
0xd5, 0x2a, 0x66, 0xa9, 0xc6, 0x23, 0xc7, 0x80, 0xf8, 0x30, 0x4d, 0xcc, 0x97, 0x6c, 0x38, 0x12,
0x04, 0x34, 0xfc, 0x3f, 0x10, 0xdf, 0xa4, 0x89, 0x05, 0x52, 0x8d, 0x87, 0x8f, 0x82, 0x2d, 0x68,
0x3a, 0x9c, 0x45, 0x75, 0xc3, 0x25, 0x9a, 0x8e, 0x9a, 0x42, 0x5d, 0xff, 0x56, 0xbc, 0x7b, 0x27,
0x37, 0xd5, 0x2d, 0x90, 0x6e, 0x3c, 0xb2, 0x06, 0x64, 0x81, 0x64, 0xc3, 0xd1, 0x66, 0xaa, 0x1b,
0x2e, 0xde, 0x7c, 0x50, 0x11, 0x68, 0xf8, 0x1f, 0x20, 0xfe, 0x21, 0xdf, 0x7a, 0x48, 0x92, 0x06,
0x61, 0x7f, 0x64, 0x12, 0x38, 0x78, 0x1a, 0x8e, 0xce, 0xa5, 0xba, 0xe1, 0x72, 0xed, 0x87, 0x05,
0x81, 0x86, 0x7f, 0x06, 0x59, 0x20, 0xd3, 0x70, 0x48, 0x8f, 0xfa, 0x49, 0xb3, 0xf1, 0x48, 0x25,
0x24, 0xe5, 0x1c, 0xd9, 0x4e, 0x75, 0xc3, 0x8d, 0x67, 0x9e, 0x61, 0x05, 0x26, 0xcd, 0xc7, 0x90,
0xe0, 0x39, 0xec, 0x42, 0x64, 0x78, 0x1e, 0xf5, 0x07, 0x6a, 0xf8, 0x09, 0x4d, 0x72, 0xc4, 0xe2,
0x8b, 0x0c, 0xff, 0xff, 0x33, 0x12, 0x36, 0x1d, 0xa8, 0x08, 0xa4, 0x98, 0x44, 0xc3, 0x7f, 0x82,
0x1c, 0x45, 0x9c, 0xeb, 0x1b, 0x8e, 0xba, 0x41, 0x35, 0x3d, 0xd5, 0x6e, 0xb8, 0xca, 0x46, 0xfd,
0xe4, 0xd6, 0x74, 0x64, 0x27, 0xc4, 0x82, 0xc3, 0xe5, 0xd4, 0xcf, 0x2c, 0x0d, 0x47, 0x75, 0x80,
0x86, 0xff, 0x03, 0xe2, 0x2f, 0xd2, 0x6d, 0x27, 0x85, 0xa9, 0xef, 0xfa, 0x86, 0x23, 0xf3, 0x41,
0xae, 0x97, 0x6e, 0x3c, 0x3a, 0x81, 0xea, 0x86, 0x8b, 0xb5, 0x9e, 0x10, 0x07, 0x1a, 0xfe, 0x1d,
0x94, 0xdd, 0x65, 0x9b, 0x8f, 0x2a, 0x53, 0xbf, 0xa0, 0x6a, 0x38, 0xd2, 0x0a, 0x09, 0xfb, 0xa3,
0xab, 0x68, 0x10, 0x34, 0x67, 0xb8, 0x80, 0x86, 0xbf, 0x01, 0x07, 0x4f, 0xc3, 0x11, 0x0b, 0x5a,
0xa4, 0x9c, 0x1c, 0x68, 0xd2, 0xa4, 0x4d, 0x35, 0x07, 0xaa, 0xde, 0x20, 0xe5, 0xf8, 0x91, 0x20,
0x5a, 0x59, 0x70, 0x18, 0x54, 0x51, 0x83, 0x2a, 0xec, 0x21, 0xd7, 0xc8, 0x00, 0x00, 0x1e, 0xe7,
0xcc, 0x6b, 0x93, 0x85, 0x38, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE add_tracks_xpm[1] = {{ png, sizeof( png ), "add_tracks_xpm" }};
//EOF

31
bitmaps_png/cpp_24/add_via.cpp
View File

@ -1,31 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0xe6, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0xed, 0x53, 0x4b, 0x0e, 0x82,
0x40, 0x0c, 0xed, 0xca, 0x13, 0x88, 0x07, 0x33, 0x7a, 0x20, 0x3f, 0x89, 0x98, 0xb8, 0x18, 0x8c,
0x89, 0x87, 0x52, 0xc1, 0x43, 0x88, 0x6e, 0x9d, 0x19, 0x5c, 0xb8, 0x19, 0x6c, 0x51, 0x93, 0x81,
0x09, 0x9f, 0x42, 0xdc, 0x18, 0x9a, 0xbc, 0xd0, 0x00, 0x7d, 0xaf, 0xd3, 0xce, 0x03, 0xe8, 0xa3,
0x0f, 0xbd, 0x87, 0x91, 0x0c, 0x60, 0x89, 0x88, 0x54, 0x00, 0x09, 0x01, 0xf3, 0x50, 0x0a, 0x58,
0xd0, 0xb7, 0x6e, 0xe4, 0x02, 0xa6, 0x48, 0xa8, 0x10, 0x69, 0x09, 0x94, 0xde, 0xc2, 0xa4, 0x0b,
0xb9, 0xa9, 0x20, 0xff, 0xc2, 0xb0, 0x45, 0xe8, 0xe8, 0x35, 0x9d, 0x17, 0x21, 0x51, 0xc4, 0x6b,
0x2c, 0x40, 0x33, 0xcf, 0x11, 0xec, 0x06, 0xe9, 0xf3, 0xb8, 0x4e, 0x4d, 0x72, 0x45, 0xc4, 0x98,
0xfb, 0xd9, 0x3b, 0xfb, 0x1f, 0xac, 0x99, 0x37, 0x16, 0xc0, 0x82, 0xb3, 0x5d, 0x4c, 0x84, 0xc5,
0xc8, 0x44, 0xf2, 0x02, 0x21, 0x47, 0x40, 0xdb, 0xc5, 0xd4, 0x79, 0x31, 0xcc, 0xe3, 0xe6, 0x2c,
0x9c, 0x23, 0xa0, 0xf2, 0x02, 0xb1, 0x2b, 0xa0, 0x2f, 0xce, 0x1e, 0x38, 0x3b, 0x88, 0x6a, 0x47,
0x74, 0x58, 0xb5, 0x1f, 0x11, 0x99, 0xc8, 0x5d, 0xb2, 0x9f, 0x9d, 0xa4, 0x74, 0xc9, 0x02, 0x66,
0xbf, 0xbc, 0xa6, 0x77, 0xb5, 0x81, 0x21, 0xcf, 0x0b, 0x68, 0x1e, 0x86, 0xd1, 0xc6, 0xed, 0xdc,
0xfc, 0x16, 0x91, 0x55, 0x9d, 0xb7, 0x26, 0xb7, 0x44, 0x3c, 0x32, 0x11, 0x3e, 0x4f, 0x9f, 0xeb,
0xab, 0x29, 0xa7, 0x99, 0xb3, 0xc7, 0xd2, 0xc7, 0x7f, 0xc6, 0x0b, 0xe9, 0xe0, 0xc5, 0x4d, 0x06,
0xe7, 0x92, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_via_xpm[1] = {{ png, sizeof( png ), "add_via_xpm" }};
//EOF

27
bitmaps_png/cpp_24/add_zone.cpp
View File

@ -1,27 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0x9b, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x18, 0xf6, 0x40,
0xaa, 0xf1, 0xc8, 0x7f, 0x72, 0xf0, 0xa8, 0x05, 0xc3, 0xc3, 0x82, 0x47, 0x92, 0x8d, 0x47, 0x83,
0x45, 0x3a, 0x8f, 0xf0, 0x8a, 0xb5, 0x9e, 0x10, 0x97, 0x6a, 0x3a, 0x1a, 0x01, 0x14, 0xbb, 0x4f,
0x2d, 0x0b, 0x1e, 0xc9, 0x34, 0x1c, 0x13, 0xa2, 0x59, 0x32, 0x95, 0x6e, 0x38, 0x1a, 0x02, 0x92,
0x0b, 0x0d, 0x0d, 0xf5, 0x0e, 0x09, 0x09, 0x79, 0x02, 0xc4, 0x8f, 0x81, 0xd8, 0x93, 0x6a, 0x16,
0x80, 0x82, 0x05, 0x24, 0x07, 0x35, 0xf8, 0x3f, 0x36, 0x4c, 0x7f, 0x0b, 0x48, 0x4a, 0x25, 0x0d,
0x87, 0x02, 0xa0, 0x16, 0x78, 0x82, 0x2c, 0x09, 0x0e, 0x0e, 0x7e, 0x04, 0x0c, 0x2e, 0x0f, 0x6a,
0x26, 0xc7, 0x1b, 0x72, 0xed, 0x87, 0x05, 0x69, 0x5d, 0xe6, 0x3c, 0x92, 0x6e, 0x3c, 0x1c, 0x2a,
0xd4, 0x70, 0x82, 0x4f, 0xb4, 0x61, 0xbf, 0x84, 0x54, 0xe3, 0xe1, 0x48, 0xbc, 0xc9, 0x94, 0xdc,
0x0c, 0x45, 0x74, 0x46, 0x1b, 0xb5, 0x60, 0xd4, 0x02, 0xda, 0x15, 0xd7, 0x83, 0x1e, 0x00, 0x00,
0xb0, 0x0e, 0xd4, 0x02, 0xaf, 0x9c, 0x70, 0x27, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44,
0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_zone_xpm[1] = {{ png, sizeof( png ), "add_zone_xpm" }};
//EOF

37
bitmaps_png/cpp_24/add_zone_cutout.cpp
View File

@ -1,37 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x01, 0x3c, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x18, 0x36, 0x40,
0xbb, 0xe1, 0x2a, 0x9b, 0x74, 0xe3, 0xd1, 0x09, 0x52, 0x8d, 0x47, 0xde, 0x02, 0xf1, 0x53, 0xa9,
0xc6, 0xa3, 0x1d, 0x20, 0x31, 0x4a, 0xd5, 0xc2, 0x01, 0x54, 0xc3, 0x7f, 0x54, 0x7c, 0xb4, 0x83,
0x52, 0xb5, 0x70, 0x00, 0x54, 0xf4, 0x0e, 0x5d, 0x93, 0x42, 0xed, 0xce, 0xff, 0x21, 0x21, 0x21,
0x18, 0x58, 0xae, 0x6e, 0xef, 0x7f, 0x4c, 0x0b, 0x8e, 0x3c, 0x25, 0xd9, 0x02, 0xf9, 0xba, 0x3d,
0xa4, 0x58, 0xf0, 0x1a, 0xaf, 0x05, 0x92, 0x8d, 0x47, 0xfa, 0xd0, 0x35, 0x25, 0xce, 0xda, 0xff,
0x7f, 0xe7, 0xce, 0x9d, 0x18, 0x38, 0x01, 0x28, 0x8e, 0xae, 0x56, 0xb2, 0xe1, 0x70, 0x2f, 0x5e,
0x0b, 0x54, 0x26, 0x6d, 0x63, 0x97, 0xad, 0xdb, 0x3b, 0x0d, 0xe4, 0x6a, 0xb9, 0xda, 0xdd, 0xff,
0x63, 0xa7, 0xed, 0xfe, 0xbf, 0x6d, 0xc7, 0x4e, 0xac, 0x16, 0x6c, 0x05, 0x8a, 0x83, 0x2c, 0x57,
0x6f, 0x03, 0x06, 0x63, 0xf3, 0xe1, 0x6f, 0x20, 0xc3, 0x8d, 0x67, 0x9e, 0x61, 0x25, 0x98, 0x92,
0x02, 0x03, 0x03, 0xc5, 0x60, 0xc1, 0xb0, 0x61, 0xc3, 0x06, 0xac, 0x86, 0xa3, 0xe3, 0x5d, 0xbb,
0x76, 0xed, 0x27, 0x3a, 0xa9, 0x92, 0x63, 0x01, 0x10, 0x7f, 0xd9, 0xbf, 0x7f, 0x3f, 0x0b, 0x2d,
0x2d, 0xf8, 0xbf, 0x7b, 0xf7, 0x6e, 0x5d, 0x9a, 0x5a, 0x00, 0x0c, 0xa6, 0x14, 0x9a, 0x5a, 0xb0,
0x63, 0xc7, 0x8e, 0xd9, 0x34, 0xb5, 0x00, 0x88, 0x2f, 0xd1, 0xda, 0x82, 0xbf, 0xdb, 0xb6, 0x6d,
0xe3, 0xa3, 0xa5, 0x05, 0xff, 0xb7, 0x6f, 0xdf, 0xee, 0x40, 0xb0, 0x34, 0x05, 0x16, 0x01, 0xb3,
0xe4, 0x80, 0x19, 0x0d, 0x54, 0x06, 0x25, 0x4c, 0x07, 0x65, 0xb4, 0x5d, 0x04, 0x0d, 0x06, 0xa9,
0x49, 0x98, 0x75, 0xe0, 0xbf, 0x7c, 0xf3, 0x91, 0xaf, 0x78, 0x4b, 0x56, 0x6c, 0x25, 0x64, 0xca,
0xec, 0xfd, 0x04, 0x2d, 0x00, 0x19, 0x4e, 0x54, 0xc9, 0x4a, 0x4a, 0x69, 0x4a, 0x56, 0xc9, 0x4a,
0x4a, 0x69, 0x4a, 0x56, 0xc9, 0x8a, 0xad, 0x34, 0x25, 0x58, 0x42, 0x92, 0xa2, 0x0f, 0x54, 0x9a,
0x02, 0xc3, 0xae, 0x07, 0x64, 0x3b, 0x10, 0xbf, 0x21, 0xb6, 0x84, 0x24, 0x57, 0xdf, 0xd0, 0x01,
0x00, 0xf6, 0x18, 0x1f, 0x64, 0x67, 0x11, 0x6c, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE add_zone_cutout_xpm[1] = {{ png, sizeof( png ), "add_zone_cutout_xpm" }};
//EOF

23
bitmaps_png/cpp_24/align_items.cpp
View File

@ -1,23 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0x59, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x90, 0x6a, 0x3c, 0x72,
0x10, 0x84, 0x19, 0x68, 0x05, 0x80, 0x86, 0xff, 0x07, 0xe1, 0xe1, 0x61, 0x41, 0x48, 0x48, 0xc8,
0x3f, 0x72, 0x30, 0x50, 0x2b, 0x23, 0xb1, 0x16, 0xfc, 0x27, 0x07, 0x37, 0x34, 0x34, 0x30, 0x8d,
0x5a, 0x30, 0x6a, 0x01, 0x9d, 0x2c, 0x00, 0x29, 0x24, 0x07, 0x0f, 0xfd, 0x9c, 0x8c, 0x37, 0x97,
0x53, 0x23, 0x0e, 0xf0, 0xe1, 0x51, 0x0b, 0x46, 0x2d, 0xa0, 0xb2, 0x05, 0xe4, 0xe6, 0x64, 0xbc,
0xb9, 0x9c, 0xe6, 0x39, 0x59, 0xb2, 0xe9, 0xc8, 0x7e, 0x10, 0xa6, 0x95, 0xf9, 0x00, 0xbb, 0x43,
0xda, 0x7d, 0x5c, 0x63, 0xe5, 0xbb, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
const BITMAP_OPAQUE align_items_xpm[1] = {{ png, sizeof( png ), "align_items_xpm" }};
//EOF

22
bitmaps_png/cpp_24/align_items_bottom.cpp
View File

@ -1,22 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0x56, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0xed, 0xcf, 0xc1, 0x0d, 0x80,
0x30, 0x0c, 0x43, 0x51, 0xa7, 0x63, 0x30, 0x0c, 0xb3, 0x99, 0x7d, 0x32, 0x04, 0x95, 0x18, 0x21,
0xeb, 0xa0, 0x70, 0xe1, 0x48, 0x0f, 0xad, 0x94, 0x13, 0xfe, 0x03, 0xf8, 0xc9, 0x86, 0x37, 0x92,
0x2d, 0x22, 0x6e, 0x8c, 0x4b, 0x77, 0x6f, 0x98, 0xcc, 0x04, 0x08, 0xf8, 0x04, 0x48, 0x0e, 0x21,
0x92, 0x09, 0x20, 0x97, 0x81, 0xd9, 0xa7, 0x02, 0x04, 0x08, 0x10, 0xf0, 0x2f, 0xa0, 0x2a, 0xdb,
0x8e, 0xab, 0x03, 0xd8, 0x2b, 0xc6, 0xd3, 0x70, 0x96, 0x03, 0x0f, 0x52, 0xdc, 0x25, 0x64, 0x4d,
0xf5, 0x53, 0xea, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE align_items_bottom_xpm[1] = {{ png, sizeof( png ), "align_items_bottom_xpm" }};
//EOF

24
bitmaps_png/cpp_24/align_items_center.cpp
View File

@ -1,24 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0x70, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x64, 0xa0, 0x31, 0x60,
0x84, 0x31, 0x1a, 0x1a, 0x1a, 0x98, 0xae, 0x5c, 0xb9, 0xf2, 0x17, 0x8f, 0xda, 0xff, 0x6b, 0xd6,
0xac, 0x61, 0x1a, 0xb5, 0x80, 0x18, 0x0b, 0x18, 0x43, 0x42, 0x42, 0xfe, 0xe1, 0x51, 0xf7, 0x6f,
0xcd, 0x9a, 0x35, 0xcc, 0x64, 0x5b, 0x40, 0xaa, 0x4f, 0x47, 0x2d, 0x18, 0x09, 0x16, 0x48, 0x35,
0x1e, 0x39, 0xc8, 0xc0, 0xc0, 0x60, 0xc7, 0xc8, 0xf0, 0x9f, 0xc1, 0xf2, 0xf2, 0x44, 0x3c, 0x09,
0x9a, 0x91, 0xe1, 0x98, 0x4e, 0x3e, 0x03, 0xb1, 0xea, 0x18, 0x18, 0x18, 0x18, 0xfe, 0x33, 0x32,
0x1c, 0xa0, 0xbd, 0x05, 0xa3, 0x91, 0x3c, 0x6a, 0x01, 0xfd, 0x2d, 0xa0, 0x79, 0x71, 0x3d, 0x82,
0xab, 0x4c, 0x5a, 0x01, 0x00, 0x1c, 0xe0, 0x22, 0x64, 0x72, 0xb1, 0xdf, 0x1b, 0x00, 0x00, 0x00,
0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE align_items_center_xpm[1] = {{ png, sizeof( png ), "align_items_center_xpm" }};
//EOF

22
bitmaps_png/cpp_24/align_items_left.cpp
View File

@ -1,22 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0x56, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x90, 0x6a, 0x3c, 0x72,
0x06, 0x84, 0x19, 0x68, 0x05, 0x80, 0x86, 0xff, 0x07, 0xe1, 0xe1, 0x61, 0x41, 0x48, 0x48, 0xc8,
0x3f, 0x72, 0x30, 0x50, 0x2b, 0x23, 0xb1, 0x16, 0xfc, 0x27, 0x07, 0x37, 0x34, 0x34, 0x30, 0x8d,
0x5a, 0x30, 0x6a, 0x01, 0x9d, 0x2c, 0x00, 0x29, 0x24, 0x07, 0x0f, 0xfd, 0x9c, 0x8c, 0x37, 0x97,
0x53, 0x23, 0x0e, 0xf0, 0xe1, 0x51, 0x0b, 0x46, 0x2d, 0xa0, 0xb2, 0x05, 0xe4, 0xe6, 0x64, 0xbc,
0xb9, 0x9c, 0x1e, 0x39, 0x79, 0x0b, 0x08, 0xd3, 0xca, 0x7c, 0x00, 0x7b, 0x0e, 0xda, 0x7d, 0x44,
0xc9, 0x53, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE align_items_left_xpm[1] = {{ png, sizeof( png ), "align_items_left_xpm" }};
//EOF

24
bitmaps_png/cpp_24/align_items_middle.cpp
View File

@ -1,24 +0,0 @@
/* Do not modify this file, it was automatically generated by the
* PNG2cpp CMake script, using a *.png file as input.
*/
#include <bitmaps_png/bitmaps_list.h>
static const unsigned char png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x06, 0x00, 0x00, 0x00, 0xe0, 0x77, 0x3d,
0xf8, 0x00, 0x00, 0x00, 0x6f, 0x49, 0x44, 0x41, 0x54, 0x48, 0xc7, 0x63, 0x60, 0x20, 0x01, 0x48,
0x35, 0x1e, 0x39, 0x08, 0xc2, 0x0c, 0xb4, 0x02, 0x40, 0xc3, 0xff, 0x83, 0xf0, 0xe0, 0xb6, 0x20,
0x24, 0x24, 0xe4, 0x1f, 0x4e, 0x1c, 0x1a, 0xfa, 0x1f, 0x8c, 0xf1, 0xa8, 0x21, 0xc6, 0x82, 0xff,
0x94, 0xe0, 0x51, 0x0b, 0x46, 0x2d, 0xa0, 0x83, 0x05, 0x0d, 0x0d, 0x0d, 0x4c, 0xb8, 0xb0, 0x74,
0xe3, 0xe1, 0xff, 0x20, 0x8c, 0x4f, 0xcd, 0xc0, 0xe4, 0x64, 0xbc, 0xb9, 0x97, 0xc4, 0x9c, 0x8c,
0x35, 0x57, 0x53, 0x1a, 0xee, 0x04, 0xe3, 0x63, 0xd4, 0x82, 0x51, 0x0b, 0x28, 0xb7, 0x00, 0x5f,
0xce, 0x24, 0x35, 0x27, 0x53, 0x94, 0xab, 0x69, 0x5e, 0xe9, 0x4b, 0x36, 0x1d, 0xd9, 0x0f, 0xc2,
0xa4, 0xe8, 0x01, 0x00, 0xb7, 0x14, 0xb2, 0x3d, 0x95, 0xc6, 0x2c, 0x3b, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
const BITMAP_OPAQUE align_items_middle_xpm[1] = {{ png, sizeof( png ), "align_items_middle_xpm" }};
//EOF

Some files were not shown because too many files have changed in this diff Show More