HYTOS

        """constructor"""

    def getSymbolCategoryByType(self, type: str):

        """get symbol category by using symbol type"""

class SymbolMappingDelegate(QStyledItemDelegate):

    def __init__(self, symbol_types: list, parent=None):

        QStyledItemDelegate.__init__(self, parent)

        self._symbol_types = symbol_types

    def createEditor(self, parent, option, index):

        """create a editor for symbol mapping"""

        editor = None

        item = index.model().itemFromIndex(index)

        if item.parent() and not item.parent().parent():

            if index.column() == 1:

                editor = QComboBox(parent)

                editor.addItems(self._symbol_types if self._symbol_types else [''])

        return editor if editor else super(SymbolMappingDelegate, self).createEditor(parent, option, index)

class SymbolMappingModel(QStandardItemModel):

    """This is SymbolMapping Model class"""

    def __init__(self):

        """constructor"""

        QStandardItemModel.__init__(self)

        self._autocad_symbols = []  # holder for autocad symbol

        project = AppDocData.instance().getCurrentProject()

        if project is not None:

            self.clear()

            self.load_symbol_info()

            # load and display symbol mapping

            app_doc_data = AppDocData.instance()

            configs = app_doc_data.getConfigs(section='Symbol Mapping')

            for row in range(self.rowCount()):

                category_index = self.index(row, 0)

                child_count = self.rowCount(category_index)

                for child_row in range(child_count):

                    child_index = self.index(child_row, 0, category_index)

                    id2_symbol_item = self.itemFromIndex(child_index)

                    id2_symbol_uid = id2_symbol_item.data(Qt.UserRole)

                    matches = [config for config in configs if config.key == str(id2_symbol_uid)]

                    for match in matches:

                        symbols = match.value.split(',')

                        for symbol in symbols:

                            if symbol not in self._autocad_symbols:

                                self._autocad_symbols.append(symbol)

                            childs = [QStandardItem(''), QStandardItem(symbol), QStandardItem('')]

                            childs[0].setData(id2_symbol_uid, Qt.UserRole)

                            for child in childs:

                                child.setEditable(False)

                            id2_symbol_item.appendRow(childs)

            headers = [QStandardItem("ID2 Symbol"), QStandardItem("AutoCAD Symbol"), QStandardItem('')]

            for idx, header in enumerate(headers):

                header.setTextAlignment(Qt.AlignCenter)

                self.setHorizontalHeaderItem(idx, header)

    def load_symbol_info(self):

        """load symbol information and display it on tree view"""

        try:

            app_doc_data = AppDocData.instance()

            symbolTypeList = app_doc_data.getSymbolTypeList()

            for row, symbolType in enumerate(symbolTypeList):

                items = [QStandardItem(symbolType[2]), QStandardItem(''), QStandardItem('')]

                items[0].setData(symbolType, Qt.UserRole)

                items[0].setEditable(False)

                items[0].setSelectable(False)

                items[1].setEditable(False)

                items[1].setSelectable(False)

                items[2].setEditable(False)

                items[2].setSelectable(False)

                symbolList = app_doc_data.getSymbolListByType('UID', symbolType[0])

                for symbol in symbolList:

                    childs = [QStandardItem(symbol.getName()), QStandardItem(''), QStandardItem('')]

                    childs[0].setData(symbol.getUid(), Qt.UserRole)

                    childs[0].setEditable(False)

                    _, svg = app_doc_data.read_symbol_shape(symbol.sName)

                    if svg:

                        symbol.pixmap = QPixmap()

                        symbol.pixmap.loadFromData(svg if isinstance(svg, bytes) else svg.encode())

                        icon = QIcon(symbol.pixmap)

                        childs[0].setIcon(icon)

                        childs[0].svgFilePath = None  # save svg file path

                    else:

                        svgPath = symbol.getSvgFileFullPath()

                        symbol.pixmap = QPixmap(svgPath)

                        icon = QIcon(symbol.pixmap)

                        childs[0].setIcon(icon)

                        childs[0].svgFilePath = svgPath  # save svg file path

                    items[0].appendRow(childs)

                items[0].sortChildren(0, Qt.AscendingOrder)

                self.appendRow(items)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f'error occurred({ex}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:' \

                      f'{sys.exc_info()[-1].tb_lineno}'

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    @property

    def autocad_symbols(self):

        """property of autocad symbol"""

        return self._autocad_symbols

        """constructor"""

        self._symbol_types = []

        self.on_load_symbol_mapping()

        self.ui.pushButtonSave.clicked.connect(self.on_save_mappings)

            """add AutoCAD line type corresponding to ID2 line type"""

            try:

                _index = self.ui.treeViewLineType.model().index(index.row(), 1)

                autocad_line_type_item = self.ui.treeViewLineType.model().itemFromIndex(_index)

                if autocad_line_type_item and autocad_line_type_item.text():

                    _index = self.ui.treeViewLineType.model().index(index.row(), 0, index.parent())

                    id2_line_type_item = self.ui.treeViewLineType.model().itemFromIndex(_index)

                    items = [QStandardItem(''), QStandardItem(autocad_line_type_item.text()), QStandardItem('')]

                    items[0].setData(id2_line_type_item.text(), Qt.UserRole)

                    for item in items:

                        item.setEditable(False)

                    id2_line_type_item.appendRow(items)

                    ## add remove button

                    child_count = self.ui.treeViewLineType.model().rowCount(id2_line_type_item.index())

                    button = QPushButton(icon=QIcon(":/newPrefix/Remove.svg"))

                    button.setMaximumWidth(20)

                    button.clicked.connect(on_remove_treeview_item)

                    _index = self.ui.treeViewLineType.model().index(child_count - 1, 2, id2_line_type_item.index())

                    self.ui.treeViewLineType.setIndexWidget(_index, button)

                    self.ui.treeViewLineType.expandAll()

            except Exception as ex:

                from App import App

                from AppDocData import MessageType

                message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                          f"{sys.exc_info()[-1].tb_lineno}"

                QMessageBox.warning(self, self._tr('Warning'), message)

    def on_load_symbol_mapping(self):

        """load symbol mapping setting"""

        def on_remove_symbol_mapping_item():

            """remove selected items"""

            indices = self.ui.treeViewSymbolMapping.selectionModel().selectedRows()

            for index in sorted(indices):

                self.ui.treeViewSymbolMapping.model().removeRow(index.row(), index.parent())

        def on_add_symbol_type_item(index: QModelIndex):

            """map AutoCAD symbol and ID2 symbol"""

            try:

                _index = self.ui.treeViewSymbolMapping.model().index(index.row(), 1, index.parent())

                autocad_symbol_item = self.ui.treeViewSymbolMapping.model().itemFromIndex(_index)

                if autocad_symbol_item and autocad_symbol_item.text():

                    _index = self.ui.treeViewSymbolMapping.model().index(index.row(), 0, index.parent())

                    id2_symbol_item = self.ui.treeViewSymbolMapping.model().itemFromIndex(_index)

                    items = [QStandardItem(''), QStandardItem(autocad_symbol_item.text()), QStandardItem('')]

                    items[0].setData(id2_symbol_item.data(Qt.UserRole), Qt.UserRole)

                    for item in items:

                        item.setEditable(False)

                    id2_symbol_item.appendRow(items)

                    ## add remove button

                    child_count = self.ui.treeViewSymbolMapping.model().rowCount(id2_symbol_item.index())

                    button = QPushButton(icon=QIcon(":/newPrefix/Remove.svg"))

                    button.setMaximumWidth(20)

                    button.clicked.connect(on_remove_symbol_mapping_item)

                    _index = self.ui.treeViewSymbolMapping.model().index(child_count - 1, 2, id2_symbol_item.index())

                    self.ui.treeViewSymbolMapping.setIndexWidget(_index, button)

                    self.ui.treeViewSymbolMapping.expandAll()

            except Exception as ex:

                from App import App

                from AppDocData import MessageType

                message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                          f"{sys.exc_info()[-1].tb_lineno}"

                QMessageBox.warning(self, 'Warning', message)

        model = SymbolMappingModel()

        model.invisibleRootItem()

        self.ui.treeViewSymbolMapping.setModel(model)

        for row in range(model.rowCount()):

            parent_index = model.index(row, 0)

            child_count = model.rowCount(parent_index)

            for child_row in range(child_count):

                button = QPushButton(icon=QIcon(":/newPrefix/Add.svg"))

                button.setMaximumWidth(20)

                index = self.ui.treeViewSymbolMapping.model().index(child_row, 2, parent_index)

                button.clicked.connect(partial(on_add_symbol_type_item, index))

                self.ui.treeViewSymbolMapping.setIndexWidget(index, button)

        self.ui.treeViewSymbolMapping.resizeColumnToContents(0)

        self.ui.treeViewSymbolMapping.resizeColumnToContents(1)

        self.ui.treeViewSymbolMapping.resizeColumnToContents(2)

        self.ui.treeViewSymbolMapping.expandAll()

        self._symbol_types = model.autocad_symbols[:]

        self.ui.treeViewSymbolMapping.setItemDelegate(SymbolMappingDelegate(self._symbol_types,

                                                                            self.ui.treeViewSymbolMapping))

        """extract information from select autocad files"""

            self._symbol_types.clear()

            for _file in files:

                if os.path.exists(_file):

                        file = os.path.normpath(_file)

                        for block_ref_record in autocad_xml_root.iter('AcDbBlockReference'):

                            block_name = block_ref_record.attrib['Name']

                            if block_name in self._symbol_types:

                                continue

                            self._symbol_types.append(block_name)

    def on_save_mappings(self):

        """save line type and symbol mappings"""

        # save symbol mappings

        model = self.ui.treeViewSymbolMapping.model()

        for row in range(model.rowCount()):

            category_index = model.index(row, 0)

            child_count = model.rowCount(category_index)

            for child_row in range(child_count):

                autocad_symbols = []

                child_index = model.index(child_row, 0, category_index)

                id2_symbol_item = model.itemFromIndex(child_index)

                id2_symbol_uid = id2_symbol_item.data(Qt.UserRole)

                id2_symbol = id2_symbol_item.text()

                mapping_count = model.rowCount(child_index)

                for mapping_row in range(mapping_count):

                    mapping_index = model.index(mapping_row, 1, child_index)

                    autocad_symbols.append(model.itemFromIndex(mapping_index).text())

                if autocad_symbols:

                    configs.append(Config('Symbol Mapping', id2_symbol_uid, ','.join(autocad_symbols)))

        """import line, text and symbol from autocad"""

        if not self._dwgs:

            QMessageBox.information(self, self.tr('Information'), self.tr('There is no selected file(s)'))

            return

        app_doc_data = AppDocData.instance()

        project = app_doc_data.getCurrentProject()

        mapping_configs = app_doc_data.getConfigs(section='Symbol Mapping')

                    layers, line_types, symbols = [], [], []

                    """parse layer, line type and symbol"""

                    for blk_ref_record in autocad_xml_root.iter('AcDbBlockReference'):

                        blk_ref_handle = blk_ref_record.attrib['Handle']

                        blk_ref_name = blk_ref_record.attrib['Name']

                        symbols.append([blk_ref_handle, blk_ref_name])

                    symbols_node = id2_xml_root.find(xg.SYMBOL_LIST_NODE_NAME)

                    if symbols_node:

                        symbols = symbols_node.findall('SYMBOL')

                        # remove only converted symbol nodes

                        for symbol in symbols:

                            if 'Converted' in symbol.attrib and symbol.attrib['Converted'] == str(True):

                                symbols_node.remove(symbol)

                            node = self.symbol_to_xml(blk_ref, id2_bbox, autocad_bbox, mapping_configs)

                            if node:

                                symbols_node.append(node)

    def symbol_to_xml(self, blk_ref_node, id2_bbox, autocad_bbox, mapping_configs: list) -> str:

        """try to convert block reference element to id2 xml"""

        import uuid

        from SymbolSvgItem import SymbolSvgItem

        def convert_to_image_coords(pt, scale: float, offset: list):

            """convert autocad coordinates to image coordinates"""

            return [pt[0] * scale + offset[0], -pt[1] * scale + offset[1]]

        try:

            scale = max([id2_bbox[2] / autocad_bbox[2], id2_bbox[3] / autocad_bbox[3]])

            offsets = [id2_bbox[0] - autocad_bbox[0] * scale, (id2_bbox[1] + id2_bbox[3]) - autocad_bbox[1] * scale]

            name = blk_ref_node.attrib['Name']

            origin = convert_to_image_coords((float(blk_ref_node.attrib['X']), float(blk_ref_node.attrib['Y'])),

                                             scale, offsets)

            angle = round(float(blk_ref_node.attrib['Angle']), 2)

            min_extents, max_extents = None, None

            tokens = blk_ref_node.attrib['MaxExtents'].strip('()').split(',')

            if 3 == len(tokens):

                max_extents = convert_to_image_coords((float(tokens[0]), float(tokens[1])), scale, offsets)

            tokens = blk_ref_node.attrib['MinExtents'].strip('()').split(',')

            if 3 == len(tokens):

                min_extents = convert_to_image_coords((float(tokens[0]), float(tokens[1])), scale, offsets)

            _height = abs(max_extents[1] - min_extents[1])

            _width = abs(max_extents[0] - min_extents[0])

            allowed_error = 0.01

            if abs(angle - 1.57) < allowed_error:

                _height, _width = _width, _height

                origin[0], origin[1] = origin[0] - _width, origin[1] - _height + _width

            elif abs(angle - 4.71) < allowed_error:

                _height, _width = _width, _height

                origin[0], origin[1] = origin[0] - _width, origin[1] + _height - _width

            uid = None

            for config in mapping_configs:

                if name in config.value.split(','):

                    uid = config.key

                    break

            if uid:

                app_doc_data = AppDocData.instance()

                symbol = app_doc_data.getSymbolByQuery('UID', uid)

                svg_file_path = os.path.join(app_doc_data.getCurrentProject().getSvgFilePath(), symbol.getType(),

                                             symbol.getName() + '.svg')

                item = SymbolSvgItem.createItem(symbol.getType(), symbol.getName(), path=svg_file_path)

                loc = [min(min_extents[0], max_extents[0]), min(min_extents[1], max_extents[1])]

                item.buildItem(name, symbol.getType(), angle, loc, (_width, _height), origin, connPts=None,

                               parentSymbol=None, childSymbol=None, hasInstrumentLabel=False, dbUid=uid)

                item.converted = True

                app_doc_data = AppDocData.instance()

                for area in app_doc_data.getAreaList():

                    if area.contains([origin[0], origin[1]]):

                        item.area = area.name

                        break

                return item.toXml()

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        return None

# Form implementation generated from reading ui file '.\UI\ImportTextFromCAD.ui'

# Created by: PyQt5 UI code generator 5.15.2

# WARNING: Any manual changes made to this file will be lost when pyuic5 is

# run again.  Do not edit this file unless you know what you are doing.

        self.gridLayout.addWidget(self.spinBoxY, 3, 2, 1, 1)

        self.gridLayout.addWidget(self.spinBoxX, 3, 1, 1, 1)

        self.gridLayout.addWidget(self.label, 3, 0, 1, 1)

        self.gridLayout.addLayout(self.horizontalLayout, 4, 1, 1, 3)

        self.label_2 = QtWidgets.QLabel(ImportTextFromCADDialog)

        self.label_2.setMinimumSize(QtCore.QSize(50, 0))

        self.label_2.setObjectName("label_2")

        self.gridLayout.addWidget(self.label_2, 0, 0, 1, 1)

        self.gridLayout.addWidget(self.pushButtonClose, 6, 3, 1, 1)

        self.pushButtonSave = QtWidgets.QPushButton(ImportTextFromCADDialog)

        icon2.addPixmap(QtGui.QPixmap(":/newPrefix/Save.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)

        self.pushButtonSave.setIcon(icon2)

        self.pushButtonSave.setObjectName("pushButtonSave")

        self.gridLayout.addWidget(self.pushButtonSave, 5, 1, 1, 3)

        self.pushButtonImport = QtWidgets.QPushButton(ImportTextFromCADDialog)

        icon3 = QtGui.QIcon()

        icon3.addPixmap(QtGui.QPixmap(":/newPrefix/OK.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)

        self.pushButtonImport.setIcon(icon3)

        self.gridLayout.addWidget(self.pushButtonImport, 6, 2, 1, 1)

        self.gridLayout.addWidget(self.label_3, 4, 0, 1, 1)

        self.tabWidgetEntities = QtWidgets.QTabWidget(ImportTextFromCADDialog)

        self.tabWidgetEntities.setObjectName("tabWidgetEntities")

        self.tabLineTypes = QtWidgets.QWidget()

        self.tabLineTypes.setObjectName("tabLineTypes")

        self.gridLayout_2 = QtWidgets.QGridLayout(self.tabLineTypes)

        self.gridLayout_2.setObjectName("gridLayout_2")

        self.treeViewLineType = QtWidgets.QTreeView(self.tabLineTypes)

        self.treeViewLineType.setObjectName("treeViewLineType")

        self.gridLayout_2.addWidget(self.treeViewLineType, 0, 0, 1, 1)

        self.tabWidgetEntities.addTab(self.tabLineTypes, "")

        self.tabSymbols = QtWidgets.QWidget()

        self.tabSymbols.setObjectName("tabSymbols")

        self.gridLayout_3 = QtWidgets.QGridLayout(self.tabSymbols)

        self.gridLayout_3.setObjectName("gridLayout_3")

        self.treeViewSymbolMapping = QtWidgets.QTreeView(self.tabSymbols)

        self.treeViewSymbolMapping.setObjectName("treeViewSymbolMapping")

        self.gridLayout_3.addWidget(self.treeViewSymbolMapping, 0, 0, 1, 1)

        self.tabWidgetEntities.addTab(self.tabSymbols, "")

        self.gridLayout.addWidget(self.tabWidgetEntities, 2, 1, 1, 3)

        self.tabWidgetEntities.setCurrentIndex(0)

        self.pushButtonClose.setText(_translate("ImportTextFromCADDialog", "Close"))

        self.pushButtonSave.setText(_translate("ImportTextFromCADDialog", "Save Mapping"))

        self.tabWidgetEntities.setTabText(self.tabWidgetEntities.indexOf(self.tabLineTypes), _translate("ImportTextFromCADDialog", "Line Types"))

        self.tabWidgetEntities.setTabText(self.tabWidgetEntities.indexOf(self.tabSymbols), _translate("ImportTextFromCADDialog", "Symbols"))

        self._converted = False  # flag indicate whether symbol is converted or not

    @property

    def converted(self):

        """return whethere symbol is converted or not"""

        return self._converted

    @converted.setter

    def converted(self, value):

        """set converted flag with given value"""

        self._converted = value

            node.attrib['Converted'] = str(self.converted)

            if not self.transformOriginPoint().isNull():

                origin = self.mapToScene(self.transformOriginPoint())

                originNode.text = f"{origin.x()},{origin.y()}"

            else:

                origin = self.origin

                originNode.text = f"{origin[0]},{origin[1]}"

            if hasattr(self, 'currentPointModeIndex'):

                currentPointModeIndexNode = Element('CURRENTPOINTMODEINDEX')

                currentPointModeIndexNode.text = str(self.currentPointModeIndex) if self.currentPointModeIndex else ''

                node.append(currentPointModeIndexNode)

            message = f'error occurred({ex}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:' \

                      f'{sys.exc_info()[-1].tb_lineno}'

    def createItem(type: str, name: str, path: str, uid=None, owner=None, flip=0):

     <item row="3" column="2">

     <item row="3" column="1">

     <item row="3" column="0">

     <item row="4" column="1" colspan="3">

     <item row="0" column="0">

      <widget class="QLabel" name="label_2">

       <property name="minimumSize">

        <size>

         <width>50</width>

         <height>0</height>

        </size>

       </property>

       <property name="text">

        <string>AutoCAD Files : </string>

       </property>

      </widget>

     </item>

     <item row="6" column="3">

     <item row="5" column="1" colspan="3">

      <widget class="QPushButton" name="pushButtonSave">

        <string>Save Mapping</string>

       </property>

       <property name="icon">

        <iconset resource="../res/MainWindow.qrc">

         <normaloff>:/newPrefix/Save.svg</normaloff>:/newPrefix/Save.svg</iconset>

     <item row="6" column="2">

     <item row="4" column="0">

     <item row="2" column="1" colspan="3">

      <widget class="QTabWidget" name="tabWidgetEntities">

       <property name="currentIndex">

        <number>0</number>

       </property>

       <widget class="QWidget" name="tabLineTypes">

        <attribute name="title">

         <string>Line Types</string>

        </attribute>

        <layout class="QGridLayout" name="gridLayout_2">

         <item row="0" column="0">

          <widget class="QTreeView" name="treeViewLineType"/>

         </item>

        </layout>

       </widget>

       <widget class="QWidget" name="tabSymbols">

        <attribute name="title">

         <string>Symbols</string>

        </attribute>

        <layout class="QGridLayout" name="gridLayout_3">

         <item row="0" column="0">

          <widget class="QTreeView" name="treeViewSymbolMapping"/>

         </item>

        </layout>

       </widget>

# Doxyfile 1.9.0

# This file describes the settings to be used by the documentation system

# doxygen (www.doxygen.org) for a project.

#

# All text after a double hash (##) is considered a comment and is placed in

# front of the TAG it is preceding.

#

# All text after a single 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

#---------------------------------------------------------------------------

# This tag specifies the encoding used for all characters in the configuration

# file that follow. The default is UTF-8 which is also the encoding used for all

# text before the first occurrence of this tag. Doxygen uses libiconv (or the

# iconv built into libc) for the transcoding. See

# https://www.gnu.org/software/libiconv/ for the list of possible encodings.

# The default value is: UTF-8.

DOXYFILE_ENCODING      = UTF-8

# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by

# double-quotes, unless you are using Doxywizard) that should identify the

# project for which the documentation is generated. This name is used in the

# title of most generated pages and in a few other places.

# The default value is: My Project.

PROJECT_NAME           = ID2

# 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         =

# Using the PROJECT_BRIEF tag one can provide an optional one line description

# for a project that appears at the top of each page and should give viewer a

# quick idea about the purpose of the project. Keep the description short.

PROJECT_BRIEF          =

# With the PROJECT_LOGO tag one can specify a logo or an icon that is included

# in the documentation. The maximum height of the logo should not exceed 55

# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy

# the logo to the output directory.

PROJECT_LOGO           = ./ID2.ico

# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path

# into which the generated documentation will be written. 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       = C:\inetpub\wwwroot\Doxygen\ID2

# 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 causes

# performance problems for the file system.

# The default value is: NO.

CREATE_SUBDIRS         = NO

# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII

# characters to appear in the names of generated files. If set to NO, non-ASCII

# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode

# U+3044.

# The default value is: NO.

ALLOW_UNICODE_NAMES    = 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.

# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,

# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),

# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,

# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),

# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,

# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,

# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,

# Ukrainian and Vietnamese.

# The default value is: English.

OUTPUT_LANGUAGE        = Korean

# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all

# documentation generated by doxygen is written. Doxygen will use this

# information to generate all generated output in the proper direction.

# Possible values are: None, LTR, RTL and Context.

# The default value is: None.

OUTPUT_TEXT_DIRECTION  = None

# If the BRIEF_MEMBER_DESC tag is set to YES, 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.

# The default value is: YES.

BRIEF_MEMBER_DESC      = YES

# If the REPEAT_BRIEF tag is set to YES, 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.

# The default value is: 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 and the.

ABBREVIATE_BRIEF       = "The $name class" \

                         "The $name widget" \

                         "The $name file" \

                         is \

                         provides \

                         specifies \

                         contains \

                         represents \

                         a \

                         an \

                         the

# 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.

# The default value is: NO.

ALWAYS_DETAILED_SEC    = NO

# 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.

# The default value is: NO.

INLINE_INHERITED_MEMB  = NO

# If the FULL_PATH_NAMES tag is set to YES, 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

# The default value is: YES.

FULL_PATH_NAMES        = YES

# 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.

#

# Note that you can specify absolute paths here, but also relative paths, which

# will be relative from the directory where doxygen is started.

# This tag requires that the tag FULL_PATH_NAMES is set to YES.

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 list of include paths that are normally passed to the compiler

# using the -I flag.

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.

# The default value is: 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-style will behave just like regular Qt-

# style comments (thus requiring an explicit @brief command for a brief

# description.)

# The default value is: NO.

JAVADOC_AUTOBRIEF      = NO

# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line

# such as

# /***************

# as being the beginning of a Javadoc-style comment "banner". If set to NO, the

# Javadoc-style will behave just like regular comments and it will not be

# interpreted by doxygen.

# The default value is: NO.

JAVADOC_BANNER         = NO

# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first

# line (until the first dot) of a Qt-style comment as the brief description. If

# set to NO, the Qt-style will behave just like regular Qt-style comments (thus

# requiring an explicit \brief command for a brief description.)

# The default value is: NO.

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 behavior. 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 behavior instead.

#

# Note that setting this tag to YES also means that rational rose comments are

# not recognized any more.

# The default value is: NO.

MULTILINE_CPP_IS_BRIEF = NO

# By default Python docstrings are displayed as preformatted text and doxygen's

# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the

# doxygen's special commands can be used and the contents of the docstring

# documentation blocks is shown as doxygen documentation.

# The default value is: YES.

PYTHON_DOCSTRING       = YES

# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the

# documentation from any documented member that it re-implements.

# The default value is: 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.

# The default value is: 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.

# Minimum value: 1, maximum value: 16, default value: 4.

TAB_SIZE               = 4

# This tag can be used to specify a number of aliases that act 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 (in the resulting output). You can put ^^ in the value part of an

# alias to insert a newline as if a physical newline was in the original file.

# When you need a literal { or } or , in the value part of an alias you have to

# escape them by means of a backslash (\), this can lead to conflicts with the

# commands \{ and \} for these it is advised to use the version @{ and @} or use

# a double escape (\\{ and \\})

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.

# The default value is: NO.

OPTIMIZE_OUTPUT_FOR_C  = NO

# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or

# Python sources only. Doxygen will then generate output that is more tailored

# for that language. For instance, namespaces will be presented as packages,

# qualified scopes will look different, etc.

# The default value is: NO.

OPTIMIZE_OUTPUT_JAVA   = NO

# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran

# sources. Doxygen will then generate output that is tailored for Fortran.

# The default value is: NO.

OPTIMIZE_FOR_FORTRAN   = NO

# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL

# sources. Doxygen will then generate output that is tailored for VHDL.

# The default value is: NO.

OPTIMIZE_OUTPUT_VHDL   = NO

# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice

# sources only. Doxygen will then generate output that is more tailored for that

# language. For instance, namespaces will be presented as modules, types will be

# separated into more groups, etc.

# The default value is: NO.

OPTIMIZE_OUTPUT_SLICE  = NO

# Doxygen selects the parser to use depending on the extension of the files it

# parses. With this tag you can assign which parser to use for a given

# extension. Doxygen has a built-in mapping, but you can override or extend it

# using this tag. The format is ext=language, where ext is a file extension, and

# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,

# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,

# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:

# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser

# tries to guess whether the code is fixed or free formatted code, this is the

# default for Fortran type files). For instance to make doxygen treat .inc files

# as Fortran files (default is PHP), and .f files as C (default is Fortran),

# use: inc=Fortran f=C.

#

# Note: For files without extension you can use no_extension as a placeholder.

#

# Note that for custom extensions you also need to set FILE_PATTERNS otherwise

# the files are not read by doxygen. When specifying no_extension you should add

# * to the FILE_PATTERNS.

#

# Note see also the list of default file extension mappings.

EXTENSION_MAPPING      =

# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments

# according to the Markdown format, which allows for more readable

# documentation. See https://daringfireball.net/projects/markdown/ for details.

# The output of markdown processing is further processed by doxygen, so you can

# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in

# case of backward compatibilities issues.

# The default value is: YES.

MARKDOWN_SUPPORT       = YES

# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up

# to that level are automatically included in the table of contents, even if

# they do not have an id attribute.

# Note: This feature currently applies only to Markdown headings.

# Minimum value: 0, maximum value: 99, default value: 5.

# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.

TOC_INCLUDE_HEADINGS   = 5

# When enabled doxygen tries to link words that correspond to documented

# classes, or namespaces to their corresponding documentation. Such a link can

# be prevented in individual cases by putting a % sign in front of the word or

# globally by setting AUTOLINK_SUPPORT to NO.

# The default value is: YES.

AUTOLINK_SUPPORT       = YES

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

# versus func(std::string) {}). This also make the inheritance and collaboration

# diagrams that involve STL classes more complete and accurate.

# The default value is: NO.

BUILTIN_STL_SUPPORT    = NO

# If you use Microsoft's C++/CLI language, you should set this option to YES to

# enable parsing support.

# The default value is: NO.

CPP_CLI_SUPPORT        = NO

# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:

# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen

# will parse them like normal C++ but will assume all classes use public instead

# of private inheritance when no explicit protection keyword is present.

# The default value is: NO.

SIP_SUPPORT            = NO

# For Microsoft's IDL there are propget and propput attributes to indicate

# getter and setter methods for a property. Setting this option to YES will make

# doxygen to replace the get and set methods by a property in the documentation.

# This will only work if the methods are indeed getting or setting a simple

# type. If this is not the case, or you want to show the methods anyway, you

# should set this option to NO.

# The default value is: YES.

IDL_PROPERTY_SUPPORT   = YES

# 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.

# The default value is: NO.

DISTRIBUTE_GROUP_DOC   = NO

# If one adds a struct or class to a group and this option is enabled, then also

# any nested class or struct is added to the same group. By default this option

# is disabled and one has to add nested compounds explicitly via \ingroup.

# The default value is: NO.

GROUP_NESTED_COMPOUNDS = NO

# Set the SUBGROUPING tag to YES 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.

# The default value is: YES.

SUBGROUPING            = YES

# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions

# are shown inside the group in which they are included (e.g. using \ingroup)

# instead of on a separate page (for HTML and Man pages) or section (for LaTeX

# and RTF).

#

# Note that this feature does not work in combination with

# SEPARATE_MEMBER_PAGES.

# The default value is: NO.

INLINE_GROUPED_CLASSES = NO

# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions

# with only public data fields or simple typedef fields will be shown inline in

# the documentation of the scope in which they are defined (i.e. file,

# namespace, or group documentation), provided this scope is documented. If set

# to NO, structs, classes, and unions are shown on a separate page (for HTML and

# Man pages) or section (for LaTeX and RTF).

# The default value is: NO.

INLINE_SIMPLE_STRUCTS  = NO

# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or

# enum is documented as struct, union, or enum with the name of the typedef. So

# typedef struct TypeS {} TypeT, will appear in the documentation as a struct

# with name TypeT. When disabled the typedef will appear as a member of a file,

# namespace, or class. And the struct will be named TypeS. This can typically be

# useful for C code in case the coding convention dictates that all compound

# types are typedef'ed and only the typedef is referenced, never the tag name.

# The default value is: NO.

TYPEDEF_HIDES_STRUCT   = NO

# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This

# cache is used to resolve symbols given their name and scope. Since this can be

# an expensive process and often the same symbol appears multiple times in the

# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small

# doxygen will become slower. If the cache is too large, memory is wasted. The

# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range

# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536

# symbols. At the end of a run doxygen will report the cache usage and suggest

# the optimal cache size from a speed point of view.

# Minimum value: 0, maximum value: 9, default value: 0.

LOOKUP_CACHE_SIZE      = 0

# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use

# during processing. When set to 0 doxygen will based this on the number of

# cores available in the system. You can set it explicitly to a value larger

# than 0 to get more control over the balance between CPU load and processing

# speed. At this moment only the input processing can be done using multiple

# threads. Since this is still an experimental feature the default is set to 1,

# which efficively disables parallel processing. Please report any issues you

# encounter. Generating dot graphs in parallel is controlled by the

# DOT_NUM_THREADS setting.

# Minimum value: 0, maximum value: 32, default value: 1.

NUM_PROC_THREADS       = 1

#---------------------------------------------------------------------------

# 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 respectively EXTRACT_STATIC tags are set to YES.

# Note: This will also disable the warnings about undocumented members that are

# normally produced when WARNINGS is set to YES.

# The default value is: NO.

EXTRACT_ALL            = YES

# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will

# be included in the documentation.

# The default value is: NO.

EXTRACT_PRIVATE        = NO

# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual

# methods of a class will be included in the documentation.

# The default value is: NO.

EXTRACT_PRIV_VIRTUAL   = NO

# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal

# scope will be included in the documentation.

# The default value is: NO.

EXTRACT_PACKAGE        = NO

# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be

# included in the documentation.

# The default value is: NO.

EXTRACT_STATIC         = NO

# 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. Does not have any effect

# for Java sources.

# The default value is: YES.

EXTRACT_LOCAL_CLASSES  = YES

# This flag is only useful for Objective-C code. If 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, only methods in the interface are

# included.