class_base_screen.h 16.8 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) 2011 Wayne Stambaugh <stambaughw@verizon.net>
 * 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_base_screen.h
 * @brief BASE_SCREEN class implementation.
29 30
 */

31 32
#ifndef  CLASS_BASE_SCREEN_H_
#define  CLASS_BASE_SCREEN_H_
33

34 35 36 37
#include <base_struct.h>
#include <class_undoredo_container.h>
#include <block_commande.h>
#include <common.h>
38 39


40 41 42 43
/**
 * Class GRID_TYPE
 * is for grid arrays.
 */
44 45 46
class GRID_TYPE
{
public:
47
    int         m_Id;
48
    wxRealPoint m_Size;
49 50 51 52 53

    GRID_TYPE& operator=( const GRID_TYPE& item )
    {
        if( this != &item )
        {
54
            m_Id   = item.m_Id;
55 56 57 58 59 60 61 62
            m_Size = item.m_Size;
        }

        return *this;
    }

    const bool operator==( const GRID_TYPE& item ) const
    {
63
        return m_Size == item.m_Size && m_Id == item.m_Id;
64
    }
65 66 67
};


68
typedef std::vector<GRID_TYPE> GRIDS;
69 70


71 72
/**
 * Class BASE_SCREEN
73
 * handles how to draw a screen (a board, a schematic ...)
74
 */
75
class BASE_SCREEN : public EDA_ITEM
76
{
77
private:
78 79 80 81 82 83 84
    GRIDS       m_grids;            ///< List of valid grid sizes.
    bool        m_FlagModified;     ///< Indicates current drawing has been modified.
    bool        m_FlagSave;         ///< Indicates automatic file save.
    EDA_ITEM*   m_CurrentItem;      ///< Currently selected object
    GRID_TYPE   m_Grid;             ///< Current grid selection.
    wxPoint     m_scrollCenter;     ///< Current scroll center point in logical units.
    wxPoint     m_MousePosition;    ///< Mouse cursor coordinate in logical units.
85 86 87 88 89 90

    /**
     * The cross hair position in logical (drawing) units.  The cross hair is not the cursor
     * position.  It is an addition indicator typically drawn on grid to indicate to the
     * user where the current action will be performed.
     */
91 92 93 94 95 96 97 98 99 100 101 102 103 104
    wxPoint     m_crossHairPosition;

    double      m_Zoom;             ///< Current zoom coefficient.

    //----< Old public API now is private, and migratory>------------------------
    // called only from EDA_DRAW_FRAME
    friend class EDA_DRAW_FRAME;

    /**
     * Function getCrossHairPosition
     * return the current cross hair position in logical (drawing) coordinates.
     * @param aInvertY Inverts the Y axis position.
     * @return The cross hair position in drawing coordinates.
     */
105
    wxPoint getCrossHairPosition( bool aInvertY ) const
106 107 108
    {
        if( aInvertY )
            return wxPoint( m_crossHairPosition.x, -m_crossHairPosition.y );
109

110 111 112 113 114 115 116 117 118 119 120 121
        return wxPoint( m_crossHairPosition.x, m_crossHairPosition.y );
    }

    /**
     * Function setCrossHairPosition
     * sets the screen cross hair position to \a aPosition in logical (drawing) units.
     * @param aPosition The new cross hair position.
     * @param aGridOrigin Origin point of the snap grid.
     * @param aSnapToGrid Sets the cross hair position to the nearest grid position to
     *                    \a aPosition.
     *
     */
122
    void setCrossHairPosition( const wxPoint& aPosition, const wxPoint& aGridOrigin, bool aSnapToGrid );
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140

    /**
     * Function getCursorScreenPosition
     * returns the cross hair position in device (display) units.b
     * @return The current cross hair position.
     */
    wxPoint getCrossHairScreenPosition() const;

    /**
     * Function getNearestGridPosition
     * returns the nearest \a aGridSize location to \a aPosition.
     * @param aPosition The position to check.
     * @param aGridOrigin The origin point of the snap grid.
     * @param aGridSize The grid size to locate to if provided.  If NULL then the current
     *                  grid size is used.
     * @return The nearst grid position.
     */
    wxPoint getNearestGridPosition( const wxPoint& aPosition, const wxPoint& aGridOrigin,
141
                                    wxRealPoint* aGridSize ) const;
142 143 144 145 146 147 148 149 150 151

    /**
     * Function getCursorPosition
     * returns the current cursor position in logical (drawing) units.
     * @param aOnGrid Returns the nearest grid position at the current cursor position.
     * @param aGridOrigin Origin point of the snap grid.
     * @param aGridSize Custom grid size instead of the current grid size.  Only valid
     *        if \a aOnGrid is true.
     * @return The current cursor position.
     */
152
    wxPoint getCursorPosition( bool aOnGrid, const wxPoint& aGridOrigin, wxRealPoint* aGridSize ) const;
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174

    void setMousePosition( const wxPoint& aPosition ) { m_MousePosition = aPosition; }

    /**
     * Function RefPos
     * Return the reference position, coming from either the mouse position
     * or the cursor position.
     *
     * @param useMouse If true, return mouse position, else cursor's.
     *
     * @return wxPoint - The reference point, either the mouse position or
     *                   the cursor position.
     */
    wxPoint refPos( bool useMouse ) const
    {
        return useMouse ? m_MousePosition : m_crossHairPosition;
    }

    const wxPoint& getScrollCenterPosition() const          { return m_scrollCenter; }
    void setScrollCenterPosition( const wxPoint& aPoint )   { m_scrollCenter = aPoint; }

    //----</Old public API now is private, and migratory>------------------------
175 176


177
public:
178 179
    static  wxString m_PageLayoutDescrFileName; ///< the name of the page layout descr file,
                                                ///< or emty to used the default pagelayout
180

181 182 183 184
    wxPoint     m_DrawOrg;          ///< offsets for drawing the circuit on the screen

    wxPoint     m_O_Curseur;        ///< Relative Screen cursor coordinate (on grid)
                                    ///< in user units. (coordinates from last reset position)
185

186
    // Scrollbars management:
187 188
    int         m_ScrollPixelsPerUnitX; ///< Pixels per scroll unit in the horizontal direction.
    int         m_ScrollPixelsPerUnitY; ///< Pixels per scroll unit in the vertical direction.
189

190
    wxSize      m_ScrollbarNumber;  /**< Current virtual draw area size in scroll units.
191 192
                                     * m_ScrollbarNumber * m_ScrollPixelsPerUnit =
                                     * virtual draw area size in pixels */
193

194
    wxPoint     m_ScrollbarPos;     ///< Current scroll bar position in scroll units.
195

196 197 198
    wxPoint     m_StartVisu;        /**< Coordinates in drawing units of the current
                                     * view position (upper left corner of device)
                                     */
199

200 201 202 203 204 205
    bool        m_Center;           /**< Center on screen.  If true (0.0) is centered
                                     * on screen coordinates can be < 0 and
                                     * > 0 except for schematics.
                                     * false: when coordinates can only be >= 0
                                     * Schematic */
    bool        m_FirstRedraw;
206

charras's avatar
charras committed
207
    // Undo/redo list of commands
208 209 210
    UNDO_REDO_CONTAINER m_UndoList;         ///< Objects list for the undo command (old data)
    UNDO_REDO_CONTAINER m_RedoList;         ///< Objects list for the redo command (old data)
    unsigned            m_UndoRedoCountMax; ///< undo/Redo command Max depth
211

212
    // block control
213
    BLOCK_SELECTOR      m_BlockLocate;      ///< Block description for block commands
214

215
    int                 m_ScreenNumber;
216
    int                 m_NumberOfScreens;
217

218 219
    std::vector<double> m_ZoomList;         ///< standard zoom (i.e. scale) coefficients.
    bool                m_IsPrinting;
220 221

public:
222
    BASE_SCREEN( KICAD_T aType = SCREEN_T );
223 224 225
    ~BASE_SCREEN();

    /**
226
     * Function SetCurItem
227
     * sets the currently selected object, m_CurrentItem.
228
     * @param aItem Any object derived from EDA_ITEM
229
     */
230
    void SetCurItem( EDA_ITEM* aItem ) { m_CurrentItem = aItem; }
231

232 233
    EDA_ITEM* GetCurItem() const { return m_CurrentItem; }

234
    void InitDataPoints( const wxSize& aPageSizeInternalUnits );
235

236
    /**
237 238
     * Function MilsToIuScalar
     * returns the scalar required to convert mils to internal units.
239
     *
240 241 242
     * @note This is a temporary hack until the derived objects SCH_SCREEN and PCB_SCREEN
     *       no longer need to be derived from BASE_SCREEN.  I does allow removal of the
     *       obsolete GetInternalUnits function.
243
     */
244
    virtual int MilsToIuScalar() { return 1; }
245 246

    /* general Undo/Redo command control */
247

248 249
    /**
     * Function ClearUndoORRedoList (virtual).
250
     * this function must remove the aItemCount old commands from aList
251
     * and delete commands, pickers and picked items if needed
252 253 254
     * Because picked items must be deleted only if they are not in use, this
     * is a virtual pure function that must be created for SCH_SCREEN and
     * PCB_SCREEN
255
     * @param aList = the UNDO_REDO_CONTAINER of commands
256 257
     * @param aItemCount = number of old commands to delete. -1 to remove all
     *                     old commands this will empty the list of commands.
258 259
     *  Commands are deleted from the older to the last.
     */
260
    virtual void ClearUndoORRedoList( UNDO_REDO_CONTAINER& aList, int aItemCount = -1 ) = 0;
261

262 263
    /**
     * Function ClearUndoRedoList
264
     * clear undo and redo list, using ClearUndoORRedoList()
265 266
     * picked items are deleted by ClearUndoORRedoList() according to their
     * status
267
     */
268
    virtual void ClearUndoRedoList();
269

270 271
    /**
     * Function PushCommandToUndoList
272
     * add a command to undo in undo list
273 274
     * delete the very old commands when the max count of undo commands is
     * reached
275 276
     * ( using ClearUndoORRedoList)
     */
277
    virtual void PushCommandToUndoList( PICKED_ITEMS_LIST* aItem );
278

279 280
    /**
     * Function PushCommandToRedoList
281
     * add a command to redo in redo list
282 283
     * delete the very old commands when the max count of redo commands is
     * reached
284 285
     * ( using ClearUndoORRedoList)
     */
286
    virtual void PushCommandToRedoList( PICKED_ITEMS_LIST* aItem );
287 288 289 290 291

    /** PopCommandFromUndoList
     * return the last command to undo and remove it from list
     * nothing is deleted.
     */
charras's avatar
charras committed
292
    virtual PICKED_ITEMS_LIST* PopCommandFromUndoList();
293 294 295 296 297

    /** PopCommandFromRedoList
     * return the last command to undo and remove it from list
     * nothing is deleted.
     */
charras's avatar
charras committed
298
    virtual PICKED_ITEMS_LIST* PopCommandFromRedoList();
299

300
    int GetUndoCommandCount() const
charras's avatar
charras committed
301 302 303
    {
        return m_UndoList.m_CommandsList.size();
    }
304

305
    int GetRedoCommandCount() const
charras's avatar
charras committed
306 307 308
    {
        return m_RedoList.m_CommandsList.size();
    }
309

310 311 312 313 314 315
    void SetModify()        { m_FlagModified = true; }
    void ClrModify()        { m_FlagModified = false; }
    void SetSave()          { m_FlagSave = true; }
    void ClrSave()          { m_FlagSave = false; }
    bool IsModify() const   { return m_FlagModified; }
    bool IsSave() const     { return m_FlagSave; }
316 317


318
    //----<zoom stuff>---------------------------------------------------------
319

320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
    /**
     * Function GetZoom
     * returns the current "zoom factor", which is a measure of
     * "internal units per device unit", or "world units per device unit".
     * A device unit is typically a pixel.
     */
    double GetZoom() const      { return m_Zoom; }

    /**
     * Function SetZoom
     * adjusts the current zoom factor.
     *
     * @param iu_per_du is the number of internal units (world units) per
     *   device units (pixels typically).
     */
    bool SetZoom( double iu_per_du );

    bool SetNextZoom();
    bool SetPreviousZoom();
    bool SetFirstZoom();
    bool SetLastZoom();

    /**
     * Function GetMaxAllowedZoom
     * returns the maximum allowed zoom factor, which was established as the last entry
     * in m_ZoomList.
     */
    double GetMaxAllowedZoom() const    { return m_ZoomList.size() ? *m_ZoomList.rbegin() : 1.0; }

    /**
     * Function GetMinAllowedZoom
     * returns the minimum allowed zoom factor, which was established as the first entry
     * in m_ZoomList.
     */
    double GetMinAllowedZoom() const    { return m_ZoomList.size() ? *m_ZoomList.begin() : 1.0; }

356 357
    /**
     * Function SetScalingFactor
358
     * sets the scaling factor of "internal unit per device unit".
359 360
     * If the output device is a screen, then "device units" are pixels.  The
     * "logical unit" is wx terminology, and corresponds to KiCad's "Internal Unit (IU)".
361 362 363 364
     * <p>
     * This scaling factor is "internal units per device unit".  This function is
     * the same thing currently as SetZoom(), but clamps the argument within a
     * legal range.
365

366 367
     * @param iu_per_du is the current scale used to draw items onto the device
     *   context wxDC.
368
     */
369 370 371 372 373 374 375 376 377 378 379
    void SetScalingFactor( double iu_per_du );

    /**
     * Function GetScalingFactor
     * returns the inverse of the current scale used to draw items on screen.
     * <p>
     * This function somehow got designed to be the inverse of SetScalingFactor().
     * <p>
     * device coordinates = user coordinates * GetScalingFactor()
     */
    double GetScalingFactor() const;
380 381


382
    //----<grid stuff>----------------------------------------------------------
383 384 385 386 387 388

    /**
     * Return the command ID of the currently selected grid.
     *
     * @return int - Currently selected grid command ID.
     */
389
    int GetGridId() const { return m_Grid.m_Id; }
390 391 392 393 394 395

    /**
     * Return the grid size of the currently selected grid.
     *
     * @return wxRealPoint - The currently selected grid size.
     */
396
    const wxRealPoint& GetGridSize() const { return m_Grid.m_Size; }
397 398 399 400 401 402

    /**
     * Return the grid object of the currently selected grid.
     *
     * @return GRID_TYPE - The currently selected grid.
     */
403 404
    const GRID_TYPE& GetGrid() const { return m_Grid; }

405 406 407 408 409 410 411 412 413
    /**
     * set the current grid size m_Grid.
     * The size must be existing in grid list (in m_grids)
     * If not, the near existing grid size is used
     * @param size = the size of the new grid
     * @return the grid id offset (id from ID_POPUP_GRID_LEVEL_1000 )
     * of the currently selected grid.
     */
    int SetGrid( const wxRealPoint& size );
414 415 416

    /**
     * Function SetGrid
417 418 419 420
     * sets the grid size from command ID (not an index in grid list, but a wxID).
     * @param aCommandId = the wxWidgets command ID
     * @return the grid id offset (id from ID_POPUP_GRID_LEVEL_1000 )
     * of the currently selected grid.
421
     */
422 423
    int SetGrid( int aCommandId );

424 425 426 427
    void SetGridList( GRIDS& sizelist );
    void AddGrid( const GRID_TYPE& grid );
    void AddGrid( const wxRealPoint& size, int id );
    void AddGrid( const wxRealPoint& size, EDA_UNITS_T aUnit, int id );
428

429 430 431 432 433 434
    /**
     * Function GetGridCount().
     * Return the size of the grid list.
     *
     * @returns - The size of the grid list.
     */
435
    size_t GetGridCount() const { return m_grids.size(); }
436 437 438 439 440 441 442 443

    /**
     * Function GetGrid()
     * Returns the grid object at \a aIndex.
     *
     * @param aIndex - The grid list index.
     * @return - The grid object at \a aIndex or the current grid if the grid list is empty.
     */
444
    GRID_TYPE& GetGrid( size_t aIndex );
445 446 447

    /**
     * Function GetGrids().
448
     * Returns the current list of grids.
449
     */
450 451 452 453
    const GRIDS& GetGrids() const
    {
        return m_grids;
    }
454

455 456 457 458 459 460 461 462 463 464 465 466
    /**
     * Function BuildGridsChoiceList().
     * Build the human readable list of grid list, for menus or combo boxes
     * the list shows the grid size both in mils or mm.
     * @param aGridsList = a wxArrayString to populate
     * @param aMmFirst = true to have mm first and mils after
     *                   false to have mils first and mm after
     * @return the index of the curr grid in list, if found or -1
     */
    int BuildGridsChoiceList( wxArrayString& aGridsList, bool aMmFirst) const;


467 468 469 470 471 472 473 474 475 476
    /**
     * Function GetClass
     * returns the class name.
     * @return wxString
     */
    virtual wxString GetClass() const
    {
        return wxT( "BASE_SCREEN" );
    }

477 478 479 480
    inline bool IsBlockActive() const { return !m_BlockLocate.IsIdle(); }

    void ClearBlockCommand() { m_BlockLocate.Clear(); }

481
#if defined(DEBUG)
482
    void Show( int nestLevel, std::ostream& os ) const;     // overload
483 484 485
#endif
};

486
#endif  // CLASS_BASE_SCREEN_H_