class_sch_screen.h 20.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2009 Jean-Pierre Charras, jaen-pierre.charras@gipsa-lab.inpg.com
 * Copyright (C) 1992-2011 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 2
 * 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/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

25 26 27 28
/**
 * @file class_sch_screen.h
 * @brief Definitions for the Eeschema program SCH_SCREEN class.
 */
29 30 31 32

#ifndef CLASS_SCREEN_H
#define CLASS_SCREEN_H

33
#include <macros.h>
34
#include <dlist.h>
35 36 37
#include <sch_item_struct.h>
#include <class_base_screen.h>
#include <class_title_block.h>
38

39
#include <../eeschema/general.h>
40

41

42 43
class LIB_PIN;
class SCH_COMPONENT;
44
class SCH_SHEET_PATH;
45
class SCH_SHEET_PIN;
46
class SCH_LINE;
47
class SCH_TEXT;
48
class PLOTTER;
49 50 51 52 53 54 55 56


enum SCH_LINE_TEST_T
{
    ENTIRE_LENGTH_T,
    END_POINTS_ONLY_T,
    EXCLUDE_END_POINTS_T
};
57

58

59 60
/// Max number of sheets in a hierarchy project
#define NB_MAX_SHEET    500
61 62


63
class SCH_SCREEN : public BASE_SCREEN
64
{
65 66 67
private:
    wxString    m_fileName;     ///< File used to load the screen.

68 69 70
    int         m_refCount;     ///< Number of sheets referencing this screen.
                                ///< Delete when it goes to zero.

71
    /// The size of the paper to print or plot on
72 73
    PAGE_INFO   m_paper;        // keep with the MVC 'model' if this class gets split

74 75
    TITLE_BLOCK m_titles;

76 77
    /// Origin of the auxilliary axis, which is used in exports mostly, but not yet in EESCHEMA
    wxPoint     m_aux_origin;
78

79 80
    DLIST< SCH_ITEM > m_drawList;     ///< Object list for the screen.
                                      /// @todo use DLIST<SCH_ITEM> or superior container
81

82 83 84 85
    /**
     * Function addConnectedItemsToBlock
     * add items connected at \a aPosition to the block pick list.
     * <p>
86
     * This method tests all connectible unselected items in the screen that are connected to
87 88 89 90 91 92 93
     * \a aPosition and adds them to the block selection pick list.  This is used when a block
     * drag is being performed to ensure connections to items in the block are not lost.
     *</p>
     * @param aPosition = The connection point to test.
     */
    void addConnectedItemsToBlock( const wxPoint& aPosition );

94
public:
95 96 97 98

    /**
     * Constructor
     */
99
    SCH_SCREEN();
100

101
    ~SCH_SCREEN();
CHARRAS's avatar
CHARRAS committed
102

103 104 105 106 107
    virtual wxString GetClass() const
    {
        return wxT( "SCH_SCREEN" );
    }

108 109 110
    const PAGE_INFO& GetPageSettings() const                { return m_paper; }
    void SetPageSettings( const PAGE_INFO& aPageSettings )  { m_paper = aPageSettings; }

111
    void SetFileName( const wxString& aFileName )           { m_fileName = aFileName; }
112

113
    const wxString& GetFileName() const                     { return m_fileName; }
114

115 116
    const wxPoint& GetAuxOrigin() const                     { return m_aux_origin; }
    void SetAuxOrigin( const wxPoint& aPosition )           { m_aux_origin = aPosition; }
117

118 119 120 121
    const TITLE_BLOCK& GetTitleBlock() const                { return m_titles; }
    //TITLE_BLOCK& GetTitleBlock() const                      { return (TITLE_BLOCK&) m_titles; }
    void SetTitleBlock( const TITLE_BLOCK& aTitleBlock )    { m_titles = aTitleBlock; }

122 123
    void DecRefCount();

124
    void IncRefCount();
125 126 127

    int GetRefCount() const { return m_refCount; }

128 129 130 131
    /**
     * Function GetDrawItems().
     * @return - A pointer to the first item in the linked list of draw items.
     */
132 133 134 135 136 137 138 139 140 141 142
    SCH_ITEM* GetDrawItems() const          { return m_drawList.begin(); }

    void Append( SCH_ITEM* aItem )          { m_drawList.Append( aItem ); }

    /**
     * Function Append
     * adds \a aList of SCH_ITEM objects to the list for draw items for the sheet.
     *
     * @param aList A reference to a #DLIST containing the #SCH_ITEM to add to the sheet.
     */
    void Append( DLIST< SCH_ITEM >& aList ) { m_drawList.Append( aList ); }
143

144 145 146 147 148
    /**
     * Function GetCurItem
     * returns the currently selected SCH_ITEM, overriding BASE_SCREEN::GetCurItem().
     * @return SCH_ITEM* - the one selected, or NULL.
     */
149
    SCH_ITEM* GetCurItem() const { return (SCH_ITEM*) BASE_SCREEN::GetCurItem(); }
150 151 152 153

    /**
     * Function SetCurItem
     * sets the currently selected object, m_CurrentItem.
154
     * @param aItem Any object derived from SCH_ITEM
155
     */
156
    void SetCurItem( SCH_ITEM* aItem ) { BASE_SCREEN::SetCurItem( (EDA_ITEM*) aItem ); }
157

158 159 160 161 162 163
    /**
     * Function Clear
     * deletes all draw items and clears the project settings.
     */
    void Clear();

164 165 166 167 168
    /**
     * Free all the items from the schematic associated with the screen.
     *
     * This does not delete any sub hierarchies.
     */
169 170 171
    void FreeDrawList();

    /**
172
     * Function GetItem
173 174 175
     * checks \a aPosition within a distance of \a aAccuracy for items of type \a aFilter.
     * @param aPosition Position in drawing units.
     * @param aAccuracy The maximum distance within \a Position to check for an item.
176
     * @param aType The type of item to find or #NOT_USED to find any item type.
177 178 179
     * @return The item found that meets the search criteria or NULL if none found.
     */
    SCH_ITEM* GetItem( const wxPoint& aPosition, int aAccuracy = 0,
180
                       KICAD_T aType = NOT_USED ) const;
181

182
    void Place( SCH_EDIT_FRAME* frame, wxDC* DC ) { };
183

184 185 186
    /**
     * Function Draw
     * draws all the items in the screen to \a aCanvas.
187 188 189
     * note: this function is useful only for schematic.
     * library editor and library viewer do not use a draw list, and therefore
     * draws nothing
190 191 192 193 194
     * @param aCanvas The canvas item to draw on.
     * @param aDC The device context to draw on.
     * @param aDrawMode The drawing mode.
     * @param aColor The drawing color.
     */
195
    void Draw( EDA_DRAW_PANEL* aCanvas, wxDC* aDC, GR_DRAWMODE aDrawMode,
196
               EDA_COLOR_T aColor = UNSPECIFIED_COLOR );
197

198 199 200
    /**
     * Function Plot
     * plots all the schematic objects to \a aPlotter.
201 202 203
     * note: this function is useful only for schematic.
     * library editor and library viewer do not use a draw list, and therefore
     * plots nothing
204 205 206 207 208
     *
     * @param aPlotter The plotter object to plot to.
     */
    void Plot( PLOTTER* aPlotter );

209
    /**
210 211
     * Function Remove
     * removes \a aItem from the schematic associated with this screen.
212
     *
213 214
     * @note The removed item is not deleted.  It is only unlinked from the item list.
     * @param aItem Item to be removed from schematic.
215
     */
216
    void Remove( SCH_ITEM* aItem );
217

218 219 220 221 222 223 224 225 226
    /**
     * Function DeleteItem
     * removes \a aItem from the linked list and deletes the object.  If \a aItem is
     * is a schematic sheet label, it is removed from the screen associated with the
     * sheet that contains the label to be deleted.
     * @param aItem The schematic object to be deleted from the screen.
     */
    void DeleteItem( SCH_ITEM* aItem );

227
    bool CheckIfOnDrawList( SCH_ITEM* st );
228

229 230 231 232 233 234 235 236 237
    /**
     * Function SchematicCleanUp
     * performs routine schematic cleaning including breaking wire and buses and
     * deleting identical objects superimposed on top of each other.
     *
     * @param aCanvas The window to draw on.
     * @param aDC The device context used for drawing to \a aCanvas.
     * @return True if any schematic clean up was performed.
     */
238 239 240 241 242 243 244 245 246 247
    bool SchematicCleanUp( EDA_DRAW_PANEL* aCanvas = NULL, wxDC* aDC = NULL );

    /**
     * Function TestDanglingEnds
     * tests all of the connectible objects in the schematic for unused connection points.
     * @param aDC - The device context to draw the dangling status indicators.
     * @param aCanvas - The window to draw on.
     * @return True if any dangling ends were found.
     */
    bool TestDanglingEnds( EDA_DRAW_PANEL* aCanvas = NULL, wxDC* aDC = NULL );
248

249 250 251
    /**
     * Function ExtractWires
     * extracts the old wires, junctions and buses.  If \a aCreateCopy is true, replace
252 253 254 255 256
     * extracted items with a copy of the original.  Old items are to be put in undo list,
     * and the new ones can be modified by clean up safely.  If an abort draw segmat command
     * is made, the old wires must be put back into #m_drawList, and the copies must be
     * deleted.  This is because previously stored undo commands can handle pointers on wires
     * or buses, and we do not delete wires or buses, we must put them in undo list.
257
     *
258 259
     * Because cleanup deletes and/or modify bus and wires, it is easier is to put
     * all the existing  wires in undo list and use a new copy of wires for cleanup.
260
     */
261
    void ExtractWires( DLIST< SCH_ITEM >& aList, bool aCreateCopy );
262

263 264
    /**
     * Function ReplaceWires
265 266 267
     * replaces all of the wires, buses, and junctions in the screen with \a aWireList.
     *
     * @param aWireList List of wires to replace the existing wires with.
268
     */
269
    void ReplaceWires( DLIST< SCH_ITEM >& aWireList );
270

271
    /**
272
     * Function MarkConnections
273 274 275 276 277 278
     * add all wires and junctions connected to \a aSegment which are not connected any
     * component pin to \a aItemList.
     * @param aSegment The segment to test for connections.
     */
    void MarkConnections( SCH_LINE* aSegment );

279 280 281 282 283 284 285
    /**
     * Functions GetConnection
     * adds all of the wires and junctions to \a aList that make up a connection to the
     * object at \a aPosition.
     * @param aPosition The position of the first connection object in drawing units.
     * @param aList The pick list to add the connect item to.
     * @param aFullConnection If true all the objects that make up this connection are
286
     *                        add to \a aList.  Otherwise, only the objects up to the first
287 288 289 290 291
     *                        node are added.
     * @return The number of items added to \a aList.
     */
    int GetConnection( const wxPoint& aPosition, PICKED_ITEMS_LIST& aList, bool aFullConnection );

292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
    /**
     * Function BreakSegment
     * checks every wire and bus for a intersection at \a aPoint and break into two segments
     * at \a aPoint if an intersection is found.
     * @param aPoint Test this point for an intersection.
     * @return True if any wires or buses were broken.
     */
    bool BreakSegment( const wxPoint& aPoint );

    /**
     * Function BreakSegmentsOnJunctions
     * tests all junctions and bus entries in the schematic for intersections with wires and
     * buses and breaks any intersections into multiple segments.
     * @return True if any wires or buses were broken.
     */
    bool BreakSegmentsOnJunctions();

309
    /* full undo redo management : */
310 311
    // use BASE_SCREEN::PushCommandToUndoList( PICKED_ITEMS_LIST* aItem )
    // use BASE_SCREEN::PushCommandToRedoList( PICKED_ITEMS_LIST* aItem )
charras's avatar
charras committed
312

313 314
    /**
     * Function ClearUndoORRedoList
charras's avatar
charras committed
315 316
     * free the undo or redo list from List element
     *  Wrappers are deleted.
317
     *  data pointed by wrappers are deleted if not in use in schematic
318
     *  i.e. when they are copy of a schematic item or they are no more in use (DELETED)
charras's avatar
charras committed
319 320 321 322 323
     * @param aList = the UNDO_REDO_CONTAINER to clear
     * @param aItemCount = the count of items to remove. < 0 for all items
     * items are removed from the beginning of the list.
     * So this function can be called to remove old commands
     */
324
    virtual void ClearUndoORRedoList( UNDO_REDO_CONTAINER& aList, int aItemCount = -1 );
325

charras's avatar
charras committed
326 327
    /**
     * Function Save
328 329
     * writes the data structures for this object out to \a aFile in "*.sch" format.
     *
charras's avatar
charras committed
330 331 332
     * @param aFile The FILE to write to.
     * @return bool - true if success writing else false.
     */
333
    bool Save( FILE* aFile ) const;
334 335 336 337 338 339

    /**
     * Clear the state flags of all the items in the screen.
     */
    void ClearDrawingState();

340 341
    int CountConnectedItems( const wxPoint& aPos, bool aTestJunctions ) const;

342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
    /**
     * Function IsJunctionNeeded
     * tests if a junction is required for the items at \a aPosition on the screen.
     * <p>
     * A junction is required at \a aPosition if the following criteria are satisfied:
     * <ul>
     * <li>one wire midpoint, one or more wire endpoints and no junction.</li>
     * <li>three or more wire endpoints and no junction.</li>
     * <li>two wire midpoints and no junction</li>
     * <li>one wire midpoint, a component pin, and no junction.</li>
     * <li>three wire endpoints, a component pin, and no junction.</li>
     * </ul>
     * </p>
     * @param aPosition The position to test.
     * @return True if a junction is required at \a aPosition.
     */
358 359 360 361 362 363 364 365 366 367 368 369
    bool IsJunctionNeeded( const wxPoint& aPosition );

    /**
     * Function IsTerminalPoint
     * tests if \a aPosition is a connection point on \a aLayer.
     *
     * @param aPosition Position to test.
     * @param aLayer The layer type to test against.  Valid layer types are #LAYER_NOTES,
     *               #LAYER_BUS, and #LAYER_WIRE.
     * @return True if \a Position is a connection point on \a aLayer.
     */
    bool IsTerminalPoint( const wxPoint& aPosition, int aLayer );
370

371 372 373 374 375 376 377 378 379 380
    /**
     * Function GetPin
     * test the screen for a component pin item at \a aPosition.
     * @param aPosition Position to test.
     * @param aComponent The component if a pin was found, otherwise NULL.
     * @param aEndPointOnly Set to true to test if \a aPosition is the connection
     *                      point of the pin.
     * @return The pin item if found, otherwise NULL.
     */
    LIB_PIN* GetPin( const wxPoint& aPosition, SCH_COMPONENT** aComponent = NULL,
381
                     bool aEndPointOnly = false ) const;
382

383 384 385 386 387 388 389 390 391 392
    /**
     * Function GetSheet
     * returns a sheet object pointer that is named \a aName.
     *
     * @note The screen hierarchy is not descened.
     * @param aName is the case insensitive name of the sheet.
     * @return A pointer to the SCH_SHEET object found or NULL.
     */
    SCH_SHEET* GetSheet( const wxString& aName );

393 394 395 396 397 398 399 400
    /**
     * Function GetSheetLabel
     * test the screen if \a aPosition is a sheet label object.
     * @param aPosition The position to test.
     * @return The sheet label object if found otherwise NULL.
     */
    SCH_SHEET_PIN* GetSheetLabel( const wxPoint& aPosition );

401 402 403 404
    /**
     * Function ClearAnnotation
     * clears the annotation for the components in \a aSheetPath on the screen.
     * @param aSheetPath The sheet path of the component annotation to clear.  If NULL then
405
     *                   the entire hierarchy is cleared.
406 407 408 409 410
     */
    void ClearAnnotation( SCH_SHEET_PATH* aSheetPath );

    /**
     * Function GetHierarchicalItems
411
     * adds all schematic sheet and component object in the screen to \a aItems.
412
     * @param aItems Hierarchical item list to fill.
413
     */
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
    void GetHierarchicalItems( EDA_ITEMS& aItems );

    /**
     * Function GetNode
     * returns all the items at \a aPosition that form a node.
     *
     * @param aPosition The wxPoint to test for node items.
     * @param aList A #EDA_ITEMS container to place the items found.
     * @return The number of node items found at \a aPosition.
     */
    int GetNode( const wxPoint& aPosition, EDA_ITEMS& aList );

    /**
     * Function GetWireOrBus
     * returns a wire or bus item located at \a aPosition.
     *
     * @param aPosition The wxPoint to test for node items.
     * @return The SCH_LINE* of the wire or bus item found at \a aPosition or NULL if item not
     *         found.
     */
    SCH_LINE* GetWireOrBus( const wxPoint& aPosition );

    /**
     * Function GetLine
     * returns a line item located at \a aPosition.
     *
     * @param aPosition The wxPoint to test for a line item.
     * @param aAccuracy Amount to inflate the item hit test bounding box.
     * @param aLayer The layer the line is drawn upon.
     * @param aSearchType Additional line test criteria.
     * @return The SCH_LINE* of the wire item found at \a aPosition or NULL if item not
     *         found.
     */
    SCH_LINE* GetLine( const wxPoint& aPosition, int aAccuracy = 0, int aLayer = LAYER_NOTES,
                       SCH_LINE_TEST_T aSearchType = ENTIRE_LENGTH_T );

    SCH_LINE* GetWire( const wxPoint& aPosition, int aAccuracy = 0,
                       SCH_LINE_TEST_T aSearchType = ENTIRE_LENGTH_T )
    {
        return GetLine( aPosition, aAccuracy, LAYER_WIRE, aSearchType );
    }

    SCH_LINE* GetBus( const wxPoint& aPosition, int aAccuracy = 0,
                      SCH_LINE_TEST_T aSearchType = ENTIRE_LENGTH_T )
    {
        return GetLine( aPosition, aAccuracy, LAYER_BUS, aSearchType );
    }

    /**
     * Function GetLabel
     * returns a label item located at \a aPosition.
     *
     * @param aPosition The wxPoint to test for label items.
     * @param aAccuracy Amount to inflate the item hit test bounding box.
     * @return The SCH_TEXT* of the label item found at \a aPosition or NULL if item not
     *         found.
     */
    SCH_TEXT* GetLabel( const wxPoint& aPosition, int aAccuracy = 0 );
472

473 474 475 476 477 478 479
    /**
     * Function SetFootprintField
     * searches screen for a component with \a aReference and set the footprint field to
     * \a aFootPrint if found.
     *
     * @param aSheetPath The sheet path used to look up the reference designator.
     * @param aReference The reference designator of the component.
480
     * @param aFootPrint The value to set the footprint field.
481
     * @param aSetVisible The value to set the field visibility flag.
482
     * @return True if \a aReference was found otherwise false.
483 484 485 486
     */
    bool SetComponentFootprint( SCH_SHEET_PATH* aSheetPath, const wxString& aReference,
                                const wxString& aFootPrint, bool aSetVisible );

487 488 489
    /**
     * Function SelectBlockItems
     * creates a list of items found when a block command is initiated.  The items selected
490
     * depend on the block command.  If the drag block command is issued, than any items
491 492 493 494
     * connected to items in the block are also selected.
     */
    void SelectBlockItems();

495 496 497 498 499 500 501
    /**
     * Function UpdatePickList
     * adds all the items in the screen within the block selection rectangle to the pick list.
     * @return The number of items in the pick list.
     */
    int UpdatePickList();

502 503 504
#if defined(DEBUG)
    void Show( int nestLevel, std::ostream& os ) const;     // overload
#endif
505 506 507
};


508 509 510 511
/**
 * Class SCH_SCREENS
 * is a class to handle the list of *screens* in a hierarchy.
 */
CHARRAS's avatar
CHARRAS committed
512 513

// screens are unique, and correspond to .sch files.
514
class SCH_SCREENS
515 516
{
private:
517 518
    std::vector< SCH_SCREEN* > m_screens;
    unsigned int               m_index;
519 520

public:
521 522 523
    SCH_SCREENS();
    ~SCH_SCREENS();
    int GetCount() const { return m_screens.size(); }
524 525
    SCH_SCREEN* GetFirst();
    SCH_SCREEN* GetNext();
526
    SCH_SCREEN* GetScreen( unsigned int aIndex ) const;
527

528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
    /**
     * Function ClearAnnotation
     * clears the annotation for all components in the hierarchy.
     */
    void ClearAnnotation();

    /**
     * Function SchematicCleanUp
     * merges and breaks wire segments in the entire schematic hierarchy.
     */
    void SchematicCleanUp();

    /**
     * Function ReplaceDuplicateTimeStamps
     * test all sheet and component objects in the schematic for duplicate time stamps
543 544
     * an replaces them as necessary.  Time stamps must be unique in order for complex
     * hierarchies know which components go to which sheets.
545 546 547 548
     * @return The number of duplicate time stamps replaced.
     */
    int ReplaceDuplicateTimeStamps();

549 550 551 552
    /**
     * Function DeleteAllMarkers
     * deletes all electronic rules check markers of \a aMarkerType from all the screens in
     * the list.
553
     * @param aMarkerType Type of markers to be deleted.
554 555 556
     */
    void DeleteAllMarkers( int aMarkerType );

557 558 559 560 561 562 563 564 565 566
    /**
     * Function GetMarkerCount
     * returns the number of ERC markers of \a aMarkerType from all of the screens in the list.
     *
     * @param aMarkerType Indicates the type of marker to count.  A value less then zero
     *                    indicates all markers are counted.
     * @return int count of the markers found.
     */
    int GetMarkerCount( int aMarkerType = -1 );

567
private:
568 569
    void AddScreenToList( SCH_SCREEN* aScreen );
    void BuildScreenList( EDA_ITEM* aItem );
570 571 572
};

#endif /* CLASS_SCREEN_H */