normalize line endings in repo

IPython/deathrow/oldfrontend/process/winprocess.py

@@ -1,264 +1,264 b''
-# A module to expose various thread/process/job related structures and
-# methods from kernel32
-#
-# The MIT License
-#
-# Copyright (c) 2006 the Mozilla Foundation <http://www.mozilla.org>
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense,
-# and/or sell copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-
-from ctypes import c_void_p, POINTER, sizeof, Structure, windll, WinError, WINFUNCTYPE
-from ctypes.wintypes import BOOL, BYTE, DWORD, HANDLE, LPCWSTR, LPWSTR, UINT, WORD
-
-LPVOID = c_void_p
-LPBYTE = POINTER(BYTE)
-LPDWORD = POINTER(DWORD)
-
-SW_HIDE = 0
-
-def ErrCheckBool(result, func, args):
-    """errcheck function for Windows functions that return a BOOL True
-    on success"""
-    if not result:
-        raise WinError()
-    return args
-
-# CloseHandle()
-
-CloseHandleProto = WINFUNCTYPE(BOOL, HANDLE)
-CloseHandle = CloseHandleProto(("CloseHandle", windll.kernel32))
-CloseHandle.errcheck = ErrCheckBool
-
-# AutoHANDLE
-
-class AutoHANDLE(HANDLE):
-    """Subclass of HANDLE which will call CloseHandle() on deletion."""
-    def Close(self):
-        if self.value:
-            CloseHandle(self)
-            self.value = 0
-    
-    def __del__(self):
-        self.Close()
-
-    def __int__(self):
-        return self.value
-
-def ErrCheckHandle(result, func, args):
-    """errcheck function for Windows functions that return a HANDLE."""
-    if not result:
-        raise WinError()
-    return AutoHANDLE(result)
-
-# PROCESS_INFORMATION structure
-
-class PROCESS_INFORMATION(Structure):
-    _fields_ = [("hProcess", HANDLE),
-                ("hThread", HANDLE),
-                ("dwProcessID", DWORD),
-                ("dwThreadID", DWORD)]
-
-    def __init__(self):
-        Structure.__init__(self)
-        
-        self.cb = sizeof(self)
-
-LPPROCESS_INFORMATION = POINTER(PROCESS_INFORMATION)
-
-# STARTUPINFO structure
-
-class STARTUPINFO(Structure):
-    _fields_ = [("cb", DWORD),
-                ("lpReserved", LPWSTR),
-                ("lpDesktop", LPWSTR),
-                ("lpTitle", LPWSTR),
-                ("dwX", DWORD),
-                ("dwY", DWORD),
-                ("dwXSize", DWORD),
-                ("dwYSize", DWORD),
-                ("dwXCountChars", DWORD),
-                ("dwYCountChars", DWORD),
-                ("dwFillAttribute", DWORD),
-                ("dwFlags", DWORD),
-                ("wShowWindow", WORD),
-                ("cbReserved2", WORD),
-                ("lpReserved2", LPBYTE),
-                ("hStdInput", HANDLE),
-                ("hStdOutput", HANDLE),
-                ("hStdError", HANDLE)
-                ]
-LPSTARTUPINFO = POINTER(STARTUPINFO)
-
-STARTF_USESHOWWINDOW    = 0x01
-STARTF_USESIZE          = 0x02
-STARTF_USEPOSITION      = 0x04
-STARTF_USECOUNTCHARS    = 0x08
-STARTF_USEFILLATTRIBUTE = 0x10
-STARTF_RUNFULLSCREEN    = 0x20
-STARTF_FORCEONFEEDBACK  = 0x40
-STARTF_FORCEOFFFEEDBACK = 0x80
-STARTF_USESTDHANDLES    = 0x100
-
-# EnvironmentBlock
-
-class EnvironmentBlock:
-    """An object which can be passed as the lpEnv parameter of CreateProcess.
-    It is initialized with a dictionary."""
-
-    def __init__(self, dict):
-        if not dict:
-            self._as_parameter_ = None
-        else:
-            values = ["%s=%s" % (key, value)
-                      for (key, value) in dict.iteritems()]
-            values.append("")
-            self._as_parameter_ = LPCWSTR("\0".join(values))
-        
-# CreateProcess()
-
-CreateProcessProto = WINFUNCTYPE(BOOL,                  # Return type
-                                 LPCWSTR,               # lpApplicationName
-                                 LPWSTR,                # lpCommandLine
-                                 LPVOID,                # lpProcessAttributes
-                                 LPVOID,                # lpThreadAttributes
-                                 BOOL,                  # bInheritHandles
-                                 DWORD,                 # dwCreationFlags
-                                 LPVOID,                # lpEnvironment
-                                 LPCWSTR,               # lpCurrentDirectory
-                                 LPSTARTUPINFO,         # lpStartupInfo
-                                 LPPROCESS_INFORMATION  # lpProcessInformation
-                                 )
-
-CreateProcessFlags = ((1, "lpApplicationName", None),
-                      (1, "lpCommandLine"),
-                      (1, "lpProcessAttributes", None),
-                      (1, "lpThreadAttributes", None),
-                      (1, "bInheritHandles", True),
-                      (1, "dwCreationFlags", 0),
-                      (1, "lpEnvironment", None),
-                      (1, "lpCurrentDirectory", None),
-                      (1, "lpStartupInfo"),
-                      (2, "lpProcessInformation"))
-
-def ErrCheckCreateProcess(result, func, args):
-    ErrCheckBool(result, func, args)
-    # return a tuple (hProcess, hThread, dwProcessID, dwThreadID)
-    pi = args[9]
-    return AutoHANDLE(pi.hProcess), AutoHANDLE(pi.hThread), pi.dwProcessID, pi.dwThreadID
-
-CreateProcess = CreateProcessProto(("CreateProcessW", windll.kernel32),
-                                   CreateProcessFlags)
-CreateProcess.errcheck = ErrCheckCreateProcess
-
-CREATE_BREAKAWAY_FROM_JOB = 0x01000000
-CREATE_DEFAULT_ERROR_MODE = 0x04000000
-CREATE_NEW_CONSOLE = 0x00000010
-CREATE_NEW_PROCESS_GROUP = 0x00000200
-CREATE_NO_WINDOW = 0x08000000
-CREATE_SUSPENDED = 0x00000004
-CREATE_UNICODE_ENVIRONMENT = 0x00000400
-DEBUG_ONLY_THIS_PROCESS = 0x00000002
-DEBUG_PROCESS = 0x00000001
-DETACHED_PROCESS = 0x00000008
-
-# CreateJobObject()
-
-CreateJobObjectProto = WINFUNCTYPE(HANDLE,             # Return type
-                                   LPVOID,             # lpJobAttributes
-                                   LPCWSTR             # lpName
-                                   )
-
-CreateJobObjectFlags = ((1, "lpJobAttributes", None),
-                        (1, "lpName", None))
-
-CreateJobObject = CreateJobObjectProto(("CreateJobObjectW", windll.kernel32),
-                                       CreateJobObjectFlags)
-CreateJobObject.errcheck = ErrCheckHandle
-
-# AssignProcessToJobObject()
-
-AssignProcessToJobObjectProto = WINFUNCTYPE(BOOL,      # Return type
-                                            HANDLE,    # hJob
-                                            HANDLE     # hProcess
-                                            )
-AssignProcessToJobObjectFlags = ((1, "hJob"),
-                                 (1, "hProcess"))
-AssignProcessToJobObject = AssignProcessToJobObjectProto(
-    ("AssignProcessToJobObject", windll.kernel32),
-    AssignProcessToJobObjectFlags)
-AssignProcessToJobObject.errcheck = ErrCheckBool
-
-# ResumeThread()
-
-def ErrCheckResumeThread(result, func, args):
-    if result == -1:
-        raise WinError()
-
-    return args
-
-ResumeThreadProto = WINFUNCTYPE(DWORD,      # Return type
-                                HANDLE      # hThread
-                                )
-ResumeThreadFlags = ((1, "hThread"),)
-ResumeThread = ResumeThreadProto(("ResumeThread", windll.kernel32),
-                                 ResumeThreadFlags)
-ResumeThread.errcheck = ErrCheckResumeThread
-
-# TerminateJobObject()
-
-TerminateJobObjectProto = WINFUNCTYPE(BOOL,   # Return type
-                                      HANDLE, # hJob
-                                      UINT    # uExitCode
-                                      )
-TerminateJobObjectFlags = ((1, "hJob"),
-                           (1, "uExitCode", 127))
-TerminateJobObject = TerminateJobObjectProto(
-    ("TerminateJobObject", windll.kernel32),
-    TerminateJobObjectFlags)
-TerminateJobObject.errcheck = ErrCheckBool
-
-# WaitForSingleObject()
-
-WaitForSingleObjectProto = WINFUNCTYPE(DWORD,  # Return type
-                                       HANDLE, # hHandle
-                                       DWORD,  # dwMilliseconds
-                                       )
-WaitForSingleObjectFlags = ((1, "hHandle"),
-                            (1, "dwMilliseconds", -1))
-WaitForSingleObject = WaitForSingleObjectProto(
-    ("WaitForSingleObject", windll.kernel32),
-    WaitForSingleObjectFlags)
-
-INFINITE = -1
-WAIT_TIMEOUT = 0x0102
-WAIT_OBJECT_0 = 0x0
-WAIT_ABANDONED = 0x0080
-
-# GetExitCodeProcess()
-
-GetExitCodeProcessProto = WINFUNCTYPE(BOOL,    # Return type
-                                      HANDLE,  # hProcess
-                                      LPDWORD, # lpExitCode
-                                      )
-GetExitCodeProcessFlags = ((1, "hProcess"),
-                           (2, "lpExitCode"))
-GetExitCodeProcess = GetExitCodeProcessProto(
-    ("GetExitCodeProcess", windll.kernel32),
-    GetExitCodeProcessFlags)
-GetExitCodeProcess.errcheck = ErrCheckBool
+# A module to expose various thread/process/job related structures and
+# methods from kernel32
+#
+# The MIT License
+#
+# Copyright (c) 2006 the Mozilla Foundation <http://www.mozilla.org>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+from ctypes import c_void_p, POINTER, sizeof, Structure, windll, WinError, WINFUNCTYPE
+from ctypes.wintypes import BOOL, BYTE, DWORD, HANDLE, LPCWSTR, LPWSTR, UINT, WORD
+
+LPVOID = c_void_p
+LPBYTE = POINTER(BYTE)
+LPDWORD = POINTER(DWORD)
+
+SW_HIDE = 0
+
+def ErrCheckBool(result, func, args):
+    """errcheck function for Windows functions that return a BOOL True
+    on success"""
+    if not result:
+        raise WinError()
+    return args
+
+# CloseHandle()
+
+CloseHandleProto = WINFUNCTYPE(BOOL, HANDLE)
+CloseHandle = CloseHandleProto(("CloseHandle", windll.kernel32))
+CloseHandle.errcheck = ErrCheckBool
+
+# AutoHANDLE
+
+class AutoHANDLE(HANDLE):
+    """Subclass of HANDLE which will call CloseHandle() on deletion."""
+    def Close(self):
+        if self.value:
+            CloseHandle(self)
+            self.value = 0
+    
+    def __del__(self):
+        self.Close()
+
+    def __int__(self):
+        return self.value
+
+def ErrCheckHandle(result, func, args):
+    """errcheck function for Windows functions that return a HANDLE."""
+    if not result:
+        raise WinError()
+    return AutoHANDLE(result)
+
+# PROCESS_INFORMATION structure
+
+class PROCESS_INFORMATION(Structure):
+    _fields_ = [("hProcess", HANDLE),
+                ("hThread", HANDLE),
+                ("dwProcessID", DWORD),
+                ("dwThreadID", DWORD)]
+
+    def __init__(self):
+        Structure.__init__(self)
+        
+        self.cb = sizeof(self)
+
+LPPROCESS_INFORMATION = POINTER(PROCESS_INFORMATION)
+
+# STARTUPINFO structure
+
+class STARTUPINFO(Structure):
+    _fields_ = [("cb", DWORD),
+                ("lpReserved", LPWSTR),
+                ("lpDesktop", LPWSTR),
+                ("lpTitle", LPWSTR),
+                ("dwX", DWORD),
+                ("dwY", DWORD),
+                ("dwXSize", DWORD),
+                ("dwYSize", DWORD),
+                ("dwXCountChars", DWORD),
+                ("dwYCountChars", DWORD),
+                ("dwFillAttribute", DWORD),
+                ("dwFlags", DWORD),
+                ("wShowWindow", WORD),
+                ("cbReserved2", WORD),
+                ("lpReserved2", LPBYTE),
+                ("hStdInput", HANDLE),
+                ("hStdOutput", HANDLE),
+                ("hStdError", HANDLE)
+                ]
+LPSTARTUPINFO = POINTER(STARTUPINFO)
+
+STARTF_USESHOWWINDOW    = 0x01
+STARTF_USESIZE          = 0x02
+STARTF_USEPOSITION      = 0x04
+STARTF_USECOUNTCHARS    = 0x08
+STARTF_USEFILLATTRIBUTE = 0x10
+STARTF_RUNFULLSCREEN    = 0x20
+STARTF_FORCEONFEEDBACK  = 0x40
+STARTF_FORCEOFFFEEDBACK = 0x80
+STARTF_USESTDHANDLES    = 0x100
+
+# EnvironmentBlock
+
+class EnvironmentBlock:
+    """An object which can be passed as the lpEnv parameter of CreateProcess.
+    It is initialized with a dictionary."""
+
+    def __init__(self, dict):
+        if not dict:
+            self._as_parameter_ = None
+        else:
+            values = ["%s=%s" % (key, value)
+                      for (key, value) in dict.iteritems()]
+            values.append("")
+            self._as_parameter_ = LPCWSTR("\0".join(values))
+        
+# CreateProcess()
+
+CreateProcessProto = WINFUNCTYPE(BOOL,                  # Return type
+                                 LPCWSTR,               # lpApplicationName
+                                 LPWSTR,                # lpCommandLine
+                                 LPVOID,                # lpProcessAttributes
+                                 LPVOID,                # lpThreadAttributes
+                                 BOOL,                  # bInheritHandles
+                                 DWORD,                 # dwCreationFlags
+                                 LPVOID,                # lpEnvironment
+                                 LPCWSTR,               # lpCurrentDirectory
+                                 LPSTARTUPINFO,         # lpStartupInfo
+                                 LPPROCESS_INFORMATION  # lpProcessInformation
+                                 )
+
+CreateProcessFlags = ((1, "lpApplicationName", None),
+                      (1, "lpCommandLine"),
+                      (1, "lpProcessAttributes", None),
+                      (1, "lpThreadAttributes", None),
+                      (1, "bInheritHandles", True),
+                      (1, "dwCreationFlags", 0),
+                      (1, "lpEnvironment", None),
+                      (1, "lpCurrentDirectory", None),
+                      (1, "lpStartupInfo"),
+                      (2, "lpProcessInformation"))
+
+def ErrCheckCreateProcess(result, func, args):
+    ErrCheckBool(result, func, args)
+    # return a tuple (hProcess, hThread, dwProcessID, dwThreadID)
+    pi = args[9]
+    return AutoHANDLE(pi.hProcess), AutoHANDLE(pi.hThread), pi.dwProcessID, pi.dwThreadID
+
+CreateProcess = CreateProcessProto(("CreateProcessW", windll.kernel32),
+                                   CreateProcessFlags)
+CreateProcess.errcheck = ErrCheckCreateProcess
+
+CREATE_BREAKAWAY_FROM_JOB = 0x01000000
+CREATE_DEFAULT_ERROR_MODE = 0x04000000
+CREATE_NEW_CONSOLE = 0x00000010
+CREATE_NEW_PROCESS_GROUP = 0x00000200
+CREATE_NO_WINDOW = 0x08000000
+CREATE_SUSPENDED = 0x00000004
+CREATE_UNICODE_ENVIRONMENT = 0x00000400
+DEBUG_ONLY_THIS_PROCESS = 0x00000002
+DEBUG_PROCESS = 0x00000001
+DETACHED_PROCESS = 0x00000008
+
+# CreateJobObject()
+
+CreateJobObjectProto = WINFUNCTYPE(HANDLE,             # Return type
+                                   LPVOID,             # lpJobAttributes
+                                   LPCWSTR             # lpName
+                                   )
+
+CreateJobObjectFlags = ((1, "lpJobAttributes", None),
+                        (1, "lpName", None))
+
+CreateJobObject = CreateJobObjectProto(("CreateJobObjectW", windll.kernel32),
+                                       CreateJobObjectFlags)
+CreateJobObject.errcheck = ErrCheckHandle
+
+# AssignProcessToJobObject()
+
+AssignProcessToJobObjectProto = WINFUNCTYPE(BOOL,      # Return type
+                                            HANDLE,    # hJob
+                                            HANDLE     # hProcess
+                                            )
+AssignProcessToJobObjectFlags = ((1, "hJob"),
+                                 (1, "hProcess"))
+AssignProcessToJobObject = AssignProcessToJobObjectProto(
+    ("AssignProcessToJobObject", windll.kernel32),
+    AssignProcessToJobObjectFlags)
+AssignProcessToJobObject.errcheck = ErrCheckBool
+
+# ResumeThread()
+
+def ErrCheckResumeThread(result, func, args):
+    if result == -1:
+        raise WinError()
+
+    return args
+
+ResumeThreadProto = WINFUNCTYPE(DWORD,      # Return type
+                                HANDLE      # hThread
+                                )
+ResumeThreadFlags = ((1, "hThread"),)
+ResumeThread = ResumeThreadProto(("ResumeThread", windll.kernel32),
+                                 ResumeThreadFlags)
+ResumeThread.errcheck = ErrCheckResumeThread
+
+# TerminateJobObject()
+
+TerminateJobObjectProto = WINFUNCTYPE(BOOL,   # Return type
+                                      HANDLE, # hJob
+                                      UINT    # uExitCode
+                                      )
+TerminateJobObjectFlags = ((1, "hJob"),
+                           (1, "uExitCode", 127))
+TerminateJobObject = TerminateJobObjectProto(
+    ("TerminateJobObject", windll.kernel32),
+    TerminateJobObjectFlags)
+TerminateJobObject.errcheck = ErrCheckBool
+
+# WaitForSingleObject()
+
+WaitForSingleObjectProto = WINFUNCTYPE(DWORD,  # Return type
+                                       HANDLE, # hHandle
+                                       DWORD,  # dwMilliseconds
+                                       )
+WaitForSingleObjectFlags = ((1, "hHandle"),
+                            (1, "dwMilliseconds", -1))
+WaitForSingleObject = WaitForSingleObjectProto(
+    ("WaitForSingleObject", windll.kernel32),
+    WaitForSingleObjectFlags)
+
+INFINITE = -1
+WAIT_TIMEOUT = 0x0102
+WAIT_OBJECT_0 = 0x0
+WAIT_ABANDONED = 0x0080
+
+# GetExitCodeProcess()
+
+GetExitCodeProcessProto = WINFUNCTYPE(BOOL,    # Return type
+                                      HANDLE,  # hProcess
+                                      LPDWORD, # lpExitCode
+                                      )
+GetExitCodeProcessFlags = ((1, "hProcess"),
+                           (2, "lpExitCode"))
+GetExitCodeProcess = GetExitCodeProcessProto(
+    ("GetExitCodeProcess", windll.kernel32),
+    GetExitCodeProcessFlags)
+GetExitCodeProcess.errcheck = ErrCheckBool

IPython/deathrow/scitedirector.py

@@ -1,26 +1,26 b''
-import win32api
-import win32gui
-import win32con
-
-import struct
-import array
-
-def findWindows():
-    ret = []
-    sdi = win32api.RegisterWindowMessage("SciTEDirectorInterface")
-    w = win32gui.GetWindow(win32gui.GetDesktopWindow(), win32con.GW_CHILD)
-    while w:
-        res = win32gui.SendMessage(w, sdi, 0, 0)
-        if res == sdi:
-            ret.append(w)
-        w = win32gui.GetWindow(w, win32con.GW_HWNDNEXT)
-
-    return ret
-
-def sendCommand(w, message):
-    CopyDataStruct = "IIP"
-    char_buffer = array.array('c', message)
-    char_buffer_address = char_buffer.buffer_info()[0]
-    char_buffer_size = char_buffer.buffer_info()[1]
-    cds = struct.pack(CopyDataStruct, 0, char_buffer_size, char_buffer_address)
-    win32gui.SendMessage(w, win32con.WM_COPYDATA, 0, cds)
+import win32api
+import win32gui
+import win32con
+
+import struct
+import array
+
+def findWindows():
+    ret = []
+    sdi = win32api.RegisterWindowMessage("SciTEDirectorInterface")
+    w = win32gui.GetWindow(win32gui.GetDesktopWindow(), win32con.GW_CHILD)
+    while w:
+        res = win32gui.SendMessage(w, sdi, 0, 0)
+        if res == sdi:
+            ret.append(w)
+        w = win32gui.GetWindow(w, win32con.GW_HWNDNEXT)
+
+    return ret
+
+def sendCommand(w, message):
+    CopyDataStruct = "IIP"
+    char_buffer = array.array('c', message)
+    char_buffer_address = char_buffer.buffer_info()[0]
+    char_buffer_size = char_buffer.buffer_info()[1]
+    cds = struct.pack(CopyDataStruct, 0, char_buffer_size, char_buffer_address)
+    win32gui.SendMessage(w, win32con.WM_COPYDATA, 0, cds)

IPython/quarantine/ipy_synchronize_with.py

@@ -1,242 +1,242 b''
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import win32api
-import win32ui
-import win32console
-import dde
-import os
-import scitedirector
-
-# test to write.
-
-def set_hook(synchronize_with_editor):
-    """Set the synchronize with editor hook with a callable object.
-    
-    The callable object will be called with the following arguments when
-    IPython wants to synchronize with you favorite editor:
-    
-     - ip: a running IPython instance.
-     
-     - filename: the path of the file the editor is supposed to display.
-     
-     - lineno : the line number of the line the editor is supposed to
-     highlight.
-     
-     - columnno : the column number of the character the editor is supposed
-     to highlight.
-    """
-    ip.set_hook("synchronize_with_editor", synchronize_with_editor)
-
-
-def find_filename(filename):
-    """Return the filename to synchronize with based on """
-    filename = os.path.splitext(filename)
-    if filename[1] == ".pyc":
-        filename = (filename[0], ".py")
-    filename = "".join(filename)
-
-    if not os.path.isabs(filename):
-        filename = os.path.join(os.getcwd(), filename)
-
-    if os.path.isfile(filename):
-        return filename
-
-    return ""
-
-
-def run_command(path, command, arguments, asynchronous = True):
-    """Run a shell command and return the exit code of the command"""
-    # This is a thin wrapper around os.system that:
-    #  - Let you run command asynchronously.
-    #  - Accept spaces in command path.
-    #  - Dont throw exception if the command don't exist.
-    line = ''
-    if asynchronous:
-        line += 'start '
-        
-    try:
-        line += win32api.GetShortPathName(os.path.join(path, command) + ".exe") + " "
-    except:
-        print 'could not find: "%s"' % (os.path.join(path, command) + ".exe")
-        return -1
-        
-    line += arguments
-    r = os.system(line)
-    return r
-
-
-def sleep(milliseconds):
-    """Wait some milliseconds."""
-    # This is used to make sure the editor did its job before we reset the focus on the console.
-    win32api.Sleep(milliseconds)
-
-
-def restore_console_focus():
-    """Restore the focus to the IPython console."""
-    h = win32console.GetConsoleWindow()
-    console_window = win32ui.CreateWindowFromHandle(h)
-    console_window.SetForegroundWindow()
-    
-
-# This is the most simple example of hook:
-class GVimHook:
-    def __init__(self, path, wakeup_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        run_command(self.path, 'gvim', '--remote-silent +%d "%s"' % (lineno, filename))
-
-        sleep(self.wakeup_duration)
-
-        restore_console_focus()
-
-
-def gvim(path = r"C:\Program Files\vim\vim71", wakeup_duration = 100):
-    synchronize_with_editor = GVimHook(path, wakeup_duration)
-    set_hook(synchronize_with_editor)
-
-
-class EmacsHook:
-    def __init__(self, path, wakeup_duration, start_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-        self.start_duration = start_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        r = run_command(self.path, "emacsclient", '-n +%d:%d "%s" 2>nul' % (lineno, columnno, filename), False)
-        if r != 0:
-            run_command(self.path, 'runemacs', '--quick -f server-start +%d:%d "%s"' % (lineno, columnno, filename))
-            sleep(self.start_duration)
-        else:
-            sleep(self.wakeup_duration)
-
-        restore_console_focus()
-
-
-def emacs(path = r"C:\Program Files\emacs\bin", wakeup_duration = 100, start_duration = 2000):
-    synchronize_with_editor = EmacsHook(path, wakeup_duration, start_duration)
-    set_hook(synchronize_with_editor)
-
-
-class SciteHook:
-    def __init__(self, path, wakeup_duration, start_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-        self.start_duration = start_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        scites = scitedirector.findWindows()
-        if not scites:
-            run_command(self.path, "scite", '"-open:%s" -goto:%d' % (filename.replace("\\", "/"), lineno))
-
-            sleep(self.start_duration)
-            restore_console_focus()
-        else:
-            scite = scites[0]
-            scitedirector.sendCommand(scite, 'open:%s' % filename.replace("\\", "/"))
-            scitedirector.sendCommand(scite, "goto:%d" % lineno)
-
-
-def scite(path = r"C:\Program Files\SciTE Source Code Editor", wakeup_duration = 100, start_duration = 500):
-    synchronize_with_editor = SciteHook(path, wakeup_duration, start_duration)
-    set_hook(synchronize_with_editor)
-
-
-class NodePadPlusPlusHook:
-    def __init__(self, path, wakeup_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        run_command(self.path, "notepad++", '"%s" -n%d' % (filename, lineno))
-
-        sleep(self.wakeup_duration)
-
-        restore_console_focus()
-
-
-def notepadplusplus(path = r"C:\Program Files\Notepad++", wakeup_duration = 100):
-    synchronize_with_editor = NodePadPlusPlusHook(path, wakeup_duration)
-    set_hook(synchronize_with_editor)
-
-
-class PsPadHook:
-    def __init__(self, path, wakeup_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        run_command(self.path, "pspad", '"%s" -%d' % (filename, lineno))
-
-        sleep(self.wakeup_duration)
-
-        restore_console_focus()
-
-
-def pspad(path = r"C:\Program Files\PSPad editor", wakeup_duration = 100):
-    synchronize_with_editor = PsPadHook(path, wakeup_duration)
-    set_hook(synchronize_with_editor)
-
-
-# This is an example of DDE hook:
-class UltraEditHook:
-    def __init__(self, path, wakeup_duration, start_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-        self.start_duration = start_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        server = dde.CreateServer()
-        server.Create("myddeserver")
-        conversation = dde.CreateConversation(server)
-        try:
-            conversation.ConnectTo("uedit32", "System")
-            conversation.Exec(r'[open("%s/%d"])' % (filename, lineno))
-            
-            sleep(self.wakeup_duration)
-        except:
-            run_command(self.path, 'uedit32', '"%s/%d"' % (filename, lineno))
-            
-            sleep(self.start_duration)
-
-        server.Shutdown()
-
-        restore_console_focus()
-
-
-def ultraedit(path = r"C:\Program Files\IDM Computer Solutions\UltraEdit-32", wakeup_duration = 10, start_duration = 2000):
-    synchronize_with_editor = UltraEditHook(path, wakeup_duration, start_duration)
-    set_hook(synchronize_with_editor)
+from IPython.core import ipapi
+ip = ipapi.get()
+
+import win32api
+import win32ui
+import win32console
+import dde
+import os
+import scitedirector
+
+# test to write.
+
+def set_hook(synchronize_with_editor):
+    """Set the synchronize with editor hook with a callable object.
+    
+    The callable object will be called with the following arguments when
+    IPython wants to synchronize with you favorite editor:
+    
+     - ip: a running IPython instance.
+     
+     - filename: the path of the file the editor is supposed to display.
+     
+     - lineno : the line number of the line the editor is supposed to
+     highlight.
+     
+     - columnno : the column number of the character the editor is supposed
+     to highlight.
+    """
+    ip.set_hook("synchronize_with_editor", synchronize_with_editor)
+
+
+def find_filename(filename):
+    """Return the filename to synchronize with based on """
+    filename = os.path.splitext(filename)
+    if filename[1] == ".pyc":
+        filename = (filename[0], ".py")
+    filename = "".join(filename)
+
+    if not os.path.isabs(filename):
+        filename = os.path.join(os.getcwd(), filename)
+
+    if os.path.isfile(filename):
+        return filename
+
+    return ""
+
+
+def run_command(path, command, arguments, asynchronous = True):
+    """Run a shell command and return the exit code of the command"""
+    # This is a thin wrapper around os.system that:
+    #  - Let you run command asynchronously.
+    #  - Accept spaces in command path.
+    #  - Dont throw exception if the command don't exist.
+    line = ''
+    if asynchronous:
+        line += 'start '
+        
+    try:
+        line += win32api.GetShortPathName(os.path.join(path, command) + ".exe") + " "
+    except:
+        print 'could not find: "%s"' % (os.path.join(path, command) + ".exe")
+        return -1
+        
+    line += arguments
+    r = os.system(line)
+    return r
+
+
+def sleep(milliseconds):
+    """Wait some milliseconds."""
+    # This is used to make sure the editor did its job before we reset the focus on the console.
+    win32api.Sleep(milliseconds)
+
+
+def restore_console_focus():
+    """Restore the focus to the IPython console."""
+    h = win32console.GetConsoleWindow()
+    console_window = win32ui.CreateWindowFromHandle(h)
+    console_window.SetForegroundWindow()
+    
+
+# This is the most simple example of hook:
+class GVimHook:
+    def __init__(self, path, wakeup_duration):
+        self.path = path
+        self.wakeup_duration = wakeup_duration
+
+    def __call__(self, ip, filename, lineno, columnno):
+        filename = find_filename(filename)
+
+        if not filename:
+            return
+
+        run_command(self.path, 'gvim', '--remote-silent +%d "%s"' % (lineno, filename))
+
+        sleep(self.wakeup_duration)
+
+        restore_console_focus()
+
+
+def gvim(path = r"C:\Program Files\vim\vim71", wakeup_duration = 100):
+    synchronize_with_editor = GVimHook(path, wakeup_duration)
+    set_hook(synchronize_with_editor)
+
+
+class EmacsHook:
+    def __init__(self, path, wakeup_duration, start_duration):
+        self.path = path
+        self.wakeup_duration = wakeup_duration
+        self.start_duration = start_duration
+
+    def __call__(self, ip, filename, lineno, columnno):
+        filename = find_filename(filename)
+
+        if not filename:
+            return
+
+        r = run_command(self.path, "emacsclient", '-n +%d:%d "%s" 2>nul' % (lineno, columnno, filename), False)
+        if r != 0:
+            run_command(self.path, 'runemacs', '--quick -f server-start +%d:%d "%s"' % (lineno, columnno, filename))
+            sleep(self.start_duration)
+        else:
+            sleep(self.wakeup_duration)
+
+        restore_console_focus()
+
+
+def emacs(path = r"C:\Program Files\emacs\bin", wakeup_duration = 100, start_duration = 2000):
+    synchronize_with_editor = EmacsHook(path, wakeup_duration, start_duration)
+    set_hook(synchronize_with_editor)
+
+
+class SciteHook:
+    def __init__(self, path, wakeup_duration, start_duration):
+        self.path = path
+        self.wakeup_duration = wakeup_duration
+        self.start_duration = start_duration
+
+    def __call__(self, ip, filename, lineno, columnno):
+        filename = find_filename(filename)
+
+        if not filename:
+            return
+
+        scites = scitedirector.findWindows()
+        if not scites:
+            run_command(self.path, "scite", '"-open:%s" -goto:%d' % (filename.replace("\\", "/"), lineno))
+
+            sleep(self.start_duration)
+            restore_console_focus()
+        else:
+            scite = scites[0]
+            scitedirector.sendCommand(scite, 'open:%s' % filename.replace("\\", "/"))
+            scitedirector.sendCommand(scite, "goto:%d" % lineno)
+
+
+def scite(path = r"C:\Program Files\SciTE Source Code Editor", wakeup_duration = 100, start_duration = 500):
+    synchronize_with_editor = SciteHook(path, wakeup_duration, start_duration)
+    set_hook(synchronize_with_editor)
+
+
+class NodePadPlusPlusHook:
+    def __init__(self, path, wakeup_duration):
+        self.path = path
+        self.wakeup_duration = wakeup_duration
+
+    def __call__(self, ip, filename, lineno, columnno):
+        filename = find_filename(filename)
+
+        if not filename:
+            return
+
+        run_command(self.path, "notepad++", '"%s" -n%d' % (filename, lineno))
+
+        sleep(self.wakeup_duration)
+
+        restore_console_focus()
+
+
+def notepadplusplus(path = r"C:\Program Files\Notepad++", wakeup_duration = 100):
+    synchronize_with_editor = NodePadPlusPlusHook(path, wakeup_duration)
+    set_hook(synchronize_with_editor)
+
+
+class PsPadHook:
+    def __init__(self, path, wakeup_duration):
+        self.path = path
+        self.wakeup_duration = wakeup_duration
+
+    def __call__(self, ip, filename, lineno, columnno):
+        filename = find_filename(filename)
+
+        if not filename:
+            return
+
+        run_command(self.path, "pspad", '"%s" -%d' % (filename, lineno))
+
+        sleep(self.wakeup_duration)
+
+        restore_console_focus()
+
+
+def pspad(path = r"C:\Program Files\PSPad editor", wakeup_duration = 100):
+    synchronize_with_editor = PsPadHook(path, wakeup_duration)
+    set_hook(synchronize_with_editor)
+
+
+# This is an example of DDE hook:
+class UltraEditHook:
+    def __init__(self, path, wakeup_duration, start_duration):
+        self.path = path
+        self.wakeup_duration = wakeup_duration
+        self.start_duration = start_duration
+
+    def __call__(self, ip, filename, lineno, columnno):
+        filename = find_filename(filename)
+
+        if not filename:
+            return
+
+        server = dde.CreateServer()
+        server.Create("myddeserver")
+        conversation = dde.CreateConversation(server)
+        try:
+            conversation.ConnectTo("uedit32", "System")
+            conversation.Exec(r'[open("%s/%d"])' % (filename, lineno))
+            
+            sleep(self.wakeup_duration)
+        except:
+            run_command(self.path, 'uedit32', '"%s/%d"' % (filename, lineno))
+            
+            sleep(self.start_duration)
+
+        server.Shutdown()
+
+        restore_console_focus()
+
+
+def ultraedit(path = r"C:\Program Files\IDM Computer Solutions\UltraEdit-32", wakeup_duration = 10, start_duration = 2000):
+    synchronize_with_editor = UltraEditHook(path, wakeup_duration, start_duration)
+    set_hook(synchronize_with_editor)
     
  No newline at end of file