Skip to content

K
kicad-source-mirror
Commit 3d73eb68 authored by dickelbeck's avatar dickelbeck
Browse files
Options

Beautification, Doxyfile edits

parent 0dc3be88
Hide whitespace changes
Inline Side-by-side
Showing with 804 additions and 1769 deletions
Doxyfile
View file @ 3d73eb68
# Doxyfile 1.5.1 # Doxyfile 1.5.3
# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project
#
# All text after a hash (#) is considered a comment and will be ignored
# The format is:
# TAG = value [value, ...]
# For lists items can also be appended using:
# TAG += value [value, ...]
# Values that contain spaces should be placed between quotes (" ")
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# Project related configuration options # Project related configuration options
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
# by quotes) that should identify the project.
PROJECT_NAME = Kicad PROJECT_NAME = Kicad
# The PROJECT_NUMBER tag can be used to enter a project or revision number.
# This could be handy for archiving the generated documentation or
# if some version control system is used.
PROJECT_NUMBER = PROJECT_NUMBER =
OUTPUT_DIRECTORY =
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
# base path where the generated documentation will be put.
# If a relative path is entered, it will be relative to the location
# where doxygen was started. If left blank the current directory will be used.
OUTPUT_DIRECTORY =
# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
# 4096 sub-directories (in 2 levels) under the output directory of each output
# format and will distribute the generated files over these directories.
# Enabling this option can be useful when feeding doxygen a huge amount of
# source files, where putting all generated files in the same directory would
# otherwise cause performance problems for the file system.
CREATE_SUBDIRS = NO CREATE_SUBDIRS = NO
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
# documentation generated by doxygen is written. Doxygen will use this
# information to generate all constant output in the proper language.
# The default language is English, other supported languages are:
# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
# Croatian, Czech, Danish, Dutch, Finnish, French, German, Greek, Hungarian,
# Italian, Japanese, Japanese-en (Japanese with English messages), Korean,
# Korean-en, Lithuanian, Norwegian, Polish, Portuguese, Romanian, Russian,
# Serbian, Slovak, Slovene, Spanish, Swedish, and Ukrainian.
OUTPUT_LANGUAGE = English OUTPUT_LANGUAGE = English
# This tag can be used to specify the encoding used in the generated output.
# The encoding is not always determined by the language that is chosen,
# but also whether or not the output is meant for Windows or non-Windows users.
# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES
# forces the Windows encoding (this is the default for the Windows binary),
# whereas setting the tag to NO uses a Unix-style encoding (the default for
# all platforms other than Windows).
USE_WINDOWS_ENCODING = NO
# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
# include brief member descriptions after the members that are listed in
# the file and class documentation (similar to JavaDoc).
# Set to NO to disable this.
BRIEF_MEMBER_DESC = YES BRIEF_MEMBER_DESC = YES
# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
# the brief description of a member or function before the detailed description.
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
# brief descriptions will be completely suppressed.
REPEAT_BRIEF = YES REPEAT_BRIEF = YES
# This tag implements a quasi-intelligent brief description abbreviator
# that is used to form the text in various listings. Each string
# in this list, if found as the leading text of the brief description, will be
# stripped from the text and the result after processing the whole list, is
# used as the annotated text. Otherwise, the brief description is used as-is.
# If left blank, the following values are used ("$name" is automatically
# replaced with the name of the entity): "The $name class" "The $name widget"
# "The $name file" "is" "provides" "specifies" "contains"
# "represents" "a" "an" "the"
ABBREVIATE_BRIEF = ABBREVIATE_BRIEF =
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
# Doxygen will generate a detailed section even if there is only a brief
# description.
ALWAYS_DETAILED_SEC = NO ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = YES
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
# inherited members of a class in the documentation of that class as if those
# members were ordinary class members. Constructors, destructors and assignment
# operators of the base classes will not be shown.
INLINE_INHERITED_MEMB = NO
# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
# path before files name in the file list and in the header files. If set
# to NO the shortest path that makes the file name unique will be used.
FULL_PATH_NAMES = NO FULL_PATH_NAMES = NO
# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
# can be used to strip a user-defined part of the path. Stripping is
# only done if one of the specified strings matches the left-hand part of
# the path. The tag can be used to show relative paths in the file list.
# If left blank the directory from which doxygen is run is used as the
# path to strip.
STRIP_FROM_PATH = STRIP_FROM_PATH =
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
# the path mentioned in the documentation of a class, which tells
# the reader which header file to include in order to use a class.
# If left blank only the name of the header file containing the class
# definition is used. Otherwise one should specify the include paths that
# are normally passed to the compiler using the -I flag.
STRIP_FROM_INC_PATH = STRIP_FROM_INC_PATH =
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
# (but less readable) file names. This can be useful is your file systems
# doesn't support long names like on DOS, Mac, or CD-ROM.
SHORT_NAMES = NO SHORT_NAMES = NO
# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
# will interpret the first line (until the first dot) of a JavaDoc-style
# comment as the brief description. If set to NO, the JavaDoc
# comments will behave just like the Qt-style comments (thus requiring an
# explicit @brief command for a brief description.
JAVADOC_AUTOBRIEF = YES JAVADOC_AUTOBRIEF = YES
QT_AUTOBRIEF = NO
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
# treat a multi-line C++ special comment block (i.e. a block of //! or ///
# comments) as a brief description. This used to be the default behaviour.
# The new default is to treat a multi-line C++ comment block as a detailed
# description. Set this tag to YES if you prefer the old behaviour instead.
MULTILINE_CPP_IS_BRIEF = NO MULTILINE_CPP_IS_BRIEF = NO
DETAILS_AT_TOP = YES
# If the DETAILS_AT_TOP tag is set to YES then Doxygen
# will output the detailed description near the top, like JavaDoc.
# If set to NO, the detailed description appears after the member
# documentation.
DETAILS_AT_TOP = NO
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
# member inherits the documentation from any documented member that it
# re-implements.
INHERIT_DOCS = YES INHERIT_DOCS = YES
# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
# a new page for each member. If set to NO, the documentation of a member will
# be part of the file/class/namespace that contains it.
SEPARATE_MEMBER_PAGES = NO SEPARATE_MEMBER_PAGES = NO
# The TAB_SIZE tag can be used to set the number of spaces in a tab.
# Doxygen uses this value to replace tabs by spaces in code fragments.
TAB_SIZE = 4 TAB_SIZE = 4
# This tag can be used to specify a number of aliases that acts
# as commands in the documentation. An alias has the form "name=value".
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
# put the command \sideeffect (or @sideeffect) in the documentation, which
# will result in a user-defined paragraph with heading "Side Effects:".
# You can put \n's in the value part of an alias to insert newlines.
ALIASES = ALIASES =
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
# sources only. Doxygen will then generate output that is more tailored for C.
# For instance, some of the names that are used will be different. The list
# of all members will be omitted, etc.
OPTIMIZE_OUTPUT_FOR_C = NO OPTIMIZE_OUTPUT_FOR_C = NO
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
# sources only. Doxygen will then generate output that is more tailored for Java.
# For instance, namespaces will be presented as packages, qualified scopes
# will look different, etc.
OPTIMIZE_OUTPUT_JAVA = NO OPTIMIZE_OUTPUT_JAVA = NO
# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to
# include (a tag file for) the STL sources as input, then you should
# set this tag to YES in order to let doxygen match functions declarations and
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
# func(std::string) {}). This also make the inheritance and collaboration
# diagrams that involve STL classes more complete and accurate.
BUILTIN_STL_SUPPORT = NO BUILTIN_STL_SUPPORT = NO
CPP_CLI_SUPPORT = NO
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
# tag is set to YES, then doxygen will reuse the documentation of the first
# member in the group (if any) for the other members of the group. By default
# all members of a group must be documented explicitly.
DISTRIBUTE_GROUP_DOC = NO DISTRIBUTE_GROUP_DOC = NO
# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
# the same type (for instance a group of public functions) to be put as a
# subgroup of that type (e.g. under the Public Functions section). Set it to
# NO to prevent subgrouping. Alternatively, this can be done per class using
# the \nosubgrouping command.
SUBGROUPING = YES SUBGROUPING = YES
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# Build related configuration options # Build related configuration options
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
# documentation are documented, even if no documentation was available.
# Private class members and static file members will be hidden unless
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
EXTRACT_ALL = YES EXTRACT_ALL = YES
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
# will be included in the documentation.
EXTRACT_PRIVATE = NO EXTRACT_PRIVATE = NO
# If the EXTRACT_STATIC tag is set to YES all static members of a file
# will be included in the documentation.
EXTRACT_STATIC = YES EXTRACT_STATIC = YES
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
# defined locally in source files will be included in the documentation.
# If set to NO only classes defined in header files are included.
EXTRACT_LOCAL_CLASSES = YES EXTRACT_LOCAL_CLASSES = YES
# This flag is only useful for Objective-C code. When set to YES local
# methods, which are defined in the implementation section but not in
# the interface are included in the documentation.
# If set to NO (the default) only methods in the interface are included.
EXTRACT_LOCAL_METHODS = NO EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
# undocumented members of documented classes, files or namespaces.
# If set to NO (the default) these members will be included in the
# various overviews, but no documentation section is generated.
# This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_MEMBERS = NO HIDE_UNDOC_MEMBERS = NO
# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
# undocumented classes that are normally visible in the class hierarchy.
# If set to NO (the default) these classes will be included in the various
# overviews. This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_CLASSES = NO HIDE_UNDOC_CLASSES = NO
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
# friend (class|struct|union) declarations.
# If set to NO (the default) these declarations will be included in the
# documentation.
HIDE_FRIEND_COMPOUNDS = NO HIDE_FRIEND_COMPOUNDS = NO
# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
# documentation blocks found inside the body of a function.
# If set to NO (the default) these blocks will be appended to the
# function's detailed documentation block.
HIDE_IN_BODY_DOCS = NO HIDE_IN_BODY_DOCS = NO
# The INTERNAL_DOCS tag determines if documentation
# that is typed after a \internal command is included. If the tag is set
# to NO (the default) then the documentation will be excluded.
# Set it to YES to include the internal documentation.
INTERNAL_DOCS = NO INTERNAL_DOCS = NO
# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
# file names in lower-case letters. If set to YES upper-case letters are also
# allowed. This is useful if you have classes or files whose names only differ
# in case and if your file system supports case sensitive file names. Windows
# and Mac users are advised to set this option to NO.
CASE_SENSE_NAMES = YES CASE_SENSE_NAMES = YES
# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
# will show members with their full class and namespace scopes in the
# documentation. If set to YES the scope will be hidden.
HIDE_SCOPE_NAMES = NO HIDE_SCOPE_NAMES = NO
# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
# will put a list of the files that are included by a file in the documentation
# of that file.
SHOW_INCLUDE_FILES = YES SHOW_INCLUDE_FILES = YES
# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
# is inserted in the documentation for inline members.
INLINE_INFO = YES INLINE_INFO = YES
# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
# will sort the (detailed) documentation of file and class members
# alphabetically by member name. If set to NO the members will appear in
# declaration order.
SORT_MEMBER_DOCS = YES SORT_MEMBER_DOCS = YES
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
# brief documentation of file, namespace and class members alphabetically
# by member name. If set to NO (the default) the members will appear in
# declaration order.
SORT_BRIEF_DOCS = NO SORT_BRIEF_DOCS = NO
# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
# sorted by fully-qualified names, including namespaces. If set to
# NO (the default), the class list will be sorted only by class name,
# not including the namespace part.
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
# Note: This option applies only to the class list, not to the
# alphabetical list.
SORT_BY_SCOPE_NAME = NO SORT_BY_SCOPE_NAME = NO
# The GENERATE_TODOLIST tag can be used to enable (YES) or
# disable (NO) the todo list. This list is created by putting \todo
# commands in the documentation.
GENERATE_TODOLIST = YES GENERATE_TODOLIST = YES
# The GENERATE_TESTLIST tag can be used to enable (YES) or
# disable (NO) the test list. This list is created by putting \test
# commands in the documentation.
GENERATE_TESTLIST = YES GENERATE_TESTLIST = YES
# The GENERATE_BUGLIST tag can be used to enable (YES) or
# disable (NO) the bug list. This list is created by putting \bug
# commands in the documentation.
GENERATE_BUGLIST = YES GENERATE_BUGLIST = YES
# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
# disable (NO) the deprecated list. This list is created by putting
# \deprecated commands in the documentation.
GENERATE_DEPRECATEDLIST= YES GENERATE_DEPRECATEDLIST= YES
# The ENABLED_SECTIONS tag can be used to enable conditional
# documentation sections, marked by \if sectionname ... \endif.
ENABLED_SECTIONS = ENABLED_SECTIONS =
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
# the initial value of a variable or define consists of for it to appear in
# the documentation. If the initializer consists of more lines than specified
# here it will be hidden. Use a value of 0 to hide initializers completely.
# The appearance of the initializer of individual variables and defines in the
# documentation can be controlled using \showinitializer or \hideinitializer
# command in the documentation regardless of this setting.
MAX_INITIALIZER_LINES = 30 MAX_INITIALIZER_LINES = 30
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
# at the bottom of the documentation of classes and structs. If set to YES the
# list will mention the files that were used to generate the documentation.
SHOW_USED_FILES = YES SHOW_USED_FILES = YES
SHOW_DIRECTORIES = YES
# If the sources in your project are distributed over multiple directories
# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
# in the documentation. The default is NO.
SHOW_DIRECTORIES = NO
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
# doxygen should invoke to get the current version for each file (typically from the
# version control system). Doxygen will invoke the program by executing (via
# popen()) the command <command> <input-file>, where <command> is the value of
# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
# provided by doxygen. Whatever the program writes to standard output
# is used as the file version. See the manual for examples.
FILE_VERSION_FILTER = FILE_VERSION_FILTER =
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to warning and progress messages # configuration options related to warning and progress messages
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# The QUIET tag can be used to turn on/off the messages that are generated
# by doxygen. Possible values are YES and NO. If left blank NO is used.
QUIET = NO QUIET = NO
# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated by doxygen. Possible values are YES and NO. If left blank
# NO is used.
WARNINGS = YES WARNINGS = YES
# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
# automatically be disabled.
WARN_IF_UNDOCUMENTED = YES WARN_IF_UNDOCUMENTED = YES
# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
# potential errors in the documentation, such as not documenting some
# parameters in a documented function, or documenting parameters that
# don't exist or using markup commands wrongly.
WARN_IF_DOC_ERROR = YES WARN_IF_DOC_ERROR = YES
# This WARN_NO_PARAMDOC option can be abled to get warnings for
# functions that are documented, but have no documentation for their parameters
# or return value. If set to NO (the default) doxygen will only warn about
# wrong or incomplete parameter documentation, but not about the absence of
# documentation.
WARN_NO_PARAMDOC = NO WARN_NO_PARAMDOC = NO
WARN_FORMAT = "$file:$line: $text "
# The WARN_FORMAT tag determines the format of the warning messages that
# doxygen can produce. The string should contain the $file, $line, and $text
# tags, which will be replaced by the file and line number from which the
# warning originated and the warning text. Optionally the format may contain
# $version, which will be replaced by the version of the file (if it could
# be obtained via FILE_VERSION_FILTER)
WARN_FORMAT = "$file:$line: $text"
# The WARN_LOGFILE tag can be used to specify a file to which warning
# and error messages should be written. If left blank the output is written
# to stderr.
WARN_LOGFILE = WARN_LOGFILE =
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to the input files # configuration options related to the input files
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# The INPUT tag can be used to specify the files and/or directories that contain
# documented source files. You may enter file names like "myfile.cpp" or
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.
INPUT = kicad \ INPUT = kicad \
pcbnew \ pcbnew \
eeschema \ eeschema \
...@@ -468,799 +84,160 @@ INPUT = kicad \ ...@@ -468,799 +84,160 @@ INPUT = kicad \
share \ share \
include \ include \
polygon polygon
INPUT_ENCODING = UTF-8
# If the value of the INPUT tag contains directories, you can use the
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank the following patterns are tested:
# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py
FILE_PATTERNS = *.h \ FILE_PATTERNS = *.h \
*.cpp *.cpp
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.
# If left blank NO is used.
RECURSIVE = YES RECURSIVE = YES
# The EXCLUDE tag can be used to specify files and/or directories that should
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
EXCLUDE = EXCLUDE =
# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
# directories that are symbolic links (a Unix filesystem feature) are excluded
# from the input.
EXCLUDE_SYMLINKS = NO EXCLUDE_SYMLINKS = NO
# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories. Note that the wildcards are matched
# against the file with absolute path, so to exclude all test directories
# for example use the pattern */test/*
EXCLUDE_PATTERNS = EXCLUDE_PATTERNS =
EXCLUDE_SYMBOLS =
# The EXAMPLE_PATH tag can be used to specify one or more files or
# directories that contain example code fragments that are included (see
# the \include command).
EXAMPLE_PATH = EXAMPLE_PATH =
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank all files are included.
EXAMPLE_PATTERNS = EXAMPLE_PATTERNS =
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
# searched for input files to be used with the \include or \dontinclude
# commands irrespective of the value of the RECURSIVE tag.
# Possible values are YES and NO. If left blank NO is used.
EXAMPLE_RECURSIVE = NO EXAMPLE_RECURSIVE = NO
# The IMAGE_PATH tag can be used to specify one or more files or
# directories that contain image that are included in the documentation (see
# the \image command).
IMAGE_PATH = IMAGE_PATH =
# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
# by executing (via popen()) the command <filter> <input-file>, where <filter>
# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
# input file. Doxygen will then use the output that the filter program writes
# to standard output. If FILTER_PATTERNS is specified, this tag will be
# ignored.
INPUT_FILTER = INPUT_FILTER =
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
# basis. Doxygen will compare the file name with each pattern and apply the
# filter if there is a match. The filters are a list of the form:
# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
# is applied to all files.
FILTER_PATTERNS = FILTER_PATTERNS =
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
# INPUT_FILTER) will be used to filter the input files when producing source
# files to browse (i.e. when SOURCE_BROWSER is set to YES).
FILTER_SOURCE_FILES = NO FILTER_SOURCE_FILES = NO
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to source browsing # configuration options related to source browsing
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
SOURCE_BROWSER = YES
# If the SOURCE_BROWSER tag is set to YES then a list of source files will INLINE_SOURCES = YES
# be generated. Documented entities will be cross-referenced with these sources.
# Note: To get rid of all source code in the generated output, make sure also
# VERBATIM_HEADERS is set to NO.
SOURCE_BROWSER = NO
# Setting the INLINE_SOURCES tag to YES will include the body
# of functions and classes directly in the documentation.
INLINE_SOURCES = NO
# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
# doxygen to hide any special comment blocks from generated source code
# fragments. Normal C and C++ comments will always remain visible.
STRIP_CODE_COMMENTS = YES STRIP_CODE_COMMENTS = YES
# If the REFERENCED_BY_RELATION tag is set to YES (the default)
# then for each documented function all documented
# functions referencing it will be listed.
REFERENCED_BY_RELATION = YES REFERENCED_BY_RELATION = YES
# If the REFERENCES_RELATION tag is set to YES (the default)
# then for each documented function all documented entities
# called/used by that function will be listed.
REFERENCES_RELATION = YES REFERENCES_RELATION = YES
# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
# link to the source code. Otherwise they will link to the documentstion.
REFERENCES_LINK_SOURCE = YES REFERENCES_LINK_SOURCE = YES
# If the USE_HTAGS tag is set to YES then the references to source code
# will point to the HTML generated by the htags(1) tool instead of doxygen
# built-in source browser. The htags tool is part of GNU's global source
# tagging system (see http://www.gnu.org/software/global/global.html). You
# will need version 4.8.6 or higher.
USE_HTAGS = NO USE_HTAGS = NO
VERBATIM_HEADERS = YES
# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
# will generate a verbatim copy of the header file for each class for
# which an include is specified. Set to NO to disable this.
VERBATIM_HEADERS = NO
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to the alphabetical class index # configuration options related to the alphabetical class index
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
ALPHABETICAL_INDEX = YES
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
# of all compounds will be generated. Enable this if the project
# contains a lot of classes, structs, unions or interfaces.
ALPHABETICAL_INDEX = NO
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
# in which this list will be split (can be a number in the range [1..20])
COLS_IN_ALPHA_INDEX = 5 COLS_IN_ALPHA_INDEX = 5
# In case all classes in a project start with a common prefix, all
# classes will be put under the same header in the alphabetical index.
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
# should be ignored while generating the index headers.
IGNORE_PREFIX = IGNORE_PREFIX =
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to the HTML output # configuration options related to the HTML output
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
# generate HTML output.
GENERATE_HTML = YES GENERATE_HTML = YES
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `html' will be used as the default path.
HTML_OUTPUT = doxygen HTML_OUTPUT = doxygen
# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
# doxygen will generate files with .html extension.
HTML_FILE_EXTENSION = .html HTML_FILE_EXTENSION = .html
# The HTML_HEADER tag can be used to specify a personal HTML header for
# each generated HTML page. If it is left blank doxygen will generate a
# standard header.
HTML_HEADER = HTML_HEADER =
# The HTML_FOOTER tag can be used to specify a personal HTML footer for
# each generated HTML page. If it is left blank doxygen will generate a
# standard footer.
HTML_FOOTER = HTML_FOOTER =
# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
# style sheet that is used by each HTML page. It can be used to
# fine-tune the look of the HTML output. If the tag is left blank doxygen
# will generate a default style sheet. Note that doxygen will try to copy
# the style sheet file to the HTML output directory, so don't put your own
# stylesheet in the HTML output directory as well, or it will be erased!
HTML_STYLESHEET = HTML_STYLESHEET =
# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
# files or namespaces will be aligned in HTML using tables. If set to
# NO a bullet list will be used.
HTML_ALIGN_MEMBERS = YES HTML_ALIGN_MEMBERS = YES
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
# will be generated that can be used as input for tools like the
# Microsoft HTML help workshop to generate a compressed HTML help file (.chm)
# of the generated HTML documentation.
GENERATE_HTMLHELP = NO GENERATE_HTMLHELP = NO
HTML_DYNAMIC_SECTIONS = NO
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
# be used to specify the file name of the resulting .chm file. You
# can add a path in front of the file if the result should not be
# written to the html output directory.
CHM_FILE = CHM_FILE =
# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
# be used to specify the location (absolute path including file name) of
# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
# the HTML help compiler on the generated index.hhp.
HHC_LOCATION = HHC_LOCATION =
# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
# controls if a separate .chi index file is generated (YES) or that
# it should be included in the master .chm file (NO).
GENERATE_CHI = NO GENERATE_CHI = NO
# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
# controls whether a binary table of contents is generated (YES) or a
# normal table of contents (NO) in the .chm file.
BINARY_TOC = NO BINARY_TOC = NO
# The TOC_EXPAND flag can be set to YES to add extra items for group members
# to the contents of the HTML help documentation and to the tree view.
TOC_EXPAND = NO TOC_EXPAND = NO
# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
# top of each HTML page. The value NO (the default) enables the index and
# the value YES disables it.
DISABLE_INDEX = NO DISABLE_INDEX = NO
# This tag can be used to set the number of enum values (range [1..20])
# that doxygen will group on one line in the generated HTML documentation.
ENUM_VALUES_PER_LINE = 4 ENUM_VALUES_PER_LINE = 4
# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
# generated containing a tree-like index structure (just like the one that
# is generated for HTML Help). For this to work a browser that supports
# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,
# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are
# probably better off using the HTML help feature.
GENERATE_TREEVIEW = YES GENERATE_TREEVIEW = YES
# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
# used to set the initial width (in pixels) of the frame in which the tree
# is shown.
TREEVIEW_WIDTH = 250 TREEVIEW_WIDTH = 250
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to the LaTeX output # configuration options related to the LaTeX output
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
# generate Latex output.
GENERATE_LATEX = NO GENERATE_LATEX = NO
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `latex' will be used as the default path.
LATEX_OUTPUT = latex LATEX_OUTPUT = latex
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked. If left blank `latex' will be used as the default command name.
LATEX_CMD_NAME = latex LATEX_CMD_NAME = latex
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
# generate index for LaTeX. If left blank `makeindex' will be used as the
# default command name.
MAKEINDEX_CMD_NAME = makeindex MAKEINDEX_CMD_NAME = makeindex
# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
# LaTeX documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_LATEX = NO COMPACT_LATEX = NO
# The PAPER_TYPE tag can be used to set the paper type that is used
# by the printer. Possible values are: a4, a4wide, letter, legal and
# executive. If left blank a4wide will be used.
PAPER_TYPE = a4wide PAPER_TYPE = a4wide
# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
# packages that should be included in the LaTeX output.
EXTRA_PACKAGES = EXTRA_PACKAGES =
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
# the generated latex document. The header should contain everything until
# the first chapter. If it is left blank doxygen will generate a
# standard header. Notice: only use this tag if you know what you are doing!
LATEX_HEADER = LATEX_HEADER =
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
# contain links (just like the HTML output) instead of page references
# This makes the output suitable for online browsing using a pdf viewer.
PDF_HYPERLINKS = NO PDF_HYPERLINKS = NO
# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
# plain latex in the generated Makefile. Set this option to YES to get a
# higher quality PDF documentation.
USE_PDFLATEX = NO USE_PDFLATEX = NO
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
# command to the generated LaTeX files. This will instruct LaTeX to keep
# running if errors occur, instead of asking the user for help.
# This option is also used when generating formulas in HTML.
LATEX_BATCHMODE = NO LATEX_BATCHMODE = NO
# If LATEX_HIDE_INDICES is set to YES then doxygen will not
# include the index chapters (such as File Index, Compound Index, etc.)
# in the output.
LATEX_HIDE_INDICES = NO LATEX_HIDE_INDICES = NO
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to the RTF output # configuration options related to the RTF output
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
# The RTF output is optimized for Word 97 and may not look very pretty with
# other RTF readers or editors.
GENERATE_RTF = NO GENERATE_RTF = NO
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `rtf' will be used as the default path.
RTF_OUTPUT = rtf RTF_OUTPUT = rtf
# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
# RTF documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_RTF = NO COMPACT_RTF = NO
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
# will contain hyperlink fields. The RTF file will
# contain links (just like the HTML output) instead of page references.
# This makes the output suitable for online browsing using WORD or other
# programs which support those fields.
# Note: wordpad (write) and others do not support links.
RTF_HYPERLINKS = NO RTF_HYPERLINKS = NO
# Load stylesheet definitions from file. Syntax is similar to doxygen's
# config file, i.e. a series of assignments. You only have to provide
# replacements, missing definitions are set to their default value.
RTF_STYLESHEET_FILE = RTF_STYLESHEET_FILE =
# Set optional variables used in the generation of an rtf document.
# Syntax is similar to doxygen's config file.
RTF_EXTENSIONS_FILE = RTF_EXTENSIONS_FILE =
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to the man page output # configuration options related to the man page output
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
# generate man pages
GENERATE_MAN = NO GENERATE_MAN = NO
# The MAN_OUTPUT tag is used to specify where the man pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `man' will be used as the default path.
MAN_OUTPUT = man MAN_OUTPUT = man
# The MAN_EXTENSION tag determines the extension that is added to
# the generated man pages (default is the subroutine's section .3)
MAN_EXTENSION = .3 MAN_EXTENSION = .3
# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
# then it will generate one additional man file for each entity
# documented in the real man page(s). These additional files
# only source the real man page, but without them the man command
# would be unable to find the correct page. The default is NO.
MAN_LINKS = NO MAN_LINKS = NO
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to the XML output # configuration options related to the XML output
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the GENERATE_XML tag is set to YES Doxygen will
# generate an XML file that captures the structure of
# the code including all documentation.
GENERATE_XML = NO GENERATE_XML = NO
# The XML_OUTPUT tag is used to specify where the XML pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `xml' will be used as the default path.
XML_OUTPUT = xml XML_OUTPUT = xml
# The XML_SCHEMA tag can be used to specify an XML schema,
# which can be used by a validating XML parser to check the
# syntax of the XML files.
XML_SCHEMA = XML_SCHEMA =
# The XML_DTD tag can be used to specify an XML DTD,
# which can be used by a validating XML parser to check the
# syntax of the XML files.
XML_DTD = XML_DTD =
# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
# dump the program listings (including syntax highlighting
# and cross-referencing information) to the XML output. Note that
# enabling this will significantly increase the size of the XML output.
XML_PROGRAMLISTING = YES XML_PROGRAMLISTING = YES
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output # configuration options for the AutoGen Definitions output
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
# generate an AutoGen Definitions (see autogen.sf.net) file
# that captures the structure of the code including all
# documentation. Note that this feature is still experimental
# and incomplete at the moment.
GENERATE_AUTOGEN_DEF = NO GENERATE_AUTOGEN_DEF = NO
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# configuration options related to the Perl module output # configuration options related to the Perl module output
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the GENERATE_PERLMOD tag is set to YES Doxygen will
# generate a Perl module file that captures the structure of
# the code including all documentation. Note that this
# feature is still experimental and incomplete at the
# moment.
GENERATE_PERLMOD = NO GENERATE_PERLMOD = NO
# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
# the necessary Makefile rules, Perl scripts and LaTeX code to be able
# to generate PDF and DVI output from the Perl module output.
PERLMOD_LATEX = NO PERLMOD_LATEX = NO
# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
# nicely formatted so it can be parsed by a human reader. This is useful
# if you want to understand what is going on. On the other hand, if this
# tag is set to NO the size of the Perl module output will be much smaller
# and Perl will parse it just the same.
PERLMOD_PRETTY = YES PERLMOD_PRETTY = YES
# The names of the make variables in the generated doxyrules.make file
# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
# This is useful so different doxyrules.make files included by the same
# Makefile don't overwrite each other's variables.
PERLMOD_MAKEVAR_PREFIX = PERLMOD_MAKEVAR_PREFIX =
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# Configuration options related to the preprocessor # Configuration options related to the preprocessor
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
# evaluate all C-preprocessor directives found in the sources and include
# files.
ENABLE_PREPROCESSING = YES ENABLE_PREPROCESSING = YES
# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
# names in the source code. If set to NO (the default) only conditional
# compilation will be performed. Macro expansion can be done in a controlled
# way by setting EXPAND_ONLY_PREDEF to YES.
MACRO_EXPANSION = NO MACRO_EXPANSION = NO
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
# then the macro expansion is limited to the macros specified with the
# PREDEFINED and EXPAND_AS_DEFINED tags.
EXPAND_ONLY_PREDEF = NO EXPAND_ONLY_PREDEF = NO
# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
# in the INCLUDE_PATH (see below) will be search if a #include is found.
SEARCH_INCLUDES = YES SEARCH_INCLUDES = YES
INCLUDE_PATH = include \
# The INCLUDE_PATH tag can be used to specify one or more directories that pcbnew \
# contain include files that are not input files but should be processed by eeschema \
# the preprocessor. gerbview
INCLUDE_PATH = h \
rung/h \
store/h \
zlib \
tdlib/h
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
# patterns (like *.h and *.hpp) to filter out the header-files in the
# directories. If left blank, the patterns specified with FILE_PATTERNS will
# be used.
INCLUDE_FILE_PATTERNS = *.h INCLUDE_FILE_PATTERNS = *.h
PREDEFINED =
# The PREDEFINED tag can be used to specify one or more macro names that
# are defined before the preprocessor is started (similar to the -D option of
# gcc). The argument of the tag is a list of macros of the form: name
# or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed. To prevent a macro definition from being
# undefined via #undef or recursively expanded use the := operator
# instead of the = operator.
PREDEFINED = TD5
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
# this tag can be used to specify a list of macro names that should be expanded.
# The macro definition that is found in the sources will be used.
# Use the PREDEFINED tag if you want to use a different macro definition.
EXPAND_AS_DEFINED = EXPAND_AS_DEFINED =
# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
# doxygen's preprocessor will remove all function-like macros that are alone
# on a line, have an all uppercase name, and do not end with a semicolon. Such
# function macros are typically used for boiler-plate code, and will confuse
# the parser if not removed.
SKIP_FUNCTION_MACROS = YES SKIP_FUNCTION_MACROS = YES
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# Configuration::additions related to external references # Configuration::additions related to external references
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# The TAGFILES option can be used to specify one or more tagfiles.
# Optionally an initial location of the external documentation
# can be added for each tagfile. The format of a tag file without
# this location is as follows:
# TAGFILES = file1 file2 ...
# Adding location for the tag files is done as follows:
# TAGFILES = file1=loc1 "file2 = loc2" ...
# where "loc1" and "loc2" can be relative or absolute paths or
# URLs. If a location is present for each tag, the installdox tool
# does not have to be run to correct the links.
# Note that each tag file must have a unique name
# (where the name does NOT include the path)
# If a tag file is not located in the directory in which doxygen
# is run, you must also specify the path to the tagfile here.
TAGFILES = TAGFILES =
# When a file name is specified after GENERATE_TAGFILE, doxygen will create
# a tag file that is based on the input files it reads.
GENERATE_TAGFILE = GENERATE_TAGFILE =
# If the ALLEXTERNALS tag is set to YES all external classes will be listed
# in the class index. If set to NO only the inherited external classes
# will be listed.
ALLEXTERNALS = NO ALLEXTERNALS = NO
# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
# in the modules index. If set to NO, only the current project's groups will
# be listed.
EXTERNAL_GROUPS = YES EXTERNAL_GROUPS = YES
# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of `which perl').
PERL_PATH = /usr/bin/perl PERL_PATH = /usr/bin/perl
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# Configuration options related to the dot tool # Configuration options related to the dot tool
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
# or super classes. Setting the tag to NO turns the diagrams off. Note that
# this option is superseded by the HAVE_DOT option below. This is only a
# fallback. It is recommended to install and use dot, since it yields more
# powerful graphs.
CLASS_DIAGRAMS = YES CLASS_DIAGRAMS = YES
MSCGEN_PATH =
# If set to YES, the inheritance and collaboration graphs will hide
# inheritance and usage relations if the target is undocumented
# or is not a class.
HIDE_UNDOC_RELATIONS = YES HIDE_UNDOC_RELATIONS = YES
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
# available from the path. This tool is part of Graphviz, a graph visualization
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
# have no effect if this option is set to NO (the default)
HAVE_DOT = NO HAVE_DOT = NO
# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect inheritance relations. Setting this tag to YES will force the
# the CLASS_DIAGRAMS tag to NO.
CLASS_GRAPH = YES CLASS_GRAPH = YES
# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect implementation dependencies (inheritance, containment, and
# class references variables) of the class with other documented classes.
COLLABORATION_GRAPH = YES COLLABORATION_GRAPH = YES
# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for groups, showing the direct groups dependencies
GROUP_GRAPHS = YES GROUP_GRAPHS = YES
# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
# collaboration diagrams in a style similar to the OMG's Unified Modeling
# Language.
UML_LOOK = NO UML_LOOK = NO
# If set to YES, the inheritance and collaboration graphs will show the
# relations between templates and their instances.
TEMPLATE_RELATIONS = YES TEMPLATE_RELATIONS = YES
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
# tags are set to YES then doxygen will generate a graph for each documented
# file showing the direct and indirect include dependencies of the file with
# other documented files.
INCLUDE_GRAPH = YES INCLUDE_GRAPH = YES
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
# documented header file showing the documented files that directly or
# indirectly include this file.
INCLUDED_BY_GRAPH = YES INCLUDED_BY_GRAPH = YES
# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will
# generate a call dependency graph for every global function or class method.
# Note that enabling this option will significantly increase the time of a run.
# So in most cases it will be better to enable call graphs for selected
# functions only using the \callgraph command.
CALL_GRAPH = NO CALL_GRAPH = NO
# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then doxygen will
# generate a caller dependency graph for every global function or class method.
# Note that enabling this option will significantly increase the time of a run.
# So in most cases it will be better to enable caller graphs for selected
# functions only using the \callergraph command.
CALLER_GRAPH = NO CALLER_GRAPH = NO
# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
# will graphical hierarchy of all classes instead of a textual one.
GRAPHICAL_HIERARCHY = YES GRAPHICAL_HIERARCHY = YES
# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
# then doxygen will show the dependencies a directory has on other directories
# in a graphical way. The dependency relations are determined by the #include
# relations between the files in the directories.
DIRECTORY_GRAPH = YES DIRECTORY_GRAPH = YES
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
# generated by dot. Possible values are png, jpg, or gif
# If left blank png will be used.
DOT_IMAGE_FORMAT = png DOT_IMAGE_FORMAT = png
# The tag DOT_PATH can be used to specify the path where the dot tool can be
# found. If left blank, it is assumed the dot tool can be found in the path.
DOT_PATH = DOT_PATH =
# The DOTFILE_DIRS tag can be used to specify one or more directories that
# contain dot files that are included in the documentation (see the
# \dotfile command).
DOTFILE_DIRS = DOTFILE_DIRS =
DOT_GRAPH_MAX_NODES = 50
# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width
# (in pixels) of the graphs generated by dot. If a graph becomes larger than
# this value, doxygen will try to truncate the graph, so that it fits within
# the specified constraint. Beware that most browsers cannot cope with very
# large images.
MAX_DOT_GRAPH_WIDTH = 1024
# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height
# (in pixels) of the graphs generated by dot. If a graph becomes larger than
# this value, doxygen will try to truncate the graph, so that it fits within
# the specified constraint. Beware that most browsers cannot cope with very
# large images.
MAX_DOT_GRAPH_HEIGHT = 1024
# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
# graphs generated by dot. A depth value of 3 means that only nodes reachable
# from the root by following a path via at most 3 edges will be shown. Nodes
# that lay further from the root node will be omitted. Note that setting this
# option to 1 or 2 may greatly reduce the computation time needed for large
# code bases. Also note that a graph may be further truncated if the graph's
# image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH
# and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default),
# the graph is not depth-constrained.
MAX_DOT_GRAPH_DEPTH = 0 MAX_DOT_GRAPH_DEPTH = 0
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, which results in a white background.
# Warning: Depending on the platform used, enabling this option may lead to
# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
# read).
DOT_TRANSPARENT = NO DOT_TRANSPARENT = NO
# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
# files in one run (i.e. multiple -o and -T options on the command line). This
# makes dot run faster, but since only newer versions of dot (>1.8.10)
# support this, this feature is disabled by default.
DOT_MULTI_TARGETS = NO DOT_MULTI_TARGETS = NO
# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
# generate a legend page explaining the meaning of the various boxes and
# arrows in the dot generated graphs.
GENERATE_LEGEND = YES GENERATE_LEGEND = YES
# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
# remove the intermediate dot files that are used to generate
# the various graphs.
DOT_CLEANUP = YES DOT_CLEANUP = YES
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# Configuration::additions related to the search engine # Configuration::additions related to the search engine
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# The SEARCHENGINE tag specifies whether or not a search engine should be
# used. If set to NO the values of all tags below this one will be ignored.
SEARCHENGINE = NO SEARCHENGINE = NO
common/basicframe.cpp
View file @ 3d73eb68
/******************************************************************/ /******************************************************************/
/* basicframe.cpp - fonctions des classes du type WinEDA_BasicFrame */ /* basicframe.cpp - fonctions des classes du type WinEDA_BasicFrame */
/******************************************************************/ /******************************************************************/
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation #pragma implementation
...@@ -12,51 +12,55 @@ ...@@ -12,51 +12,55 @@
#include "id.h" #include "id.h"
/*******************************************************/ /*******************************************************/
/* Constructeur de WinEDA_BasicFrame: la fenetre generale */ /* Constructeur de WinEDA_BasicFrame: la fenetre generale */
/*******************************************************/ /*******************************************************/
WinEDA_BasicFrame::WinEDA_BasicFrame( wxWindow * father, int idtype, WinEDA_BasicFrame::WinEDA_BasicFrame( wxWindow* father, int idtype,
WinEDA_App *parent, const wxString & title, WinEDA_App* parent, const wxString& title,
const wxPoint& pos, const wxSize& size, long style): const wxPoint& pos, const wxSize& size, long style ) :
wxFrame(father, -1, title, pos, size, style ) wxFrame( father, -1, title, pos, size, style )
{ {
wxSize minsize; wxSize minsize;
m_Ident = idtype; m_Ident = idtype;
m_Parent = parent; m_Parent = parent;
SetFont(*g_StdFont); SetFont( *g_StdFont );
m_MenuBar = NULL; // menu du haut d'ecran m_MenuBar = NULL; // menu du haut d'ecran
m_HToolBar = NULL; m_HToolBar = NULL;
m_FrameIsActive = TRUE; m_FrameIsActive = TRUE;
m_MsgFrameHeight = MSG_PANEL_DEFAULT_HEIGHT; m_MsgFrameHeight = MSG_PANEL_DEFAULT_HEIGHT;
minsize.x = 470; minsize.x = 470;
minsize.y = 350 + m_MsgFrameHeight; minsize.y = 350 + m_MsgFrameHeight;
SetSizeHints( minsize.x, minsize.y, -1,-1, -1,-1); SetSizeHints( minsize.x, minsize.y, -1, -1, -1, -1 );
/* Verification des parametres de creation */ /* Verification des parametres de creation */
if ( (size.x < minsize.x) || (size.y < minsize.y) ) if( (size.x < minsize.x) || (size.y < minsize.y) )
SetSize(0,0, minsize.x, minsize.y); SetSize( 0, 0, minsize.x, minsize.y );
// Create child subwindows. // Create child subwindows.
GetClientSize(&m_FrameSize.x, &m_FrameSize.y); /* dimx, dimy = dimensions utiles de la GetClientSize( &m_FrameSize.x, &m_FrameSize.y ); /* dimx, dimy = dimensions utiles de la
zone utilisateur de la fenetre principale */ * zone utilisateur de la fenetre principale */
m_FramePos.x = m_FramePos.y = 0; m_FramePos.x = m_FramePos.y = 0;
m_FrameSize.y -= m_MsgFrameHeight; m_FrameSize.y -= m_MsgFrameHeight;
} }
/******************************************/ /******************************************/
WinEDA_BasicFrame::~WinEDA_BasicFrame() WinEDA_BasicFrame::~WinEDA_BasicFrame()
/******************************************/ /******************************************/
{ {
if ( m_Parent->m_HtmlCtrl ) delete m_Parent->m_HtmlCtrl; if( m_Parent->m_HtmlCtrl )
m_Parent->m_HtmlCtrl = NULL; delete m_Parent->m_HtmlCtrl;
m_Parent->m_HtmlCtrl = NULL;
} }
/********************************************/ /********************************************/
void WinEDA_BasicFrame::ReCreateMenuBar() void WinEDA_BasicFrame::ReCreateMenuBar()
/********************************************/ /********************************************/
// Virtual function // Virtual function
{ {
} }
...@@ -66,29 +70,31 @@ void WinEDA_BasicFrame::ReCreateMenuBar() ...@@ -66,29 +70,31 @@ void WinEDA_BasicFrame::ReCreateMenuBar()
void WinEDA_BasicFrame::GetSettings() void WinEDA_BasicFrame::GetSettings()
/*********************************************/ /*********************************************/
{ {
wxString text; wxString text;
int Ypos_min; int Ypos_min;
if( m_Parent->m_EDA_Config ) if( m_Parent->m_EDA_Config )
{ {
text = m_FrameName + wxT("Pos_x"); text = m_FrameName + wxT( "Pos_x" );
m_Parent->m_EDA_Config->Read(text, &m_FramePos.x); m_Parent->m_EDA_Config->Read( text, &m_FramePos.x );
text = m_FrameName + wxT("Pos_y"); text = m_FrameName + wxT( "Pos_y" );
m_Parent->m_EDA_Config->Read(text, &m_FramePos.y); m_Parent->m_EDA_Config->Read( text, &m_FramePos.y );
text = m_FrameName + wxT("Size_x"); text = m_FrameName + wxT( "Size_x" );
m_Parent->m_EDA_Config->Read(text, &m_FrameSize.x, 600); m_Parent->m_EDA_Config->Read( text, &m_FrameSize.x, 600 );
text = m_FrameName + wxT("Size_y"); text = m_FrameName + wxT( "Size_y" );
m_Parent->m_EDA_Config->Read(text, &m_FrameSize.y, 400); m_Parent->m_EDA_Config->Read( text, &m_FrameSize.y, 400 );
} }
// Ensure Window title bar is visible // Ensure Window title bar is visible
#ifdef __WXMAC__ #ifdef __WXMAC__
// for macOSX, the window must be below system (macOSX) toolbar
Ypos_min = GetMBarHeight(); // for macOSX, the window must be below system (macOSX) toolbar
Ypos_min = GetMBarHeight();
#else #else
Ypos_min = 0; Ypos_min = 0;
#endif #endif
if ( m_FramePos.y < Ypos_min ) m_FramePos.y = Ypos_min; if( m_FramePos.y < Ypos_min )
m_FramePos.y = Ypos_min;
} }
...@@ -96,181 +102,191 @@ int Ypos_min; ...@@ -96,181 +102,191 @@ int Ypos_min;
void WinEDA_BasicFrame::SaveSettings() void WinEDA_BasicFrame::SaveSettings()
/*****************************************/ /*****************************************/
{ {
wxString text; wxString text;
if ( !m_Parent || !m_Parent->m_EDA_Config ) return; if( !m_Parent || !m_Parent->m_EDA_Config )
return;
if( ! m_Parent->m_EDA_Config || IsIconized() ) return; if( !m_Parent->m_EDA_Config || IsIconized() )
return;
m_FrameSize = GetSize(); m_FrameSize = GetSize();
m_FramePos = GetPosition(); m_FramePos = GetPosition();
text = m_FrameName + wxT("Pos_x"); text = m_FrameName + wxT( "Pos_x" );
m_Parent->m_EDA_Config->Write(text, (long)m_FramePos.x); m_Parent->m_EDA_Config->Write( text, (long) m_FramePos.x );
text = m_FrameName + wxT("Pos_y"); text = m_FrameName + wxT( "Pos_y" );
m_Parent->m_EDA_Config->Write(text, (long)m_FramePos.y); m_Parent->m_EDA_Config->Write( text, (long) m_FramePos.y );
text = m_FrameName + wxT("Size_x"); text = m_FrameName + wxT( "Size_x" );
m_Parent->m_EDA_Config->Write(text, (long)m_FrameSize.x); m_Parent->m_EDA_Config->Write( text, (long) m_FrameSize.x );
text = m_FrameName + wxT("Size_y"); text = m_FrameName + wxT( "Size_y" );
m_Parent->m_EDA_Config->Write(text, (long)m_FrameSize.y); m_Parent->m_EDA_Config->Write( text, (long) m_FrameSize.y );
} }
/******************************************************/ /******************************************************/
void WinEDA_BasicFrame::PrintMsg(const wxString & text) void WinEDA_BasicFrame::PrintMsg( const wxString& text )
/******************************************************/ /******************************************************/
{ {
SetStatusText(text); SetStatusText( text );
#ifdef DEBUG #ifdef DEBUG
printf("%s\n", (const char*)text.mb_str() ); printf( "%s\n", (const char*) text.mb_str() );
#endif #endif
} }
/*************************************************************************/ /*************************************************************************/
void WinEDA_BasicFrame::DisplayActivity(int PerCent, const wxString & Text) void WinEDA_BasicFrame::DisplayActivity( int PerCent, const wxString& Text )
/*************************************************************************/ /*************************************************************************/
/* Display a bargraph (0 to 50 point length) for a PerCent value from 0 to 100 /* Display a bargraph (0 to 50 point length) for a PerCent value from 0 to 100
*/ */
{ {
wxString Line; wxString Line;
Line = Text; Line = Text;
PerCent = (PerCent < 0) ? 0 : PerCent; PerCent = (PerCent < 0) ? 0 : PerCent;
PerCent = (PerCent > 100) ? 100 : PerCent; PerCent = (PerCent > 100) ? 100 : PerCent;
PerCent /= 2; // Bargraph is 0 .. 50 points from 0% to 100% PerCent /= 2; // Bargraph is 0 .. 50 points from 0% to 100%
if (PerCent) Line.Pad(PerCent, '*'); if( PerCent )
Line.Pad( PerCent, '*' );
SetStatusText(Line); SetStatusText( Line );
} }
/*******************************************************************/ /*******************************************************************/
void WinEDA_BasicFrame::SetLastProject(const wxString & FullFileName) void WinEDA_BasicFrame::SetLastProject( const wxString& FullFileName )
/*******************************************************************/ /*******************************************************************/
/* Met a jour la liste des anciens projets /* Met a jour la liste des anciens projets
*/ */
{ {
unsigned ii; unsigned ii;
if ( FullFileName.IsEmpty() ) return; if( FullFileName.IsEmpty() )
return;
//suppression d'une ancienne trace eventuelle du meme fichier //suppression d'une ancienne trace eventuelle du meme fichier
for ( ii = 0; ii < m_Parent->m_LastProject.GetCount(); ) for( ii = 0; ii < m_Parent->m_LastProject.GetCount(); )
{ {
if(m_Parent->m_LastProject[ii].IsEmpty() ) break; if( m_Parent->m_LastProject[ii].IsEmpty() )
break;
#ifdef __WINDOWS__ #ifdef __WINDOWS__
if ( m_Parent->m_LastProject[ii].CmpNoCase(FullFileName) == 0 ) if( m_Parent->m_LastProject[ii].CmpNoCase( FullFileName ) == 0 )
#else #else
if ( m_Parent->m_LastProject[ii] == FullFileName ) if( m_Parent->m_LastProject[ii] == FullFileName )
#endif #endif
{ {
#if ( (wxMAJOR_VERSION < 2) || ((wxMAJOR_VERSION == 2)&& (wxMINOR_VERSION <= 4)) ) #if ( ( wxMAJOR_VERSION < 2) || ( ( wxMAJOR_VERSION == 2)&& (wxMINOR_VERSION <= 4 ) ) )
m_Parent->m_LastProject.Remove(ii); m_Parent->m_LastProject.Remove( ii );
#else #else
m_Parent->m_LastProject.RemoveAt(ii); m_Parent->m_LastProject.RemoveAt( ii );
#endif #endif
} }
else ii++; else
} ii++;
}
while (m_Parent->m_LastProject.GetCount() >= m_Parent->m_LastProjectMaxCount) while( m_Parent->m_LastProject.GetCount() >= m_Parent->m_LastProjectMaxCount )
{ {
#if ( (wxMAJOR_VERSION < 2) || ((wxMAJOR_VERSION == 2)&& (wxMINOR_VERSION <= 4)) ) #if ( ( wxMAJOR_VERSION < 2) || ( ( wxMAJOR_VERSION == 2)&& (wxMINOR_VERSION <= 4 ) ) )
files.Remove(files.GetCount() - 1); files.Remove( files.GetCount() - 1 );
#else #else
m_Parent->m_LastProject.RemoveAt(m_Parent->m_LastProject.GetCount() - 1); m_Parent->m_LastProject.RemoveAt( m_Parent->m_LastProject.GetCount() - 1 );
#endif #endif
} }
m_Parent->m_LastProject.Insert(FullFileName, 0);
ReCreateMenuBar(); m_Parent->m_LastProject.Insert( FullFileName, 0 );
ReCreateMenuBar();
} }
/**************************************************/ /**************************************************/
wxString WinEDA_BasicFrame::GetLastProject(int rang) wxString WinEDA_BasicFrame::GetLastProject( int rang )
/**************************************************/ /**************************************************/
{ {
if ( rang < 0 ) rang = 0; if( rang < 0 )
if ( (unsigned) rang >= m_Parent->m_LastProject.GetCount() ) rang = 0;
return wxEmptyString; if( (unsigned) rang >= m_Parent->m_LastProject.GetCount() )
return m_Parent->m_LastProject[rang]; return wxEmptyString;
return m_Parent->m_LastProject[rang];
} }
/**************************************************************/ /**************************************************************/
void WinEDA_BasicFrame::GetKicadHelp(wxCommandEvent& event) void WinEDA_BasicFrame::GetKicadHelp( wxCommandEvent& event )
/**************************************************************/ /**************************************************************/
{ {
if ( m_Parent->m_HtmlCtrl == NULL ) if( m_Parent->m_HtmlCtrl == NULL )
{ {
m_Parent->InitOnLineHelp(); m_Parent->InitOnLineHelp();
} }
if ( m_Parent->m_HtmlCtrl ) if( m_Parent->m_HtmlCtrl )
{ {
m_Parent->m_HtmlCtrl->DisplayContents(); m_Parent->m_HtmlCtrl->DisplayContents();
m_Parent->m_HtmlCtrl->Display(m_Parent->m_HelpFileName); m_Parent->m_HtmlCtrl->Display( m_Parent->m_HelpFileName );
} }
else else
{ {
wxString msg; wxString msg;
msg.Printf( _("Help file %s not found"), m_Parent->m_HelpFileName.GetData() ); msg.Printf( _( "Help file %s not found" ), m_Parent->m_HelpFileName.GetData() );
DisplayError(this, msg); DisplayError( this, msg );
} }
} }
/***********************************************************/ /***********************************************************/
void WinEDA_BasicFrame::GetKicadAbout(wxCommandEvent& event) void WinEDA_BasicFrame::GetKicadAbout( wxCommandEvent& event )
/**********************************************************/ /**********************************************************/
{ {
Print_Kicad_Infos(this, m_AboutTitle); Print_Kicad_Infos( this, m_AboutTitle );
} }
/********************************************************************/ /********************************************************************/
void WinEDA_BasicFrame::ProcessFontPreferences(int id) void WinEDA_BasicFrame::ProcessFontPreferences( int id )
/********************************************************************/ /********************************************************************/
{ {
wxFont font; wxFont font;
switch (id) switch( id )
{ {
case ID_PREFERENCES_FONT:
case ID_PREFERENCES_FONT: break;
break;
case ID_PREFERENCES_FONT_STATUS:
case ID_PREFERENCES_FONT_STATUS: font = wxGetFontFromUser( this, *g_StdFont );
{ if( font.Ok() )
font = wxGetFontFromUser(this, *g_StdFont); {
if ( font.Ok() ) int pointsize = font.GetPointSize();
{ *g_StdFont = font;
int pointsize = font.GetPointSize(); SetFont( *g_StdFont );
*g_StdFont = font; if( GetStatusBar() )
SetFont(*g_StdFont); GetStatusBar()->SetFont( *g_StdFont );
if ( GetStatusBar() ) g_StdFontPointSize = pointsize;
GetStatusBar()->SetFont(*g_StdFont); }
g_StdFontPointSize = pointsize; break;
}
break; case ID_PREFERENCES_FONT_DIALOG:
} font = wxGetFontFromUser( this, *g_DialogFont );
if( font.Ok() )
case ID_PREFERENCES_FONT_DIALOG: {
{ int pointsize = font.GetPointSize();
font = wxGetFontFromUser(this, *g_DialogFont); *g_DialogFont = font;
if ( font.Ok() ) SetFont( *g_DialogFont );
{ g_DialogFontPointSize = pointsize;
int pointsize = font.GetPointSize(); g_FixedFontPointSize = pointsize;
*g_DialogFont = font; g_FixedFont->SetPointSize( g_FixedFontPointSize );
SetFont(*g_DialogFont); }
g_DialogFontPointSize = pointsize; break;
g_FixedFontPointSize = pointsize;
g_FixedFont->SetPointSize(g_FixedFontPointSize); default:
} DisplayError( this, wxT( "WinEDA_BasicFrame::ProcessFontPreferences Internal Error" ) );
break; break;
} }
default: DisplayError(this, wxT("WinEDA_BasicFrame::ProcessFontPreferences Internal Error") );
break;
}
} }
common/worksheet.cpp
View file @ 3d73eb68
/**************************************************/ /**************************************************/
/* WORKSHEET.CPP : routines de trace du cartouche */ /* WORKSHEET.CPP : routines de trace du cartouche */
/**************************************************/ /**************************************************/
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
...@@ -14,291 +14,314 @@ ...@@ -14,291 +14,314 @@
extern wxString g_Main_Title; extern wxString g_Main_Title;
/*************************************************************************************/ /*************************************************************************************/
void WinEDA_DrawFrame::TraceWorkSheet(wxDC * DC, BASE_SCREEN * screen, int line_width) void WinEDA_DrawFrame::TraceWorkSheet( wxDC* DC, BASE_SCREEN* screen, int line_width )
/*************************************************************************************/ /*************************************************************************************/
/* Draw the sheet references /* Draw the sheet references
*/ */
{ {
if ( ! m_Draw_Sheet_Ref ) return; if( !m_Draw_Sheet_Ref )
return;
Ki_PageDescr * Sheet = screen->m_CurrentSheetDesc;
int ii, jj, xg , yg, ipas, gxpas, gypas; Ki_PageDescr* Sheet = screen->m_CurrentSheetDesc;
wxPoint pos; int ii, jj, xg, yg, ipas, gxpas, gypas;
int refx, refy,Color; wxPoint pos;
wxString Line; int refx, refy, Color;
Ki_WorkSheetData * WsItem; wxString Line;
int scale = m_InternalUnits/1000; Ki_WorkSheetData* WsItem;
wxSize size(SIZETEXT*scale,SIZETEXT*scale); int scale = m_InternalUnits / 1000;
wxSize size_ref(SIZETEXT_REF*scale,SIZETEXT_REF*scale); wxSize size( SIZETEXT* scale, SIZETEXT* scale );
wxString msg; wxSize size_ref( SIZETEXT_REF* scale, SIZETEXT_REF* scale );
int UpperLimit = VARIABLE_BLOCK_START_POSITION;
int width = line_width; wxString msg;
int UpperLimit = VARIABLE_BLOCK_START_POSITION;
Color = RED; int width = line_width;
if(Sheet == NULL)
{ Color = RED;
DisplayError(this, if( Sheet == NULL )
wxT("WinEDA_DrawFrame::TraceWorkSheet() error: m_CurrentSheet NULL")); {
return; DisplayError( this,
} wxT( "WinEDA_DrawFrame::TraceWorkSheet() error: m_CurrentSheet NULL" ) );
return;
// if not printing, draw the page limits: }
if ( ! g_IsPrinting & g_ShowPageLimits )
{ // if not printing, draw the page limits:
GRSetDrawMode(DC, GR_COPY); if( !g_IsPrinting & g_ShowPageLimits )
GRRect(&DrawPanel->m_ClipBox, DC, 0, 0, {
Sheet->m_Size.x * scale, Sheet->m_Size.y * scale, width, GRSetDrawMode( DC, GR_COPY );
g_DrawBgColor == WHITE ? LIGHTGRAY : DARKDARKGRAY ); GRRect( &DrawPanel->m_ClipBox, DC, 0, 0,
} Sheet->m_Size.x * scale, Sheet->m_Size.y * scale, width,
g_DrawBgColor == WHITE ? LIGHTGRAY : DARKDARKGRAY );
GRSetDrawMode(DC, GR_COPY); }
/* trace de la bordure */
refx = Sheet->m_LeftMargin; GRSetDrawMode( DC, GR_COPY );
refy = Sheet->m_TopMargin; /* Upper left corner */ /* trace de la bordure */
xg = Sheet->m_Size.x - Sheet->m_RightMargin; refx = Sheet->m_LeftMargin;
yg = Sheet->m_Size.y - Sheet->m_BottomMargin; /* lower right corner */ refy = Sheet->m_TopMargin; /* Upper left corner */
xg = Sheet->m_Size.x - Sheet->m_RightMargin;
for ( ii = 0; ii < 2 ; ii++ ) yg = Sheet->m_Size.y - Sheet->m_BottomMargin; /* lower right corner */
{
GRRect(&DrawPanel->m_ClipBox, DC, refx * scale, refy * scale, for( ii = 0; ii < 2; ii++ )
xg * scale, yg * scale, width, Color); {
GRRect( &DrawPanel->m_ClipBox, DC, refx * scale, refy * scale,
refx += GRID_REF_W; refy += GRID_REF_W; xg * scale, yg * scale, width, Color );
xg -= GRID_REF_W; yg -= GRID_REF_W;
} refx += GRID_REF_W; refy += GRID_REF_W;
/* trace des reperes */ xg -= GRID_REF_W; yg -= GRID_REF_W;
refx = Sheet->m_LeftMargin; }
refy = Sheet->m_TopMargin; /* Upper left corner */
xg = Sheet->m_Size.x - Sheet->m_RightMargin; /* trace des reperes */
yg = Sheet->m_Size.y - Sheet->m_BottomMargin; /* lower right corner */ refx = Sheet->m_LeftMargin;
refy = Sheet->m_TopMargin; /* Upper left corner */
/* Trace des reperes selon l'axe X */ xg = Sheet->m_Size.x - Sheet->m_RightMargin;
ipas = (xg - refx) / PAS_REF; yg = Sheet->m_Size.y - Sheet->m_BottomMargin; /* lower right corner */
gxpas = ( xg - refx) / ipas;
for ( ii = refx + gxpas, jj = 1; ipas > 0 ; ii += gxpas , jj++, ipas--) /* Trace des reperes selon l'axe X */
{ ipas = (xg - refx) / PAS_REF;
Line.Printf( wxT("%d"),jj); gxpas = ( xg - refx) / ipas;
if( ii < xg - PAS_REF/2 ) for( ii = refx + gxpas, jj = 1; ipas > 0; ii += gxpas, jj++, ipas-- )
{ {
GRLine(&DrawPanel->m_ClipBox, DC, ii * scale, refy * scale, Line.Printf( wxT( "%d" ), jj );
ii * scale, (refy + GRID_REF_W) * scale, width, Color); if( ii < xg - PAS_REF / 2 )
} {
DrawGraphicText(DrawPanel, DC, GRLine( &DrawPanel->m_ClipBox, DC, ii * scale, refy * scale,
wxPoint( (ii - gxpas/2) * scale, (refy + GRID_REF_W/2) * scale), ii * scale, (refy + GRID_REF_W) * scale, width, Color );
Color, }
Line, TEXT_ORIENT_HORIZ, size_ref, DrawGraphicText( DrawPanel, DC,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, width); wxPoint( (ii - gxpas / 2) * scale, (refy + GRID_REF_W / 2) * scale ),
if( ii < xg - PAS_REF/2 ) Color,
{ Line, TEXT_ORIENT_HORIZ, size_ref,
GRLine(&DrawPanel->m_ClipBox, DC,ii * scale, yg * scale, GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, width );
ii * scale, (yg - GRID_REF_W) * scale, width, Color); if( ii < xg - PAS_REF / 2 )
} {
DrawGraphicText(DrawPanel, DC, GRLine( &DrawPanel->m_ClipBox, DC, ii * scale, yg * scale,
wxPoint( (ii - gxpas/2) * scale, (yg - GRID_REF_W/2) * scale), ii * scale, (yg - GRID_REF_W) * scale, width, Color );
Color, }
Line, TEXT_ORIENT_HORIZ, size_ref, DrawGraphicText( DrawPanel, DC,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, width); wxPoint( (ii - gxpas / 2) * scale, (yg - GRID_REF_W / 2) * scale ),
} Color,
Line, TEXT_ORIENT_HORIZ, size_ref,
/* Trace des reperes selon l'axe Y */ GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, width );
ipas = (yg - refy) / PAS_REF; }
gypas = ( yg - refy) / ipas;
for ( ii = refy + gypas, jj = 0; ipas > 0 ; ii += gypas , jj++, ipas--) /* Trace des reperes selon l'axe Y */
{ ipas = (yg - refy) / PAS_REF;
Line.Empty(); gypas = ( yg - refy) / ipas;
if( jj < 26 ) Line.Printf(wxT("%c"), jj + 'A'); for( ii = refy + gypas, jj = 0; ipas > 0; ii += gypas, jj++, ipas-- )
else Line.Printf(wxT("%c"), 'a' + jj - 26); {
if( ii < yg - PAS_REF/2 ) Line.Empty();
{ if( jj < 26 )
GRLine(&DrawPanel->m_ClipBox, DC, refx * scale, ii * scale, Line.Printf( wxT( "%c" ), jj + 'A' );
(refx + GRID_REF_W) * scale, ii * scale, width, Color); else
} Line.Printf( wxT( "%c" ), 'a' + jj - 26 );
DrawGraphicText(DrawPanel, DC, if( ii < yg - PAS_REF / 2 )
wxPoint((refx + GRID_REF_W/2) * scale, (ii - gypas/2) * scale), {
Color, GRLine( &DrawPanel->m_ClipBox, DC, refx * scale, ii * scale,
Line, TEXT_ORIENT_HORIZ, size_ref, (refx + GRID_REF_W) * scale, ii * scale, width, Color );
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, width); }
if( ii < yg - PAS_REF/2 ) DrawGraphicText( DrawPanel, DC,
{ wxPoint( (refx + GRID_REF_W / 2) * scale, (ii - gypas / 2) * scale ),
GRLine(&DrawPanel->m_ClipBox, DC, xg * scale, ii * scale, Color,
(xg - GRID_REF_W) * scale, ii * scale, width, Color); Line, TEXT_ORIENT_HORIZ, size_ref,
} GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, width );
DrawGraphicText(DrawPanel, DC, if( ii < yg - PAS_REF / 2 )
wxPoint((xg - GRID_REF_W/2) * scale, (ii - gxpas/2) * scale), {
Color, GRLine( &DrawPanel->m_ClipBox, DC, xg * scale, ii * scale,
Line, TEXT_ORIENT_HORIZ, size_ref, (xg - GRID_REF_W) * scale, ii * scale, width, Color );
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, width); }
} DrawGraphicText( DrawPanel, DC,
wxPoint( (xg - GRID_REF_W / 2) * scale, (ii - gxpas / 2) * scale ),
Color,
Line, TEXT_ORIENT_HORIZ, size_ref,
/* Trace du cartouche */ GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, width );
refx = Sheet->m_Size.x - Sheet->m_RightMargin - GRID_REF_W; }
refy = Sheet->m_Size.y - Sheet->m_BottomMargin - GRID_REF_W; /* lower right corner */
/* Trace du cartouche */
for( WsItem = &WS_Date; WsItem != NULL; WsItem = WsItem->Pnext ) refx = Sheet->m_Size.x - Sheet->m_RightMargin - GRID_REF_W;
{ refy = Sheet->m_Size.y - Sheet->m_BottomMargin - GRID_REF_W; /* lower right corner */
pos.x = (refx - WsItem->m_Posx)* scale;
pos.y = (refy - WsItem->m_Posy)* scale; for( WsItem = &WS_Date; WsItem != NULL; WsItem = WsItem->Pnext )
msg.Empty(); {
switch( WsItem->m_Type ) pos.x = (refx - WsItem->m_Posx) * scale;
{ pos.y = (refy - WsItem->m_Posy) * scale;
case WS_DATE: msg.Empty();
if(WsItem->m_Legende) msg = WsItem->m_Legende;
msg += screen->m_Date; switch( WsItem->m_Type )
DrawGraphicText(DrawPanel, DC, pos, Color, {
msg, TEXT_ORIENT_HORIZ, size, case WS_DATE:
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); if( WsItem->m_Legende )
break; msg = WsItem->m_Legende;
msg += screen->m_Date;
case WS_REV: DrawGraphicText( DrawPanel, DC, pos, Color,
if(WsItem->m_Legende) msg = WsItem->m_Legende; msg, TEXT_ORIENT_HORIZ, size,
msg += screen->m_Revision; GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
DrawGraphicText(DrawPanel, DC, pos, Color, break;
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); case WS_REV:
break; if( WsItem->m_Legende )
msg = WsItem->m_Legende;
case WS_KICAD_VERSION: msg += screen->m_Revision;
if(WsItem->m_Legende) msg = WsItem->m_Legende; DrawGraphicText( DrawPanel, DC, pos, Color,
msg += g_ProductName + g_Main_Title; msg, TEXT_ORIENT_HORIZ, size,
msg += wxT(" ") + GetBuildVersion(); GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
DrawGraphicText(DrawPanel, DC, pos, Color, break;
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); case WS_KICAD_VERSION:
break; if( WsItem->m_Legende )
msg = WsItem->m_Legende;
case WS_SIZESHEET: msg += g_ProductName + g_Main_Title;
if(WsItem->m_Legende) msg = WsItem->m_Legende; msg += wxT( " " ) + GetBuildVersion();
msg += Sheet->m_Name; DrawGraphicText( DrawPanel, DC, pos, Color,
DrawGraphicText(DrawPanel, DC, pos, Color, msg, TEXT_ORIENT_HORIZ, size,
msg, TEXT_ORIENT_HORIZ, size, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); break;
break;
case WS_SIZESHEET:
if( WsItem->m_Legende )
case WS_IDENTSHEET: msg = WsItem->m_Legende;
if(WsItem->m_Legende) msg = WsItem->m_Legende; msg += Sheet->m_Name;
msg << screen->m_ScreenNumber << wxT("/") << screen->m_NumberOfScreen; DrawGraphicText( DrawPanel, DC, pos, Color,
DrawGraphicText(DrawPanel, DC, pos, Color, msg, TEXT_ORIENT_HORIZ, size,
msg, TEXT_ORIENT_HORIZ, size, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); break;
break;
case WS_FILENAME: case WS_IDENTSHEET:
{ if( WsItem->m_Legende )
wxString fname, fext; msg = WsItem->m_Legende;
wxFileName::SplitPath(screen->m_FileName, (wxString*)NULL, &fname, &fext); msg << screen->m_ScreenNumber << wxT( "/" ) << screen->m_NumberOfScreen;
if(WsItem->m_Legende) msg = WsItem->m_Legende; DrawGraphicText( DrawPanel, DC, pos, Color,
msg << fname << wxT(".") << fext; msg, TEXT_ORIENT_HORIZ, size,
DrawGraphicText(DrawPanel, DC, pos, Color, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
msg, TEXT_ORIENT_HORIZ, size, break;
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width);
} case WS_FILENAME:
break; {
wxString fname, fext;
case WS_FULLSHEETNAME: wxFileName::SplitPath( screen->m_FileName, (wxString*) NULL, &fname, &fext );
if(WsItem->m_Legende) msg = WsItem->m_Legende; if( WsItem->m_Legende )
msg += GetScreenDesc(); msg = WsItem->m_Legende;
DrawGraphicText(DrawPanel, DC, pos, Color, msg << fname << wxT( "." ) << fext;
msg, TEXT_ORIENT_HORIZ, size, DrawGraphicText( DrawPanel, DC, pos, Color,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); msg, TEXT_ORIENT_HORIZ, size,
break; GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
}
break;
case WS_COMPANY_NAME:
if(WsItem->m_Legende) msg = WsItem->m_Legende; case WS_FULLSHEETNAME:
msg += screen->m_Company; if( WsItem->m_Legende )
if ( ! msg.IsEmpty() ) msg = WsItem->m_Legende;
{ msg += GetScreenDesc();
DrawGraphicText(DrawPanel, DC, pos, Color, DrawGraphicText( DrawPanel, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size, msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT); break;
}
break;
case WS_COMPANY_NAME:
case WS_TITLE: if( WsItem->m_Legende )
if(WsItem->m_Legende) msg = WsItem->m_Legende; msg = WsItem->m_Legende;
msg += screen->m_Title; msg += screen->m_Company;
DrawGraphicText(DrawPanel, DC, pos, Color, if( !msg.IsEmpty() )
msg, TEXT_ORIENT_HORIZ, size, {
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); DrawGraphicText( DrawPanel, DC, pos, Color,
break; msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
case WS_COMMENT1: UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
if(WsItem->m_Legende) msg = WsItem->m_Legende; }
msg += screen->m_Commentaire1; break;
if ( ! msg.IsEmpty() )
{ case WS_TITLE:
DrawGraphicText(DrawPanel, DC, pos, Color, if( WsItem->m_Legende )
msg, TEXT_ORIENT_HORIZ, size, msg = WsItem->m_Legende;
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); msg += screen->m_Title;
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT); DrawGraphicText( DrawPanel, DC, pos, Color,
} msg, TEXT_ORIENT_HORIZ, size,
break; GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
break;
case WS_COMMENT2:
if(WsItem->m_Legende) msg = WsItem->m_Legende; case WS_COMMENT1:
msg += screen->m_Commentaire2; if( WsItem->m_Legende )
if ( ! msg.IsEmpty() ) msg = WsItem->m_Legende;
{ msg += screen->m_Commentaire1;
DrawGraphicText(DrawPanel, DC, pos, Color, if( !msg.IsEmpty() )
msg, TEXT_ORIENT_HORIZ, size, {
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); DrawGraphicText( DrawPanel, DC, pos, Color,
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT); msg, TEXT_ORIENT_HORIZ, size,
} GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
break; UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
}
case WS_COMMENT3: break;
if(WsItem->m_Legende) msg = WsItem->m_Legende;
msg += screen->m_Commentaire3; case WS_COMMENT2:
if ( ! msg.IsEmpty() ) if( WsItem->m_Legende )
{ msg = WsItem->m_Legende;
DrawGraphicText(DrawPanel, DC, pos, Color, msg += screen->m_Commentaire2;
msg, TEXT_ORIENT_HORIZ, size, if( !msg.IsEmpty() )
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); {
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT); DrawGraphicText( DrawPanel, DC, pos, Color,
} msg, TEXT_ORIENT_HORIZ, size,
break; GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
case WS_COMMENT4: }
if(WsItem->m_Legende) msg = WsItem->m_Legende; break;
msg += screen->m_Commentaire4;
if ( ! msg.IsEmpty() ) case WS_COMMENT3:
{ if( WsItem->m_Legende )
DrawGraphicText(DrawPanel, DC, pos, Color, msg = WsItem->m_Legende;
msg, TEXT_ORIENT_HORIZ, size, msg += screen->m_Commentaire3;
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width); if( !msg.IsEmpty() )
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT); {
} DrawGraphicText( DrawPanel, DC, pos, Color,
break; msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
case WS_UPPER_SEGMENT: UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
if (UpperLimit == 0 ) break; }
case WS_LEFT_SEGMENT: break;
WS_MostUpperLine.m_Posy =
WS_MostUpperLine.m_Endy = case WS_COMMENT4:
WS_MostLeftLine.m_Posy = UpperLimit; if( WsItem->m_Legende )
pos.y = (refy - WsItem->m_Posy)* scale; msg = WsItem->m_Legende;
case WS_SEGMENT: msg += screen->m_Commentaire4;
xg = Sheet->m_Size.x - if( !msg.IsEmpty() )
GRID_REF_W - Sheet->m_RightMargin - WsItem->m_Endx; {
yg = Sheet->m_Size.y - DrawGraphicText( DrawPanel, DC, pos, Color,
GRID_REF_W - Sheet->m_BottomMargin - WsItem->m_Endy; msg, TEXT_ORIENT_HORIZ, size,
GRLine(&DrawPanel->m_ClipBox, DC, pos.x, pos.y, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, width );
xg * scale, yg * scale, width, Color); UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
break; }
break;
}
} case WS_UPPER_SEGMENT:
if( UpperLimit == 0 )
break;
case WS_LEFT_SEGMENT:
WS_MostUpperLine.m_Posy =
WS_MostUpperLine.m_Endy =
WS_MostLeftLine.m_Posy = UpperLimit;
pos.y = (refy - WsItem->m_Posy) * scale;
case WS_SEGMENT:
xg = Sheet->m_Size.x -
GRID_REF_W - Sheet->m_RightMargin - WsItem->m_Endx;
yg = Sheet->m_Size.y -
GRID_REF_W - Sheet->m_BottomMargin - WsItem->m_Endy;
GRLine( &DrawPanel->m_ClipBox, DC, pos.x, pos.y,
xg * scale, yg * scale, width, Color );
break;
}
}
} }
/*********************************************************************/ /*********************************************************************/
wxString WinEDA_DrawFrame::GetScreenDesc() wxString WinEDA_DrawFrame::GetScreenDesc()
/*********************************************************************/ /*********************************************************************/
{ {
wxString msg; wxString msg;
msg << GetScreen()->m_ScreenNumber << wxT("/") <<
GetScreen()->m_NumberOfScreen; msg << GetScreen()->m_ScreenNumber << wxT( "/" ) <<
return msg; GetScreen()->m_NumberOfScreen;
return msg;
} }
pcbnew/globaleditpad.cpp
View file @ 3d73eb68
/*************************/ /*************************/
/* Edition des Pastilles */ /* Edition des Pastilles */
/*************************/ /*************************/
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
...@@ -14,144 +14,157 @@ ...@@ -14,144 +14,157 @@
#include "protos.h" #include "protos.h"
/* Variables Locales */ /* Variables Locales */
static bool Pad_Shape_Filter = TRUE; static bool Pad_Shape_Filter = TRUE;
static bool Pad_Layer_Filter = TRUE; static bool Pad_Layer_Filter = TRUE;
static bool Pad_Orient_Filter = TRUE; static bool Pad_Orient_Filter = TRUE;
static bool Pad_Size_Change = TRUE; static bool Pad_Size_Change = TRUE;
static bool Pad_Shape_Change = FALSE; static bool Pad_Shape_Change = FALSE;
static bool Pad_Orient_Change = FALSE; static bool Pad_Orient_Change = FALSE;
static bool Pad_Drill_Change = TRUE; static bool Pad_Drill_Change = TRUE;
enum id_pad_global_edit enum id_pad_global_edit {
{ ID_CHANGE_CURRENT_MODULE = 1900,
ID_CHANGE_CURRENT_MODULE = 1900, ID_CHANGE_ID_MODULES,
ID_CHANGE_ID_MODULES, ID_CHANGE_GET_PAD_SETTINGS
ID_CHANGE_GET_PAD_SETTINGS
}; };
/************************************/ /************************************/
/* class WinEDA_PadGlobalEditFrame */ /* class WinEDA_PadGlobalEditFrame */
/************************************/ /************************************/
class WinEDA_PadGlobalEditFrame: public wxDialog class WinEDA_PadGlobalEditFrame : public wxDialog
{ {
private: private:
WinEDA_BasePcbFrame * m_Parent; WinEDA_BasePcbFrame* m_Parent;
wxDC * m_DC; wxDC* m_DC;
D_PAD * CurrentPad; D_PAD* CurrentPad;
wxCheckBox * m_Pad_Shape_Filter; wxCheckBox* m_Pad_Shape_Filter;
wxCheckBox * m_Pad_Layer_Filter; wxCheckBox* m_Pad_Layer_Filter;
wxCheckBox * m_Pad_Orient_Filter; wxCheckBox* m_Pad_Orient_Filter;
wxCheckBox * m_Pad_Size_Change; wxCheckBox* m_Pad_Size_Change;
wxCheckBox * m_Pad_Shape_Change; wxCheckBox* m_Pad_Shape_Change;
wxCheckBox * m_Pad_Drill_Change; wxCheckBox* m_Pad_Drill_Change;
wxCheckBox * m_Pad_Orient_Change; wxCheckBox* m_Pad_Orient_Change;
public: public:
// Constructor and destructor
WinEDA_PadGlobalEditFrame(WinEDA_BasePcbFrame *parent, // Constructor and destructor
D_PAD * Pad, wxDC * DC, const wxPoint & pos); WinEDA_PadGlobalEditFrame( WinEDA_BasePcbFrame * parent,
~WinEDA_PadGlobalEditFrame() { } D_PAD * Pad, wxDC * DC, const wxPoint &pos );
~WinEDA_PadGlobalEditFrame() { }
private: private:
void PadPropertiesAccept(wxCommandEvent& event); void PadPropertiesAccept( wxCommandEvent& event );
void OnCancelClick(wxCommandEvent& event); void OnCancelClick( wxCommandEvent& event );
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
}; };
BEGIN_EVENT_TABLE(WinEDA_PadGlobalEditFrame, wxDialog) BEGIN_EVENT_TABLE( WinEDA_PadGlobalEditFrame, wxDialog )
EVT_BUTTON(ID_CHANGE_CURRENT_MODULE, WinEDA_PadGlobalEditFrame::PadPropertiesAccept) EVT_BUTTON( ID_CHANGE_CURRENT_MODULE, WinEDA_PadGlobalEditFrame::PadPropertiesAccept )
EVT_BUTTON(ID_CHANGE_ID_MODULES, WinEDA_PadGlobalEditFrame::PadPropertiesAccept) EVT_BUTTON( ID_CHANGE_ID_MODULES, WinEDA_PadGlobalEditFrame::PadPropertiesAccept )
EVT_BUTTON(ID_CHANGE_GET_PAD_SETTINGS, WinEDA_PadGlobalEditFrame::PadPropertiesAccept) EVT_BUTTON( ID_CHANGE_GET_PAD_SETTINGS, WinEDA_PadGlobalEditFrame::PadPropertiesAccept )
EVT_BUTTON(wxID_CANCEL, WinEDA_PadGlobalEditFrame::OnCancelClick) EVT_BUTTON( wxID_CANCEL, WinEDA_PadGlobalEditFrame::OnCancelClick )
END_EVENT_TABLE() END_EVENT_TABLE()
/********************************************************************************/ /********************************************************************************/
WinEDA_PadGlobalEditFrame::WinEDA_PadGlobalEditFrame(WinEDA_BasePcbFrame *parent, WinEDA_PadGlobalEditFrame::WinEDA_PadGlobalEditFrame( WinEDA_BasePcbFrame* parent,
D_PAD * Pad,wxDC * DC, const wxPoint & framepos): D_PAD* Pad,
wxDialog(parent, -1, _("Pads Global Edit"), framepos, wxSize(310, 235), wxDC* DC,
DIALOG_STYLE) const wxPoint& framepos ) :
wxDialog( parent, -1, _( "Pads Global Edit" ), framepos, wxSize( 310, 235 ),
DIALOG_STYLE )
/********************************************************************************/ /********************************************************************************/
{ {
wxPoint pos; wxPoint pos;
wxButton * Button; wxButton* Button;
m_Parent = parent; m_Parent = parent;
SetFont(*g_DialogFont); SetFont( *g_DialogFont );
m_DC = DC; m_DC = DC;
Centre(); Centre();
CurrentPad = Pad; CurrentPad = Pad;
/* Creation des boutons de commande */ /* Creation des boutons de commande */
pos.x = 150; pos.x = 150;
pos.y = 10; pos.y = 10;
Button = new wxButton(this, ID_CHANGE_GET_PAD_SETTINGS, Button = new wxButton( this, ID_CHANGE_GET_PAD_SETTINGS,
_("Pad Settings..."), pos); _( "Pad Settings..." ), pos );
Button->SetForegroundColour( wxColor(0, 80, 0) );
Button->SetForegroundColour( wxColor( 0, 80, 0 ) );
pos.y += Button->GetDefaultSize().y + 50;
Button = new wxButton(this, ID_CHANGE_CURRENT_MODULE, pos.y += Button->GetDefaultSize().y + 50;
_("Change Module"), pos); Button = new wxButton( this, ID_CHANGE_CURRENT_MODULE,
Button->SetForegroundColour( *wxRED ); _( "Change Module" ), pos );
pos.y += Button->GetDefaultSize().y + 10; Button->SetForegroundColour( *wxRED );
Button = new wxButton(this, ID_CHANGE_ID_MODULES,
_("Change Id Modules"), pos); pos.y += Button->GetDefaultSize().y + 10;
Button->SetForegroundColour( *wxRED ); Button = new wxButton( this, ID_CHANGE_ID_MODULES,
_( "Change Id Modules" ), pos );
pos.y += Button->GetDefaultSize().y + 10;
Button = new wxButton(this, wxID_CANCEL, _("Cancel"), pos); Button->SetForegroundColour( *wxRED );
Button->SetForegroundColour( *wxBLUE );
pos.y += Button->GetDefaultSize().y + 10;
// Selection des filtres de selection des pads : Button = new wxButton( this, wxID_CANCEL, _( "Cancel" ), pos );
pos.x = 5;
pos.y = 5; Button->SetForegroundColour( *wxBLUE );
new wxStaticBox(this, -1, _("Pad Filter :"), pos, wxSize(130, 75) );
// Selection des filtres de selection des pads :
pos.x += 5; pos.x = 5;
pos.y += 18; pos.y = 5;
m_Pad_Shape_Filter = new wxCheckBox(this, -1, _("Shape Filter"), pos); new wxStaticBox( this, -1, _( "Pad Filter :" ), pos, wxSize( 130, 75 ) );
m_Pad_Shape_Filter->SetValue(Pad_Shape_Filter);
pos.x += 5;
pos.y += 18; pos.y += 18;
m_Pad_Layer_Filter = new wxCheckBox(this, -1, _("Layer Filter"), pos); m_Pad_Shape_Filter = new wxCheckBox( this, -1, _( "Shape Filter" ), pos );
m_Pad_Layer_Filter->SetValue(Pad_Layer_Filter);
m_Pad_Shape_Filter->SetValue( Pad_Shape_Filter );
pos.y += 18;
m_Pad_Orient_Filter = new wxCheckBox(this, -1, _("Orient Filter"), pos); pos.y += 18;
m_Pad_Orient_Filter->SetValue(Pad_Orient_Filter); m_Pad_Layer_Filter = new wxCheckBox( this, -1, _( "Layer Filter" ), pos );
// Items a editer m_Pad_Layer_Filter->SetValue( Pad_Layer_Filter );
pos.x -= 5;
pos.y += 25; pos.y += 18;
new wxStaticBox(this, -1, _("Change Items :"), pos, wxSize(130, 95) ); m_Pad_Orient_Filter = new wxCheckBox( this, -1, _( "Orient Filter" ), pos );
pos.x += 5; m_Pad_Orient_Filter->SetValue( Pad_Orient_Filter );
pos.y += 18;
m_Pad_Size_Change = new wxCheckBox(this, -1, _("Change Size"), pos); // Items a editer
m_Pad_Size_Change->SetValue(Pad_Size_Change); pos.x -= 5;
pos.y += 25;
pos.y += 18; new wxStaticBox( this, -1, _( "Change Items :" ), pos, wxSize( 130, 95 ) );
m_Pad_Shape_Change = new wxCheckBox(this, -1, _("Change Shape"), pos);
m_Pad_Shape_Change->SetValue(Pad_Shape_Change); pos.x += 5;
pos.y += 18;
pos.y += 18; m_Pad_Size_Change = new wxCheckBox( this, -1, _( "Change Size" ), pos );
m_Pad_Drill_Change = new wxCheckBox(this, -1, _("Change Drill"), pos);
m_Pad_Drill_Change->SetValue(Pad_Drill_Change); m_Pad_Size_Change->SetValue( Pad_Size_Change );
pos.y += 18; pos.y += 18;
m_Pad_Orient_Change = new wxCheckBox(this, -1, _("Change Orient"), pos); m_Pad_Shape_Change = new wxCheckBox( this, -1, _( "Change Shape" ), pos );
m_Pad_Orient_Change->SetValue(Pad_Orient_Change);
m_Pad_Shape_Change->SetValue( Pad_Shape_Change );
pos.y += 18;
m_Pad_Drill_Change = new wxCheckBox( this, -1, _( "Change Drill" ), pos );
m_Pad_Drill_Change->SetValue( Pad_Drill_Change );
pos.y += 18;
m_Pad_Orient_Change = new wxCheckBox( this, -1, _( "Change Orient" ), pos );
m_Pad_Orient_Change->SetValue( Pad_Orient_Change );
} }
/**********************************************************************/ /**********************************************************************/
void WinEDA_PadGlobalEditFrame::OnCancelClick(wxCommandEvent& WXUNUSED(event)) void WinEDA_PadGlobalEditFrame::OnCancelClick( wxCommandEvent& WXUNUSED (event) )
/**********************************************************************/ /**********************************************************************/
{ {
EndModal( -1 ); EndModal( -1 );
...@@ -159,40 +172,43 @@ void WinEDA_PadGlobalEditFrame::OnCancelClick(wxCommandEvent& WXUNUSED(event)) ...@@ -159,40 +172,43 @@ void WinEDA_PadGlobalEditFrame::OnCancelClick(wxCommandEvent& WXUNUSED(event))
/*************************************************************************/ /*************************************************************************/
void WinEDA_PadGlobalEditFrame::PadPropertiesAccept(wxCommandEvent& event) void WinEDA_PadGlobalEditFrame::PadPropertiesAccept( wxCommandEvent& event )
/*************************************************************************/ /*************************************************************************/
/* Met a jour les differents parametres pour le composant en cours d'dition /* Met a jour les differents parametres pour le composant en cours d'dition
*/ */
{ {
int returncode = 0; int returncode = 0;
switch( event.GetId() ) switch( event.GetId() )
{ {
case ID_CHANGE_GET_PAD_SETTINGS: case ID_CHANGE_GET_PAD_SETTINGS:
m_Parent->InstallPadOptionsFrame( NULL, NULL, wxPoint(-1, -1) ); m_Parent->InstallPadOptionsFrame( NULL, NULL, wxPoint( -1, -1 ) );
break; break;
case ID_CHANGE_ID_MODULES: case ID_CHANGE_ID_MODULES:
returncode = 1; returncode = 1;
// Fall through
// Fall through
case ID_CHANGE_CURRENT_MODULE:
Pad_Shape_Filter = m_Pad_Shape_Filter->GetValue(); case ID_CHANGE_CURRENT_MODULE:
Pad_Layer_Filter = m_Pad_Layer_Filter->GetValue(); Pad_Shape_Filter = m_Pad_Shape_Filter->GetValue();
Pad_Orient_Filter = m_Pad_Orient_Filter->GetValue(); Pad_Layer_Filter = m_Pad_Layer_Filter->GetValue();
Pad_Size_Change = m_Pad_Size_Change->GetValue(); Pad_Orient_Filter = m_Pad_Orient_Filter->GetValue();
Pad_Shape_Change = m_Pad_Shape_Change->GetValue(); Pad_Size_Change = m_Pad_Size_Change->GetValue();
Pad_Drill_Change = m_Pad_Drill_Change->GetValue(); Pad_Shape_Change = m_Pad_Shape_Change->GetValue();
Pad_Orient_Change = m_Pad_Orient_Change->GetValue(); Pad_Drill_Change = m_Pad_Drill_Change->GetValue();
EndModal( returncode ); Pad_Orient_Change = m_Pad_Orient_Change->GetValue();
break; EndModal( returncode );
} break;
}
} }
/***************************************************************************/ /***************************************************************************/
void WinEDA_BasePcbFrame::Global_Import_Pad_Settings( D_PAD * Pad, wxDC * DC) void WinEDA_BasePcbFrame::Global_Import_Pad_Settings( D_PAD* Pad, wxDC* DC )
/***************************************************************************/ /***************************************************************************/
/* /*
* Routine de selection et de correction des dimensions des pastilles * Routine de selection et de correction des dimensions des pastilles
* de tous les modules * de tous les modules
...@@ -201,132 +217,136 @@ void WinEDA_BasePcbFrame::Global_Import_Pad_Settings( D_PAD * Pad, wxDC * DC) ...@@ -201,132 +217,136 @@ void WinEDA_BasePcbFrame::Global_Import_Pad_Settings( D_PAD * Pad, wxDC * DC)
* - ou sur l'module localisee, selon le menu d'appel * - ou sur l'module localisee, selon le menu d'appel
*/ */
{ {
D_PAD* pt_pad ; D_PAD* pt_pad;
MODULE * Module_Ref , * Module; MODULE* Module_Ref, * Module;
int diag; int diag;
bool Edit_Same_Modules = FALSE; bool Edit_Same_Modules = FALSE;
if( Pad == NULL ) if( Pad == NULL )
return; return;
Module = (MODULE *) Pad->m_Parent; Module = (MODULE*) Pad->m_Parent;
if( Module == NULL ) if( Module == NULL )
{ {
DisplayError(this, wxT("Global_Import_Pad_Settings() Error: NULL module")); DisplayError( this, wxT( "Global_Import_Pad_Settings() Error: NULL module" ) );
return; return;
} }
wxString ref_name_module = Module->m_LibRef; wxString ref_name_module = Module->m_LibRef;
Module->Display_Infos(this); Module->Display_Infos( this );
WinEDA_PadGlobalEditFrame * frame = new WinEDA_PadGlobalEditFrame(this, Pad,DC, WinEDA_PadGlobalEditFrame* frame = new WinEDA_PadGlobalEditFrame( this, Pad, DC,
wxPoint(-1,-1)); wxPoint( -1, -1 ) );
diag = frame->ShowModal();
frame->Destroy(); diag = frame->ShowModal();
frame->Destroy();
if( diag == -1 )
return; if( diag == -1 )
if( diag == 1 ) return;
Edit_Same_Modules = TRUE; if( diag == 1 )
Edit_Same_Modules = TRUE;
/* Recherche et copie du nom librairie de reference: */
Module_Ref = Module; /* Recherche et copie du nom librairie de reference: */
Module_Ref = Module;
/* Mise a jour des modules ou du module */
/* Mise a jour des modules ou du module */
Module = (MODULE*) m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext ) Module = (MODULE*) m_Pcb->m_Modules;
{ for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
if( ! Edit_Same_Modules ) {
if( Module != Module_Ref ) if( !Edit_Same_Modules )
continue; if( Module != Module_Ref )
continue;
if( ref_name_module != Module->m_LibRef )
continue ; if( ref_name_module != Module->m_LibRef )
continue;
Module->Display_Infos(this);
Module->Display_Infos( this );
/* Effacement du module */
Module->Draw(DrawPanel, DC, wxPoint(0, 0), GR_XOR); /* Effacement du module */
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
pt_pad = (D_PAD*) Module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext ) pt_pad = (D_PAD*) Module->m_Pads;
{ for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
/* Filtrage des modifications interdites */ {
if( Pad_Shape_Filter ) /* Filtrage des modifications interdites */
{ if( Pad_Shape_Filter )
if( pt_pad->m_PadShape != g_Pad_Master.m_PadShape ) {
continue; if( pt_pad->m_PadShape != g_Pad_Master.m_PadShape )
} continue;
}
if( Pad_Orient_Filter )
{ if( Pad_Orient_Filter )
if( (pt_pad->m_Orient - Module->m_Orient) != g_Pad_Master.m_Orient ) {
continue; if( (pt_pad->m_Orient - Module->m_Orient) != g_Pad_Master.m_Orient )
} continue;
}
if( Pad_Layer_Filter )
{ if( Pad_Layer_Filter )
if( pt_pad->m_Masque_Layer != g_Pad_Master.m_Masque_Layer ) {
continue; if( pt_pad->m_Masque_Layer != g_Pad_Master.m_Masque_Layer )
else continue;
m_Pcb->m_Status_Pcb &= ~( LISTE_CHEVELU_OK | CONNEXION_OK); else
} m_Pcb->m_Status_Pcb &= ~( LISTE_CHEVELU_OK | CONNEXION_OK);
}
/* Modif des caracteristiques: */
if( Pad_Shape_Change ) /* Modif des caracteristiques: */
{ if( Pad_Shape_Change )
pt_pad->m_Attribut = g_Pad_Master.m_Attribut; {
pt_pad->m_PadShape = g_Pad_Master.m_PadShape; pt_pad->m_Attribut = g_Pad_Master.m_Attribut;
} pt_pad->m_PadShape = g_Pad_Master.m_PadShape;
}
pt_pad->m_Masque_Layer = g_Pad_Master.m_Masque_Layer;
pt_pad->m_Masque_Layer = g_Pad_Master.m_Masque_Layer;
if( Pad_Size_Change )
{ if( Pad_Size_Change )
pt_pad->m_Size = g_Pad_Master.m_Size; {
pt_pad->m_DeltaSize = g_Pad_Master.m_DeltaSize; pt_pad->m_Size = g_Pad_Master.m_Size;
pt_pad->m_Offset = g_Pad_Master.m_Offset; pt_pad->m_DeltaSize = g_Pad_Master.m_DeltaSize;
} pt_pad->m_Offset = g_Pad_Master.m_Offset;
}
if( Pad_Drill_Change )
{ if( Pad_Drill_Change )
pt_pad->m_Drill = g_Pad_Master.m_Drill; {
pt_pad->m_DrillShape = g_Pad_Master.m_DrillShape; pt_pad->m_Drill = g_Pad_Master.m_Drill;
} pt_pad->m_DrillShape = g_Pad_Master.m_DrillShape;
}
if( Pad_Orient_Change )
{ if( Pad_Orient_Change )
pt_pad->m_Orient = g_Pad_Master.m_Orient + Module->m_Orient; {
} pt_pad->m_Orient = g_Pad_Master.m_Orient + Module->m_Orient;
}
/* Traitement des cas particuliers : */
if( g_Pad_Master.m_PadShape != PAD_TRAPEZOID ) /* Traitement des cas particuliers : */
{ if( g_Pad_Master.m_PadShape != PAD_TRAPEZOID )
pt_pad->m_DeltaSize.x = 0; {
pt_pad->m_DeltaSize.y = 0; pt_pad->m_DeltaSize.x = 0;
} pt_pad->m_DeltaSize.y = 0;
if( g_Pad_Master.m_PadShape == PAD_CIRCLE ) }
pt_pad->m_Size.y = pt_pad->m_Size.x; if( g_Pad_Master.m_PadShape == PAD_CIRCLE )
pt_pad->m_Size.y = pt_pad->m_Size.x;
switch( g_Pad_Master.m_Attribut & 0x7F )
{ switch( g_Pad_Master.m_Attribut & 0x7F )
case PAD_SMD: {
case PAD_CONN: case PAD_SMD:
pt_pad->m_Drill = wxSize(0, 0); case PAD_CONN:
pt_pad->m_Offset.x = 0; pt_pad->m_Drill = wxSize( 0, 0 );
pt_pad->m_Offset.y = 0; pt_pad->m_Offset.x = 0;
break; pt_pad->m_Offset.y = 0;
break;
default:
break; default:
} break;
pt_pad->ComputeRayon(); }
}
Module->Set_Rectangle_Encadrement(); pt_pad->ComputeRayon();
Module->Draw(DrawPanel, DC, wxPoint(0, 0), GR_OR); }
}
GetScreen()->SetModify(); Module->Set_Rectangle_Encadrement();
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
}
GetScreen()->SetModify();
} }
pcbnew/ioascii.cpp
View file @ 3d73eb68
...@@ -309,7 +309,7 @@ int WinEDA_BasePcbFrame::ReadSetup( FILE* File, int* LineNum ) ...@@ -309,7 +309,7 @@ int WinEDA_BasePcbFrame::ReadSetup( FILE* File, int* LineNum )
if( strncmp( Line, "Layer[", LAYERKEYZ ) == 0 ) if( strncmp( Line, "Layer[", LAYERKEYZ ) == 0 )
{ {
// parse: // parse:
// Layer[n] "a Layer name" <LAYER_T> // Layer[n] <a_Layer_name_with_no_spaces> <LAYER_T>
char* cp = Line + LAYERKEYZ; char* cp = Line + LAYERKEYZ;
int layer = atoi(cp); int layer = atoi(cp);
...@@ -320,7 +320,6 @@ int WinEDA_BasePcbFrame::ReadSetup( FILE* File, int* LineNum ) ...@@ -320,7 +320,6 @@ int WinEDA_BasePcbFrame::ReadSetup( FILE* File, int* LineNum )
m_Pcb->SetLayerName( layer, layerName ); m_Pcb->SetLayerName( layer, layerName );
data = strtok( NULL, " " ); data = strtok( NULL, " " );
if( data ) if( data )
{ {
LAYER_T type = LAYER::ParseType( data ); LAYER_T type = LAYER::ParseType( data );
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment