1

import os

     2

from nodelist import NodeList

     3

from nodemanager import NodeManager

     4

import config_utils, gen_cfile

     5

from networkedit import networkedit

     6

     7

class _NetworkEdit(networkedit):

     8

    " Overload some of CanFestival Network Editor methods "

     9

    def OnCloseFrame(self, event):

    10

        " Do reset _NodeListPlug.View when closed"

    11

        self._onclose()

    12

        event.Skip()

    13

    14

class _NodeListPlug(NodeList):

    15

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

    16

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    17

      <xsd:element name="CanFestivalNode">

    18

        <xsd:complexType>

    19

          <xsd:attribute name="CAN_Device" type="xsd:string" use="required" />

    20

        </xsd:complexType>

    21

      </xsd:element>

    22

    </xsd:schema>

    23

    """

    24

    25

    def __init__(self, buspath):

    26

        manager = NodeManager()

    27

        NodeList.__init__(self, manager)

    28

        self.LoadProject(buspath)

    29

    30

    _View = None

    31

    def _OpenView(self):

    32

        if not self._View:

    33

            def _onclose():

    34

                self.View = None

    35

            self._View = _NetworkEdit()

    36

            self._View._onclose = _onclose

    37

        return self.View

    38

    PluginMethods = [("NetworkEdit",_OpenView)]

    39

    40

    def OnPlugClose(self):

    41

        if self._View:

    42

            self._View.Close()

    43

    44

    def PlugTestModified(self):

    45

        return self.HasChanged()

    46

    47

    def PlugRequestSave(self):

    48

        self.SaveProject()

    49

        return True

    50

    51

    def Generate_C(self, dirpath, locations):

    52

        """

    53

        return C code for network dictionnary

    54

        """

    55

        filepath = os.path.join(dirpath, "master.c")

    56

        master = config_utils.GenerateConciseDCF(locations, self)

    57

        res = gen_cfile.GenerateFile(filepath, master)

    58

        if not res:

    59

             s = str(self.BaseParams.BusId)+"_IN(){}\n"

    60

             s += "CanOpen(\""+self.CanFestivalNode.CAN_Device+"\")"

    61

             f = file(filepath, 'a')

    62

             f.write(s)

    63

        else:

    64

             pass # error

    65

        return {"headers":["master.h"],"sources":["master.c"]}

    66

    67

class RootClass:

    68

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

    69

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    70

      <xsd:element name="CanFestivalInstance">

    71

        <xsd:complexType>

    72

          <xsd:attribute name="CAN_Driver" type="xsd:string" use="required" />

    73

        </xsd:complexType>

    74

      </xsd:element>

    75

    </xsd:schema>

    76

    """

    77

    78

    PlugChildsTypes = [("CanOpenNode",_NodeListPlug)]

    79

    80

    def Generate_C(self, filepath, locations):

    81

        """

    82

        return C code for network dictionnary

    83

        """

    84

        master = config_utils.GenerateConciseDCF(locations, self)

    85

        res = gen_cfile.GenerateFile(filepath, master)

    86

        if not res:

    87

             s = str(self.BaseParams.BusId)+"_IN(){}\n"

    88

             s += "CanOpen(str(\""+self.CanFestivalNode.CAN_Device+"\")"

    89

             f = file(filepath, 'a')

    90

             f.write(s)

    91

        else:

    92

             pass # error

    93