diff_scene.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */
 
#ifndef KICAD_DIFF_SCENE_H
#define KICAD_DIFF_SCENE_H
 
#include <kicommon.h>
 
#include <diff_merge/kicad_diff_types.h>
#include <diff_merge/diff_doc_kind.h>
 
#include <base_units.h>
#include <gal/color4d.h>
#include <lset.h>
#include <math/box2.h>
 
#include <wx/string.h>
 
#include <array>
#include <map>
#include <optional>
 
class SHAPE_POLY_SET;
 
 
namespace KICAD_DIFF
{

enum class CATEGORY
{
    ADDED,
    REMOVED,
    MODIFIED,
    CONFLICT,
};
 

inline constexpr std::array<CATEGORY, 4> PAINT_ORDER{
    CATEGORY::MODIFIED,
    CATEGORY::ADDED,
    CATEGORY::REMOVED,
    CATEGORY::CONFLICT,
};
 
 
inline constexpr std::size_t CATEGORY_COUNT = PAINT_ORDER.size();

struct KICOMMON_API SCENE_SHAPE
{
    BOX2I          bbox;
    KIGFX::COLOR4D color;
    wxString       label; // shown by interactive renderer as a hover tooltip

    KIID_PATH changeId;
 
    using PolygonList = std::vector<std::vector<std::vector<VECTOR2I>>>;
    PolygonList polygons;
};
 

struct KICOMMON_API DOCUMENT_SEGMENT
{
    VECTOR2I       start;
    VECTOR2I       end;
    int            width = 0;
    KIGFX::COLOR4D color;
    LSET           layers;
};
 

struct KICOMMON_API DOCUMENT_POLYGON
{
    std::vector<VECTOR2I> outline;
    bool                  filled = false;
    int                   lineWidth = 0;
    KIGFX::COLOR4D        color;
    LSET                  layers;
};
 

struct KICOMMON_API DOCUMENT_CIRCLE
{
    VECTOR2I       center;
    int            radius = 0;
    bool           filled = false;
    int            lineWidth = 0;
    KIGFX::COLOR4D color;
    LSET           layers;
};
 

struct KICOMMON_API DOCUMENT_GEOMETRY
{
    std::vector<DOCUMENT_SEGMENT> segments;
    std::vector<DOCUMENT_POLYGON> polygons;
    std::vector<DOCUMENT_CIRCLE>  circles;
 
    bool Empty() const { return segments.empty() && polygons.empty() && circles.empty(); }
};
 

struct GEOMETRY_SINK
{
    virtual ~GEOMETRY_SINK() = default;
 
    virtual void FillPolygon( const DOCUMENT_POLYGON& aPoly ) = 0;
    virtual void StrokePolygon( const DOCUMENT_POLYGON& aPoly ) = 0;
    virtual void DrawSegment( const DOCUMENT_SEGMENT& aSegment ) = 0;
    virtual void DrawCircle( const DOCUMENT_CIRCLE& aCircle ) = 0;
};
 

inline void IterateDocumentGeometry( const DOCUMENT_GEOMETRY& aGeometry, GEOMETRY_SINK& aSink )
{
    if( aGeometry.Empty() )
        return;
 
    for( const DOCUMENT_POLYGON& poly : aGeometry.polygons )
        aSink.FillPolygon( poly );
 
    for( const DOCUMENT_POLYGON& poly : aGeometry.polygons )
        aSink.StrokePolygon( poly );
 
    for( const DOCUMENT_SEGMENT& segment : aGeometry.segments )
        aSink.DrawSegment( segment );
 
    for( const DOCUMENT_CIRCLE& circle : aGeometry.circles )
        aSink.DrawCircle( circle );
}
 
 
struct KICOMMON_API DIFF_SCENE
{
    DOC_KIND                 docKind = DOC_KIND::PCB;
 
    BOX2I                    documentBBox; // union of all change bboxes
    std::vector<SCENE_SHAPE> addedShapes;
    std::vector<SCENE_SHAPE> removedShapes;
    std::vector<SCENE_SHAPE> modifiedShapes;
    std::vector<SCENE_SHAPE> conflictShapes;

    DOCUMENT_GEOMETRY referenceGeometry;
    DOCUMENT_GEOMETRY comparisonGeometry;
};
 

inline const EDA_IU_SCALE& IuScaleForDocKind( DOC_KIND aKind )
{
    switch( aKind )
    {
    case DOC_KIND::SCH:
    case DOC_KIND::SYM_LIB:
        return schIUScale;
 
    case DOC_KIND::PCB:
    case DOC_KIND::FP_LIB:
    case DOC_KIND::FOOTPRINT:
    case DOC_KIND::UNKNOWN:
    default:
        return pcbIUScale;
    }
}
 

struct KICOMMON_API DIFF_COLOR_THEME
{
    KIGFX::COLOR4D added = KIGFX::COLOR4D( 0.20, 0.65, 0.20, 1.0 );      // green
    KIGFX::COLOR4D removed = KIGFX::COLOR4D( 0.80, 0.20, 0.20, 1.0 );    // red
    KIGFX::COLOR4D modified = KIGFX::COLOR4D( 0.85, 0.65, 0.10, 1.0 );   // amber
    KIGFX::COLOR4D conflict = KIGFX::COLOR4D( 0.65, 0.20, 0.70, 1.0 );   // magenta
    KIGFX::COLOR4D background = KIGFX::COLOR4D( 0.97, 0.97, 0.97, 1.0 ); // near-white
    KIGFX::COLOR4D foreground = KIGFX::COLOR4D( 0.10, 0.10, 0.10, 1.0 ); // near-black

    KIGFX::COLOR4D reference = KIGFX::COLOR4D( 0.38, 0.38, 0.38, 0.55 );
    KIGFX::COLOR4D comparison = KIGFX::COLOR4D( 0.38, 0.38, 0.38, 0.55 );
};
 

KICOMMON_API DIFF_SCENE BuildScene( const DOCUMENT_DIFF& aDiff, const DIFF_COLOR_THEME& aTheme );
 

KICOMMON_API CATEGORY CategoryFor( CHANGE_KIND aKind );
 

KICOMMON_API void ExpandBBoxToGeometry( DIFF_SCENE& aScene );
 

KICOMMON_API std::optional<BOX2I> BBoxFromGeometry( const DOCUMENT_GEOMETRY& aGeometry );
 

KICOMMON_API LSET GeometryLayerSet( const DOCUMENT_GEOMETRY& aGeometry );
 

KICOMMON_API DOCUMENT_GEOMETRY FilterGeometryByVisibleLayers( const DOCUMENT_GEOMETRY& aGeometry,
                                                              const LSET&              aVisibleLayers );
 

KICOMMON_API void AppendGeometry( DOCUMENT_GEOMETRY& aDst, DOCUMENT_GEOMETRY&& aSrc );
 

KICOMMON_API bool IsRoutingNetChange( const ITEM_CHANGE& aChange );
 

KICOMMON_API wxString ChangeDisplayLabel( const ITEM_CHANGE& aChange );
 

KICOMMON_API KIGFX::COLOR4D ThemeColorFor( const DIFF_COLOR_THEME& aTheme, CATEGORY aCategory );
 

KICOMMON_API DOCUMENT_POLYGON MakeBBoxOutline( const BOX2I& aBBox, const KIGFX::COLOR4D& aColor, int aLineWidth = 0 );
 

KICOMMON_API SHAPE_POLY_SET PolySetFromPolygonList( const SCENE_SHAPE::PolygonList& aPolygons );
 

KICOMMON_API void CollectChangeBBoxes( const DOCUMENT_DIFF& aDiff, std::map<KIID_PATH, BOX2I>& aOut );
 

KICOMMON_API const std::vector<SCENE_SHAPE>& ShapesFor( const DIFF_SCENE& aScene, CATEGORY aCategory );
 

KICOMMON_API std::optional<BOX2I> HighlightedBBox( const DIFF_SCENE& aScene, const KIID_PATH& aChangeId,
                                                   const std::array<bool, CATEGORY_COUNT>& aCategoryVisible );
 
} // namespace KICAD_DIFF
 
#endif // KICAD_DIFF_SCENE_H