6

from threading import Thread, Event, Lock

     9

import sikuli

    18

    """Send shortut to app by calling corresponding methods.

    21

        k = KBDShortcut()

    25

    fkeys = {"Stop":     sikuli.Key.F4,

    26

             "Run":      sikuli.Key.F5,

    27

             "Transfer": sikuli.Key.F6,

    28

             "Connect":  sikuli.Key.F7,

    29

             "Clean":    sikuli.Key.F9,

    30

             "Build":    sikuli.Key.F11,

    31

             "Save":     ("s",sikuli.Key.CTRL),

    32

             "New":      ("n",sikuli.Key.CTRL),

    33

             "Address":  ("l",sikuli.Key.CTRL)}  # to reach address bar in GTK's file selector

    36

        self.app = app.sikuliapp

    40

        if type(fkey) != tuple:

    46

            sikuli.type(*fkey)

    54

    def __init__(self):

    55

        """

    56

        Parameters: 

    57

            app (class BeremizApp)

    58

        """

    59

        self.r = sikuli.Region(self.sikuliapp.window())

    74

    def WaitIdleUI(self, period=1, timeout=15):

    84

            sikuli.wait(period)

    96

    def __init__(self):

    97

        """

    98

        Parameters: 

    99

            app (class BeremizApp)

   100

        """

   105

        self.pattern = None

   106

        self.success_event = Event()

   107

   115

            sys.stdout.write(a)

   117

            if self.pattern is not None and a.find(self.pattern) >= 0:

   118

                sys.stdout.write("found pattern in '" + a +"'")

   119

                self.success_event.set()

   120

   121

    def waitForChangeAndIdleStdout(self, period=2, timeout=15):

   128

   129

        if self.event.wait(timeout):

   130

            self.event.clear()

   131

        else:

   132

            raise Exception("Stdout didn't become active before timeout")

   133

   134

        self.waitIdleStdout(period, timeout - (timesec() - start_time))

   135

   136

    def waitIdleStdout(self, period=2, timeout=15):

   143

        end_time = timesec() + timeout

   144

        self.event.clear()

   145

        while timesec() < end_time:

   146

            if self.event.wait(period):

   147

                # no timeout -> got event -> not idle -> loop again

   148

                self.event.clear()

   149

            else:

   150

                # timeout -> no event -> idle -> exit

   151

                return True

   152

   153

        raise Exception("Stdout did not idle before timeout")

   154

   155

    def waitPatternInStdout(self, pattern, timeout, count=1):

   157

        self.pattern = pattern

   158

        end_time = timesec() + timeout

   159

        self.event.clear()

   161

            remain = end_time - timesec()

   162

            if remain <= 0 :

   163

                res = False

   164

                break

   165

   166

            res = self.success_event.wait(remain)

   167

            if res:

   168

                self.success_event.clear()

   172

        self.pattern = None

   173

        return res

   174

   175

class BeremizApp(IDEIdleObserver, stdoutIdleObserver):

   176

    def __init__(self, projectpath=None, exemple=None):

   177

        """

   178

        Starts Beremiz IDE, waits for main window to appear, maximize it.

   179

   180

            Parameters: 

   181

                projectpath (str): path to project to open

   182

                exemple (str): path relative to exemples directory

   183

   184

            Returns:

   185

                Sikuli App class instance

   186

        """

   187

   188

        command = [python_bin, opj(beremiz_path,"Beremiz.py"), "--log=/dev/stdout"]

   189

   190

        if exemple is not None:

   191

            command.append(opj(beremiz_path,"exemples",exemple))

   192

        elif projectpath is not None:

   193

            command.append(projectpath)

   194

   195

        # App class is broken in Sikuli 2.0.5: can't start process with arguments.

   196

        # 

   197

        # Workaround : - use subprocess module to spawn IDE process,

   198

        #              - use wmctrl to find IDE window details and maximize it

   199

        #              - pass exact window title to App class constructor

   200

   201

        self.proc = subprocess.Popen(command, stdout=subprocess.PIPE, bufsize=0)

   202

   203

        # Window are macthed against process' PID

   204

        ppid = self.proc.pid

   205

   206

        # Timeout 5s

   207

        c = 50

   208

        while c > 0:

   209

            # equiv to "wmctrl -l -p | grep $pid"

   210

            try:

   211

                wlist = filter(lambda l:(len(l)>2 and l[2]==str(ppid)), map(lambda s:s.split(None,4), subprocess.check_output(["wmctrl", "-l", "-p"]).splitlines()))

   212

            except subprocess.CalledProcessError:

   213

                wlist = []

   214

   215

            # window with no title only has 4 fields do describe it

   216

            # beremiz splashcreen has no title

   217

            # wait until main window is visible

   218

            if len(wlist) == 1 and len(wlist[0]) == 5:

   219

                windowID,_zero,wpid,_XID,wtitle = wlist[0] 

   220

                break

   221

   222

            sikuli.wait(0.1)

   223

            c = c - 1

   224

   225

        if c == 0:

   226

            raise Exception("Couldn't find Beremiz window")

   227

   228

        # Maximize window x and y

   229

        subprocess.check_call(["wmctrl", "-i", "-r", windowID, "-b", "add,maximized_vert,maximized_horz"])

   230

   231

        # switchApp creates an App object by finding window by title, is not supposed to spawn a process

   232

        self.sikuliapp = sikuli.switchApp(wtitle)

   233

        self.k = KBDShortcut(self)

   234

   235

        IDEIdleObserver.__init__(self)

   236

        stdoutIdleObserver.__init__(self)

   237

   238

        # stubs for common sikuli calls to allow adding hooks later

   239

        for n in ["click","doubleClick","type"]:

   240

            setattr(self, n, getattr(sikuli, n))

   241

   242

    def close(self):

   243

        self.sikuliapp.close()

   244

        self.sikuliapp = None

   245

   246

    def __del__(self):

   247

        if self.sikuliapp is not None:

   248

            self.sikuliapp.close()

   249

        IDEIdleObserver.__del__(self)

   250

        stdoutIdleObserver.__del__(self)

   251