1

import os, shutil, sys

     2

base_folder = os.path.split(sys.path[0])[0]

     3

sys.path.append(os.path.join(base_folder, "wxsvg", "SVGUIEditor"))

     4

sys.path.append(os.path.join(base_folder, "plcopeneditor", "graphics"))

     5

     6

import wx

     7

     8

from SVGUIGenerator import *

     9

from SVGUIControler import *

    10

from SVGUIEditor import *

    11

from FBD_Objects import *

    12

    13

from wxPopen import ProcessLogger

    14

    15

[ID_SVGUIEDITORFBDPANEL, 

    16

] = [wx.NewId() for _init_ctrls in range(1)]

    17

    18

SVGUIFB_Types = {ITEM_CONTAINER : "Container",

    19

                 ITEM_BUTTON : "Button", 

    20

                 ITEM_TEXT : "TextCtrl", 

    21

                 ITEM_SCROLLBAR : "ScrollBar", 

    22

                 ITEM_ROTATING : "RotatingCtrl", 

    23

                 ITEM_NOTEBOOK : "NoteBook", 

    24

                 ITEM_TRANSFORM : "Transform"}

    25

    26

class _SVGUIEditor(SVGUIEditor):

    27

    """

    28

    This Class add IEC specific features to the SVGUIEditor :

    29

        - FDB preview

    30

        - FBD begin drag 

    31

    """

    32

    33

    def _init_coll_EditorGridSizer_Items(self, parent):

    34

        SVGUIEditor._init_coll_EditorGridSizer_Items(self, parent)

    35

        parent.AddWindow(self.FBDPanel, 0, border=0, flag=wx.GROW)

    36

    37

    def _init_ctrls(self, prnt):

    38

        SVGUIEditor._init_ctrls(self, prnt, False)

    39

    40

        self.FBDPanel = wx.Panel(id=ID_SVGUIEDITORFBDPANEL, 

    41

                  name='FBDPanel', parent=self.EditorPanel, pos=wx.Point(0, 0),

    42

                  size=wx.Size(0, 0), style=wx.TAB_TRAVERSAL|wx.SIMPLE_BORDER)

    43

        self.FBDPanel.SetBackgroundColour(wx.WHITE)

    44

        self.FBDPanel.Bind(wx.EVT_LEFT_DOWN, self.OnFBDPanelClick)

    45

        self.FBDPanel.Bind(wx.EVT_PAINT, self.OnPaintFBDPanel)

    46

    47

        setattr(self.FBDPanel, "GetScaling", lambda: None) 

    48

    49

        self._init_sizers()

    50

    51

    def __init__(self, parent, controler = None, fileOpen = None):

    52

        SVGUIEditor.__init__(self, parent, controler, fileOpen)

    53

    54

        self.FBDBlock = None

    55

    56

    def RefreshView(self, select_id = None):

    57

        SVGUIEditor.RefreshView(self, select_id)

    58

        self.FBDPanel.Refresh()

    59

    60

    def OnPaintFBDPanel(self,event):

    61

        dc = wx.ClientDC(self.FBDPanel)

    62

        dc.Clear()

    63

        selected = self.GetSelected()

    64

        if selected is not None:

    65

            selected_type = self.Controler.GetElementType(selected)

    66

            if selected_type is not None:

    67

                self.FBDBlock = FBD_Block(parent=self.FBDPanel,type=SVGUIFB_Types[selected_type],name=self.Controler.GetElementName(selected))

    68

                width, height = self.FBDBlock.GetMinSize()

    69

                self.FBDBlock.SetSize(width,height)

    70

                clientsize = self.FBDPanel.GetClientSize()

    71

                x = (clientsize.width - width) / 2

    72

                y = (clientsize.height - height) / 2

    73

                self.FBDBlock.SetPosition(x, y)

    74

                self.FBDBlock.Draw(dc)

    75

        else:

    76

            self.FBDBlock = None

    77

        event.Skip()

    78

    79

    def OnFBDPanelClick(self, event):

    80

        if self.FBDBlock:

    81

            data = wx.TextDataObject(str((self.FBDBlock.GetType(), "functionBlock", self.FBDBlock.GetName())))

    82

            DropSrc = wx.DropSource(self.FBDPanel)

    83

            DropSrc.SetData(data)

    84

            DropSrc.DoDragDrop()

    85

        event.Skip()

    86

    87

    def OnInterfaceTreeItemSelected(self, event):

    88

        self.FBDPanel.Refresh()

    89

        SVGUIEditor.OnInterfaceTreeItemSelected(self, event)

    90

    91

    def OnGenerate(self,event):

    92

        self.SaveProject()

    93

        self.Controler.PlugGenerate_C(sys.path[0],(0,0,4,5),None)

    94

        event.Skip()    

    95

    96

TYPECONVERSION = {"BOOL" : "X", "SINT" : "B", "INT" : "W", "DINT" : "D", "LINT" : "L",

    97

    "USINT" : "B", "UINT" : "W", "UDINT" : "D", "ULINT" : "L", "REAL" : "D", "LREAL" : "L",

    98

    "STRING" : "B", "BYTE" : "B", "WORD" : "W", "DWORD" : "D", "LWORD" : "L", "WSTRING" : "W"}

    99

   100

CTYPECONVERSION = {"BOOL" : "IEC_BOOL", "UINT" : "IEC_UINT", "STRING" : "IEC_STRING", "REAL" : "IEC_REAL"}

   101

CPRINTTYPECONVERSION = {"BOOL" : "d", "UINT" : "d", "STRING" : "s", "REAL" : "f"}

   102

   103

class RootClass(SVGUIControler):

   104

   105

    def __init__(self):

   106

        SVGUIControler.__init__(self)

   107

        filepath = os.path.join(self.PlugPath(), "gui.xml")

   108

   109

        if os.path.isfile(filepath):

   110

            svgfile = os.path.join(self.PlugPath(), "gui.svg")

   111

            if os.path.isfile(svgfile):

   112

                self.SvgFilepath = svgfile

   113

            self.OpenXMLFile(filepath)

   114

        else:

   115

            self.CreateNewInterface()

   116

            self.SetFilePath(filepath)

   117

   118

    def GetElementIdFromName(self, name):

   119

        element = self.GetElementByName(name)

   120

        if element is not None:

   121

            return element.getid()

   122

        return None

   123

   124

    _View = None

   125

    def _OpenView(self, logger):

   126

        if not self._View:

   127

            def _onclose():

   128

                self._View = None

   129

            def _onsave():

   130

                self.GetPlugRoot().SaveProject()

   131

            self._View = _SVGUIEditor(self.GetPlugRoot().AppFrame, self)

   132

            self._View._onclose = _onclose

   133

            self._View._onsave = _onsave

   134

            self._View.Show()

   135

   136

    def _ImportSVG(self, logger):

   137

        if not self._View:

   138

            dialog = wx.FileDialog(self.GetPlugRoot().AppFrame, "Choose a SVG file", os.getcwd(), "",  "SVG files (*.svg)|*.svg|All files|*.*", wx.OPEN)

   139

            if dialog.ShowModal() == wx.ID_OK:

   140

                svgpath = dialog.GetPath()

   141

                if os.path.isfile(svgpath):

   142

                    shutil.copy(svgpath, os.path.join(self.PlugPath(), "gui.svg"))

   143

                else:

   144

                    logger.write_error("No such SVG file: %s\n"%svgpath)

   145

            dialog.Destroy()

   146

   147

    def _ImportXML(self, logger):

   148

        if not self._View:

   149

            dialog = wx.FileDialog(self.GetPlugRoot().AppFrame, "Choose a XML file", os.getcwd(), "",  "XML files (*.xml)|*.xml|All files|*.*", wx.OPEN)

   150

            if dialog.ShowModal() == wx.ID_OK:

   151

                xmlpath = dialog.GetPath()

   152

                if os.path.isfile(xmlpath):

   153

                    shutil.copy(xmlpath, os.path.join(self.PlugPath(), "gui.xml"))

   154

                else:

   155

                    logger.write_error("No such XML file: %s\n"%xmlpath)

   156

            dialog.Destroy()

   157

   158

    PluginMethods = [

   159

        {"bitmap" : os.path.join("images","HMIEditor"),

   160

         "name" : "HMI Editor",

   161

         "tooltip" : "HMI Editor",

   162

         "method" : "_OpenView"},

   163

        {"bitmap" : os.path.join("images","ImportSVG"),

   164

         "name" : "Import SVG",

   165

         "tooltip" : "Import SVG",

   166

         "method" : "_ImportSVG"},

   167

        {"bitmap" : os.path.join("images","ImportDEF"),

   168

         "name" : "Import XML",

   169

         "tooltip" : "Import XML",

   170

         "method" : "_ImportXML"},

   171

    ]

   172

   173

    def OnPlugSave(self):

   174

        self.SaveXMLFile()

   175

        return True

   176

   177

    def PlugGenerate_C(self, buildpath, locations, logger):

   178

        progname = "SVGUI_%s"%"_".join(map(str, self.GetCurrentLocation()))

   179

   180

        generator = _SVGUICGenerator(self.GetElementsByType(), self.GetSVGFilePath(), self.GetFilePath(), self.GetCurrentLocation())

   181

        generator.GenerateProgram((0, 0), buildpath, progname)

   182

        Gen_C_file = os.path.join(buildpath, progname+".cpp" )

   183

   184

        if wx.Platform == '__WXMSW__':

   185

            cxx_flags = "-I..\\..\\wxPython-src-2.8.7.1\\bld\\lib\\wx\\include\\msw-unicode-release-2.8 -I..\\..\\wxPython-src-2.8.7.1\\include -I..\\..\\wxPython-src-2.8.7.1\\contrib\\include -I..\\..\\matiec\\lib -DWXUSINGDLL -D__WXMSW__ -mthreads"

   186

            libs = "\"..\\lib\\libwxsvg.a\" \"..\\lib\\libwxsvg_agg.a\" \"..\\lib\\libagg.a\" \"..\\lib\\libaggplatformwin32.a\" \"..\\lib\\libaggfontwin32tt.a\" -L..\\..\\wxPython-src-2.8.7.1\\bld\\lib -mno-cygwin -mwindows -mthreads  -mno-cygwin -mwindows -Wl,--subsystem,windows -mwindows -lwx_mswu_richtext-2.8 -lwx_mswu_aui-2.8 -lwx_mswu_xrc-2.8 -lwx_mswu_qa-2.8 -lwx_mswu_html-2.8 -lwx_mswu_adv-2.8 -lwx_mswu_core-2.8 -lwx_baseu_xml-2.8 -lwx_baseu_net-2.8 -lwx_baseu-2.8"

   187

        else:

   188

            status, result, err_result = ProcessLogger(logger, "wx-config --cxxflags", no_stdout=True).spin()

   189

            if status:

   190

                logger.write_error("Unable to get wx cxxflags\n")

   191

            cxx_flags = result.strip() + " -I../matiec/lib"

   192

   193

            status, result, err_result = ProcessLogger(logger, "wx-config --libs", no_stdout=True).spin()

   194

            if status:

   195

                logger.write_error("Unable to get wx libs\n")

   196

            libs = result.strip() + " -lwxsvg"

   197

   198

        return [(Gen_C_file, cxx_flags)],libs,True

   199

   200

    def BlockTypesFactory(self):

   201

        def generate_svgui_block(generator, block, body, link, order=False):

   202

            name = block.getinstanceName()

   203

            block_id = self.GetElementIdFromName(name)

   204

            if block_id == None:

   205

                raise ValueError, "No corresponding block found"

   206

            type = block.gettypeName()

   207

            block_infos = GetBlockType(type)

   208

            current_location = ".".join(map(str, self.GetCurrentLocation()))

   209

            if not generator.ComputedBlocks.get(name, False) and not order:

   210

                generator.ComputedBlocks[block] = True

   211

                for num, variable in enumerate(block.inputVariables.getvariable()):

   212

                    connections = variable.connectionPointIn.getconnections()

   213

                    if connections and len(connections) == 1:

   214

                        parameter = "%sQ%s%s.%d.%d"%("%", TYPECONVERSION[block_infos["inputs"][num][1]], current_location, block_id, num+1)

   215

                        value = generator.ComputeFBDExpression(body, connections[0])

   216

                        generator.Program += ("  %s := %s;\n"%(parameter, generator.ExtractModifier(variable, value)))

   217

            if link:

   218

                connectionPoint = link.getposition()[-1]

   219

                for num, variable in enumerate(block.outputVariables.getvariable()):

   220

                    blockPointx, blockPointy = variable.connectionPointOut.getrelPositionXY()

   221

                    if block.getx() + blockPointx == connectionPoint.getx() and block.gety() + blockPointy == connectionPoint.gety():

   222

                        return "%sI%s%s.%d.%d"%("%", TYPECONVERSION[block_infos["outputs"][num][1]], current_location, block_id, num+1)

   223

                raise ValueError, "No output variable found"

   224

            else:

   225

                return None

   226

   227

        def initialise_block(type, name, block = None):

   228

            block_id = self.GetElementIdFromName(name)

   229

            if block_id == None:

   230

                raise ValueError, "No corresponding block found"

   231

            block_infos = GetBlockType(type)

   232

            current_location = ".".join(map(str, self.GetCurrentLocation()))

   233

            variables = []

   234

            if block is not None:

   235

                input_variables = block.inputVariables.getvariable()

   236

                output_variables = block.outputVariables.getvariable()

   237

            else:

   238

                input_variables = None

   239

                output_variables = None

   240

            for num, (input_name, input_type, input_modifier) in enumerate(block_infos["inputs"]):

   241

                if input_variables is not None and num < len(input_variables):

   242

                    connections = input_variables[num].connectionPointIn.getconnections()

   243

                if input_variables is None or connections and len(connections) == 1:

   244

                    variables.append((input_type, None, "%sQ%s%s.%d.%d"%("%", TYPECONVERSION[input_type], current_location, block_id, num+1), None))

   245

            for num, (output_name, output_type, output_modifier) in enumerate(block_infos["outputs"]):

   246

                variables.append((output_type, None, "%sI%s%s.%d.%d"%("%", TYPECONVERSION[input_type], current_location, block_id, num+1), None))

   247

            return variables

   248

   249

        return [{"name" : "SVGUI function blocks", "list" :

   250

                [{"name" : "Container", "type" : "functionBlock", "extensible" : False, 

   251

                    "inputs" : [("Show","BOOL","none"),("Enable","BOOL","none")], 

   252

                    "outputs" : [],

   253

                    "comment" : "SVGUI Container",

   254

                    "generate" : generate_svgui_block, "initialise" : initialise_block},

   255

                {"name" : "Button", "type" : "functionBlock", "extensible" : False, 

   256

                    "inputs" : [("Show","BOOL","none"),("Enable","BOOL","none"),("Toggle","BOOL","none")], 

   257

                    "outputs" : [("State","BOOL","none")],

   258

                    "comment" : "SVGUI Button",

   259

                    "generate" : generate_svgui_block, "initialise" : initialise_block},

   260

                {"name" : "TextCtrl", "type" : "functionBlock", "extensible" : False, 

   261

                    "inputs" : [("Show","BOOL","none"),("Enable","BOOL","none"),("SetText","STRING","none")], 

   262

                    "outputs" : [("Text","STRING","none")],

   263

                    "comment" : "SVGUI Text Control",

   264

                    "generate" : generate_svgui_block, "initialise" : initialise_block},

   265

                {"name" : "ScrollBar", "type" : "functionBlock", "extensible" : False, 

   266

                    "inputs" : [("Show","BOOL","none"),("Enable","BOOL","none"),("SetThumb","UINT","none"),("SetRange","UINT","none"),("SetPosition","UINT","none")], 

   267

                    "outputs" : [("Position","UINT","none")],

   268

                    "comment" : "SVGUI ScrollBar",

   269

                    "generate" : generate_svgui_block, "initialise" : initialise_block},

   270

                {"name" : "NoteBook", "type" : "functionBlock", "extensible" : False, 

   271

                    "inputs" : [("Show","BOOL","none"),("Enable","BOOL","none"),("SetSelected","BOOL","none")], 

   272

                    "outputs" : [("Selected","UINT","none")],

   273

                    "comment" : "SVGUI Notebook",

   274

                    "generate" : generate_svgui_block, "initialise" : initialise_block},

   275

                {"name" : "RotatingCtrl", "type" : "functionBlock", "extensible" : False, 

   276

                    "inputs" : [("Show","BOOL","none"),("Enable","BOOL","none"),("SetAngle","REAL","none")], 

   277

                    "outputs" : [("Angle","REAL","none")],

   278

                    "comment" : "SVGUI Rotating Control",

   279

                    "generate" : generate_svgui_block, "initialise" : initialise_block},

   280

                {"name" : "Transform", "type" : "functionBlock", "extensible" : False, 

   281

                    "inputs" : [("Show","BOOL","none"),("Enable","BOOL","none"),("SetX","REAL","none"),("SetY","REAL","none"),("SetXScale","REAL","none"),("SetYScale","REAL","none"),("SetAngle","REAL","none")], 

   282

                    "outputs" : [("X","REAL","none"),("Y","REAL","none")],

   283

                    "comment" : "SVGUI Transform",

   284

                    "generate" : generate_svgui_block, "initialise" : initialise_block},

   285

               ]}

   286

        ]

   287

   288

   289

   290

class _SVGUICGenerator(SVGUICGenerator):

   291

   292

    def __init__(self, elements, svgfile, xmlfile, current_location):

   293

        SVGUICGenerator.__init__(self, elements, svgfile, xmlfile)

   294

   295

        self.CurrentLocation = current_location

   296

   297

    def GenerateProgramHeadersPublicVars(self):

   298

        text = """    void OnPlcOutEvent(wxEvent& event);

   299

   300

    void Retrieve();

   301

    void Publish();

   302

    void Initialize();

   303

"""

   304

#        text += "    void Print();\n"

   305

        return text

   306

   307

    def GenerateIECVars(self):

   308

        text = ""

   309

        for element in self.Elements:

   310

            text += "STATE_TYPE out_state_%d;\n"%element.getid()

   311

            text += "STATE_TYPE in_state_%d;\n"%element.getid()

   312

        text +="\n"

   313

        current_location = "_".join(map(str, self.CurrentLocation))

   314

        #Declaration des variables

   315

        for element in self.Elements:

   316

            block_infos = GetBlockType(SVGUIFB_Types[GetElementType(element)])

   317

            block_id = element.getid()

   318

            for i, input in enumerate(block_infos["inputs"]):

   319

                element_c_type = CTYPECONVERSION[input[1]]

   320

                variable = "__Q%s%s_%d_%d"%(TYPECONVERSION[input[1]], current_location, block_id, i + 1)

   321

                text += "%s %s;\n"%(element_c_type, variable)

   322

                text += "%s _copy%s;\n"%(element_c_type, variable)

   323

            for i, output in enumerate(block_infos["outputs"]):

   324

                element_c_type = CTYPECONVERSION[output[1]]

   325

                variable = "__I%s%s_%d_%d"%(TYPECONVERSION[output[1]], current_location, block_id, i + 1)

   326

                text += "%s %s;\n"%(element_c_type, variable)

   327

                text += "%s _copy%s;\n"%(element_c_type, variable)

   328

            text +="\n"

   329

        return text

   330

   331

    def GenerateGlobalVarsAndFuncs(self, size):

   332

        text = """#include \"iec_types.h\"

   333

   334

#ifdef __WXMSW__

   335

#define COMPARE_AND_SWAP_VAL(Destination, comparand, exchange) InterlockedCompareExchange(Destination, exchange, comparand)

   336

#define THREAD_RETURN_TYPE DWORD WINAPI

   337

#define STATE_TYPE long int

   338

#else

   339

#define COMPARE_AND_SWAP_VAL(Destination, comparand, exchange) __sync_val_compare_and_swap(Destination, comparand, exchange)

   340

#define THREAD_RETURN_TYPE void*

   341

#define STATE_TYPE volatile int

   342

#endif

   343

   344

"""

   345

   346

        text += self.GenerateIECVars()

   347

   348

        text += """IMPLEMENT_APP_NO_MAIN(SVGViewApp);

   349

IMPLEMENT_WX_THEME_SUPPORT;

   350

SVGViewApp *myapp = NULL;

   351

   352

#ifdef __WXMSW__

   353

HANDLE wxMainLoop;

   354

DWORD wxMainLoopId;

   355

#else

   356

pthread_t wxMainLoop;

   357

#endif

   358

   359

"""

   360

   361

#        text += "pthread_t wxMainLoop,automate;\n"

   362

        text += """int myargc = 0;

   363

char** myargv = NULL;

   364

   365

#define UNCHANGED 1

   366

#define PLC_BUSY 2

   367

#define CHANGED 3

   368

#define GUI_BUSY 4

   369

#ifdef __WXMSW__

   370

#else

   371

#endif

   372

   373

bool refresh = false;

   374

bool refreshing = false;

   375

   376

THREAD_RETURN_TYPE InitWxEntry(void* args)

   377

{

   378

  wxEntry(myargc,myargv);

   379

  return 0;

   380

}

   381

   382

"""

   383

#        text += """void* SimulAutomate(void* args)

   384

#{

   385

#  while(1){

   386

#    myapp->frame->m_svgCtrl->IN_"+self.BusNumber+"();

   387

#    //printf(\"AUTOMATE\\n\");

   388

#    myapp->frame->m_svgCtrl->OUT_"+self.BusNumber+"();

   389

#    sleep(1);

   390

#  }

   391

#  return args;

   392

#}

   393

#

   394

#"""

   395

   396

        text += """bool SVGViewApp::OnInit()

   397

{

   398

  #ifndef __WXMSW__

   399

    setlocale(LC_NUMERIC, "C");

   400

  #endif

   401

"""

   402

        #text += "  frame = new MainFrame(NULL, wxT(\"Program\"),wxDefaultPosition, wxSize(%d, %d));\n"%size

   403

        text += """  frame = new MainFrame(NULL, wxT("Program"),wxDefaultPosition, wxDefaultSize);

   404

  frame->Show();

   405

  myapp = this;

   406

"""

   407

#        text += "  pthread_create(&automate, NULL, SimulAutomate, NULL);\n"

   408

        text += """  return true;

   409

}

   410

   411

extern "C" {

   412

   413

int __init_%(location)s(int argc, char** argv)

   414

{

   415

  myargc = argc;

   416

  myargv = argv;

   417

#ifdef __WXMSW__

   418

  wxMainLoop = CreateThread(NULL, 0, InitWxEntry, 0, 0, &wxMainLoopId);

   419

#else

   420

  pthread_create(&wxMainLoop, NULL, InitWxEntry, NULL);

   421

#endif

   422

  return 0;

   423

}

   424

   425

void __cleanup_%(location)s()

   426

{

   427

}

   428

   429

void __retrieve_%(location)s()

   430

{

   431

  if(myapp){

   432

    myapp->frame->m_svgCtrl->Retrieve();

   433

  }        

   434

}

   435

   436

void __publish_%(location)s()

   437

{

   438

  if(myapp){

   439

    myapp->frame->m_svgCtrl->Publish();

   440

  }

   441

}

   442

   443

}

   444

   445

IEC_STRING wxStringToIEC_STRING(wxString s)

   446

{

   447

  IEC_STRING res = {0,""};

   448

  int i;

   449

  for(i = 0; i<s.Length() && i<STR_MAX_LEN; i++)

   450

    res.body[i] = s.GetChar(i);

   451

  res.len = i;

   452

  return res;

   453

}

   454

   455

"""%{"location" : "_".join(map(str, self.CurrentLocation))}

   456

   457

        return text

   458

   459

    def GenerateProgramEventTable(self):

   460

        text = """BEGIN_DECLARE_EVENT_TYPES()

   461

DECLARE_LOCAL_EVENT_TYPE( EVT_PLC, wxNewEventType() )

   462

END_DECLARE_EVENT_TYPES()

   463

   464

DEFINE_LOCAL_EVENT_TYPE( EVT_PLC )

   465

   466

"""     

   467

        #Event Table Declaration

   468

        text += "BEGIN_EVENT_TABLE(Program, SVGUIWindow)\n"

   469

        for element in self.Elements:

   470

            element_type = GetElementType(element)

   471

            element_name = element.getname()

   472

            if element_type == ITEM_BUTTON:

   473

                text += "  EVT_BUTTON (SVGUIID(\"%s\"), Program::On%sClick)\n"%(element_name, element_name)

   474

            elif element_type in [ITEM_SCROLLBAR, ITEM_ROTATING, ITEM_TRANSFORM]:

   475

                text += "  EVT_COMMAND_SCROLL_THUMBTRACK (SVGUIID(\"%s\"), Program::On%sChanging)\n"%(element_name, element_name)

   476

            elif element_type == ITEM_NOTEBOOK:

   477

                text += "  EVT_NOTEBOOK_PAGE_CHANGED (SVGUIID(\"%s\"), Program::On%sTabChanged)\n"%(element_name, element_name)

   478

        text += "  EVT_CUSTOM(EVT_PLC, wxID_ANY, Program::OnPlcOutEvent)\n"

   479

        text += "END_EVENT_TABLE()\n\n"

   480

        return text

   481

   482

    def GenerateProgramInitFrame(self):

   483

        text = """MainFrame::MainFrame(wxWindow *parent, const wxString& title, const wxPoint& pos,const wxSize& size, long style): wxFrame(parent, wxID_ANY, title, pos, size, style)

   484

{

   485

  m_svgCtrl = new Program(this);

   486

  if (m_svgCtrl->LoadFiles(wxT("%s"), wxT("%s")))

   487

  {

   488

    Show(true);

   489

    m_svgCtrl->SetFocus();