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.

3d-viewer/3d_cache/dialogs/panel_prev_3d.cpp

@@ -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_bpvTop->SetBitmap( KiBitmap( BITMAPS::axis3d_top ) );
-    m_bpvFront->SetBitmap( KiBitmap( axis3d_front_xpm ) );
+    m_bpvFront->SetBitmap( KiBitmap( BITMAPS::axis3d_front ) );
-    m_bpvBack->SetBitmap( KiBitmap( axis3d_back_xpm ) );
+    m_bpvBack->SetBitmap( KiBitmap( BITMAPS::axis3d_back ) );
-    m_bpvLeft->SetBitmap( KiBitmap( axis3d_left_xpm ) );
+    m_bpvLeft->SetBitmap( KiBitmap( BITMAPS::axis3d_left ) );
-    m_bpvRight->SetBitmap( KiBitmap( axis3d_right_xpm ) );
+    m_bpvRight->SetBitmap( KiBitmap( BITMAPS::axis3d_right ) );
-    m_bpvBottom->SetBitmap( KiBitmap( axis3d_bottom_xpm ) );
+    m_bpvBottom->SetBitmap( KiBitmap( BITMAPS::axis3d_bottom ) );
-    m_bpvISO->SetBitmap( KiBitmap( ortho_xpm ) );
+    m_bpvISO->SetBitmap( KiBitmap( BITMAPS::ortho ) );
-    m_bpUpdate->SetBitmap( KiBitmap( reload_xpm ) );
+    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

3d-viewer/3d_viewer/3d_menubar.cpp

@@ -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 -------------------------------------------------------------

3d-viewer/3d_viewer/3d_toolbar.cpp

@@ -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 );

3d-viewer/3d_viewer/eda_3d_viewer.cpp

@@ -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

3d-viewer/3d_viewer/tools/3d_actions.cpp

@@ -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 );
 

CMakeModules/BuildSteps/CreateBitmapInfo.cmake

@@ -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}" )

bitmap2component/bitmap2cmp_gui.cpp

@@ -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 ) );
     }
 }
 

bitmaps_png/CMakeLists.txt

@@ -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" )
-    set( pngDir "${CMAKE_CURRENT_SOURCE_DIR}/png_${pngHeight}" )
 
-    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} )
+        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" )
 
-        #svg2png( inputFile outFile pngWidth pngHeight )
+            set( svgFile "${CMAKE_CURRENT_SOURCE_DIR}/sources/${theme}/${bmn}.svg" )
-        svg2png( ${svgFile} ${tmpFile} ${pngWidth} ${pngHeight} )
+            set( pngFile "${bmn}${themeTag}_${pngHeight}.png" )
+            set( pngPath "${pngDir}/${pngFile}" )
+            set( tmpFile "${TMP_DIR}/${pngFile}" )
 
-        #png2png( inputFile outFile )
+            if( NOT EXISTS ${svgFile} )
-        png2png( ${tmpFile} ${pngFile} )
+                continue()
+            endif()
 
-        #png2cpp( inputFile outFile )
+            #svg2png( inputFile outFile pngWidth pngHeight )
-        png2cpp( ${pngFile} ${cppFile} )
+            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
-)

bitmaps_png/cpp_16/icon_bitmap2component_16.cpp

@@ -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

bitmaps_png/cpp_16/icon_eeschema_16.cpp

@@ -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

bitmaps_png/cpp_16/icon_gerbview_16.cpp

@@ -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

bitmaps_png/cpp_16/icon_kicad_16.cpp

@@ -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

bitmaps_png/cpp_16/icon_libedit_16.cpp

@@ -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

bitmaps_png/cpp_16/icon_modedit_16.cpp

@@ -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

bitmaps_png/cpp_16/icon_pagelayout_editor_16.cpp

@@ -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

bitmaps_png/cpp_16/icon_pcbcalculator_16.cpp

@@ -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

bitmaps_png/cpp_16/icon_pcbnew_16.cpp

@@ -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

bitmaps_png/cpp_16/list_nets_16.cpp

@@ -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

bitmaps_png/cpp_16/options_generic_16.cpp

@@ -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

bitmaps_png/cpp_16/pinorient_down.cpp

@@ -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

bitmaps_png/cpp_16/pinorient_left.cpp

@@ -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

bitmaps_png/cpp_16/pinorient_right.cpp

@@ -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

bitmaps_png/cpp_16/pinorient_up.cpp

@@ -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

bitmaps_png/cpp_16/pinshape_active_low_input.cpp

@@ -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

bitmaps_png/cpp_16/pinshape_active_low_output.cpp

@@ -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

bitmaps_png/cpp_16/pinshape_clock_active_low.cpp

@@ -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

bitmaps_png/cpp_16/pinshape_clock_fall.cpp

@@ -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

bitmaps_png/cpp_16/pinshape_clock_invert.cpp

@@ -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

bitmaps_png/cpp_16/pinshape_clock_normal.cpp

@@ -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

bitmaps_png/cpp_16/pinshape_invert.cpp

@@ -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

bitmaps_png/cpp_16/pinshape_nonlogic.cpp

@@ -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

bitmaps_png/cpp_16/pinshape_normal.cpp

@@ -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

bitmaps_png/cpp_16/pintype_3states.cpp

@@ -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

bitmaps_png/cpp_16/pintype_bidi.cpp

@@ -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

bitmaps_png/cpp_16/pintype_input.cpp

@@ -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

bitmaps_png/cpp_16/pintype_nic.cpp

@@ -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

bitmaps_png/cpp_16/pintype_noconnect.cpp

@@ -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

bitmaps_png/cpp_16/pintype_notspecif.cpp

@@ -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

bitmaps_png/cpp_16/pintype_opencoll.cpp

@@ -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

bitmaps_png/cpp_16/pintype_openemit.cpp

@@ -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

bitmaps_png/cpp_16/pintype_output.cpp

@@ -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

bitmaps_png/cpp_16/pintype_passive.cpp

@@ -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

bitmaps_png/cpp_16/pintype_powerinput.cpp

@@ -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

bitmaps_png/cpp_16/pintype_poweroutput.cpp

@@ -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

bitmaps_png/cpp_16/small_down.cpp

@@ -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

bitmaps_png/cpp_16/small_edit.cpp

@@ -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

bitmaps_png/cpp_16/small_folder.cpp

@@ -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

bitmaps_png/cpp_16/small_library.cpp

@@ -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

bitmaps_png/cpp_16/small_plus.cpp

@@ -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

bitmaps_png/cpp_16/small_refresh.cpp

@@ -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

bitmaps_png/cpp_16/small_trash.cpp

@@ -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

bitmaps_png/cpp_16/small_up.cpp

@@ -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

bitmaps_png/cpp_16/small_warning.cpp

@@ -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

bitmaps_png/cpp_16/tree_nosel.cpp

@@ -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

bitmaps_png/cpp_16/tree_sel.cpp

@@ -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

bitmaps_png/cpp_16/triangle_down.cpp

@@ -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

bitmaps_png/cpp_16/triangle_right.cpp

@@ -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

bitmaps_png/cpp_16/visibility.cpp

@@ -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

bitmaps_png/cpp_16/visibility_off.cpp

@@ -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

bitmaps_png/cpp_16/www.cpp

@@ -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

bitmaps_png/cpp_24/about.cpp

@@ -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

bitmaps_png/cpp_24/add_aligned_dimension.cpp

@@ -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

bitmaps_png/cpp_24/add_arc.cpp

@@ -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

bitmaps_png/cpp_24/add_board.cpp

@@ -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

bitmaps_png/cpp_24/add_bus.cpp

@@ -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

bitmaps_png/cpp_24/add_bus2bus.cpp

@@ -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

bitmaps_png/cpp_24/add_center_dimension.cpp

@@ -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

bitmaps_png/cpp_24/add_circle.cpp

@@ -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

bitmaps_png/cpp_24/add_component.cpp

@@ -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

bitmaps_png/cpp_24/add_corner.cpp

@@ -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

bitmaps_png/cpp_24/add_dashed_line.cpp

@@ -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

bitmaps_png/cpp_24/add_document.cpp

@@ -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

bitmaps_png/cpp_24/add_glabel.cpp

@@ -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

bitmaps_png/cpp_24/add_graphical_polygon.cpp

@@ -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

bitmaps_png/cpp_24/add_graphical_segments.cpp

@@ -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

bitmaps_png/cpp_24/add_hierar_pin.cpp

@@ -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

bitmaps_png/cpp_24/add_hierarchical_label.cpp

@@ -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

bitmaps_png/cpp_24/add_hierarchical_subsheet.cpp

@@ -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

bitmaps_png/cpp_24/add_junction.cpp

@@ -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

bitmaps_png/cpp_24/add_keepout_area.cpp

@@ -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

bitmaps_png/cpp_24/add_label.cpp

@@ -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

bitmaps_png/cpp_24/add_leader.cpp

@@ -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

bitmaps_png/cpp_24/add_library.cpp

@@ -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

bitmaps_png/cpp_24/add_line.cpp

@@ -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

bitmaps_png/cpp_24/add_line2bus.cpp

@@ -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

bitmaps_png/cpp_24/add_line_label.cpp

@@ -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

bitmaps_png/cpp_24/add_orthogonal_dimension.cpp

@@ -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

bitmaps_png/cpp_24/add_pcb_target.cpp

@@ -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

bitmaps_png/cpp_24/add_power.cpp

@@ -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

bitmaps_png/cpp_24/add_rectangle.cpp

@@ -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

bitmaps_png/cpp_24/add_symbol_to_schematic.cpp

@@ -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

bitmaps_png/cpp_24/add_tracks.cpp

@@ -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

bitmaps_png/cpp_24/add_via.cpp

@@ -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

bitmaps_png/cpp_24/add_zone.cpp

@@ -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

bitmaps_png/cpp_24/add_zone_cutout.cpp

@@ -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

bitmaps_png/cpp_24/align_items.cpp

@@ -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

bitmaps_png/cpp_24/align_items_bottom.cpp

@@ -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

bitmaps_png/cpp_24/align_items_center.cpp

@@ -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

bitmaps_png/cpp_24/align_items_left.cpp

@@ -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

bitmaps_png/cpp_24/align_items_middle.cpp

@@ -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