diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index f8c268e..04107ac 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -35,66 +35,66 @@
 
 /*
 
-A number of SysV or ncurses functions don't have wrappers yet; if you
-need a given function, add it and send a patch.  See
-http://www.python.org/dev/patches/ for instructions on how to submit
-patches to Python.
+  A number of SysV or ncurses functions don't have wrappers yet; if you
+  need a given function, add it and send a patch.  See
+  http://www.python.org/dev/patches/ for instructions on how to submit
+  patches to Python.
 
-Here's a list of currently unsupported functions:
+  Here's a list of currently unsupported functions:
 
-	addchnstr addchstr color_set define_key
-	del_curterm delscreen dupwin inchnstr inchstr innstr keyok
-	mcprint mvaddchnstr mvaddchstr mvcur mvinchnstr
-	mvinchstr mvinnstr mmvwaddchnstr mvwaddchstr 
-	mvwinchnstr mvwinchstr mvwinnstr newterm
-	restartterm ripoffline scr_dump
-	scr_init scr_restore scr_set scrl set_curterm set_term setterm
-	tgetent tgetflag tgetnum tgetstr tgoto timeout tputs
-	vidattr vidputs waddchnstr waddchstr
-	wcolor_set winchnstr winchstr winnstr wmouse_trafo wscrl
+  addchnstr addchstr color_set define_key
+  del_curterm delscreen dupwin inchnstr inchstr innstr keyok
+  mcprint mvaddchnstr mvaddchstr mvcur mvinchnstr
+  mvinchstr mvinnstr mmvwaddchnstr mvwaddchstr
+  mvwinchnstr mvwinchstr mvwinnstr newterm
+  restartterm ripoffline scr_dump
+  scr_init scr_restore scr_set scrl set_curterm set_term setterm
+  tgetent tgetflag tgetnum tgetstr tgoto timeout tputs
+  vidattr vidputs waddchnstr waddchstr
+  wcolor_set winchnstr winchstr winnstr wmouse_trafo wscrl
 
-Low-priority: 
-	slk_attr slk_attr_off slk_attr_on slk_attr_set slk_attroff
-	slk_attron slk_attrset slk_clear slk_color slk_init slk_label
-	slk_noutrefresh slk_refresh slk_restore slk_set slk_touch
+  Low-priority:
+  slk_attr slk_attr_off slk_attr_on slk_attr_set slk_attroff
+  slk_attron slk_attrset slk_clear slk_color slk_init slk_label
+  slk_noutrefresh slk_refresh slk_restore slk_set slk_touch
 
-Menu extension (ncurses and probably SYSV):
-	current_item free_item free_menu item_count item_description
-	item_index item_init item_name item_opts item_opts_off
-	item_opts_on item_term item_userptr item_value item_visible
-	menu_back menu_driver menu_fore menu_format menu_grey
-	menu_init menu_items menu_mark menu_opts menu_opts_off
-	menu_opts_on menu_pad menu_pattern menu_request_by_name
-	menu_request_name menu_spacing menu_sub menu_term menu_userptr
-	menu_win new_item new_menu pos_menu_cursor post_menu
-	scale_menu set_current_item set_item_init set_item_opts
-	set_item_term set_item_userptr set_item_value set_menu_back
-	set_menu_fore set_menu_format set_menu_grey set_menu_init
-	set_menu_items set_menu_mark set_menu_opts set_menu_pad
-	set_menu_pattern set_menu_spacing set_menu_sub set_menu_term
-	set_menu_userptr set_menu_win set_top_row top_row unpost_menu
+  Menu extension (ncurses and probably SYSV):
+  current_item free_item free_menu item_count item_description
+  item_index item_init item_name item_opts item_opts_off
+  item_opts_on item_term item_userptr item_value item_visible
+  menu_back menu_driver menu_fore menu_format menu_grey
+  menu_init menu_items menu_mark menu_opts menu_opts_off
+  menu_opts_on menu_pad menu_pattern menu_request_by_name
+  menu_request_name menu_spacing menu_sub menu_term menu_userptr
+  menu_win new_item new_menu pos_menu_cursor post_menu
+  scale_menu set_current_item set_item_init set_item_opts
+  set_item_term set_item_userptr set_item_value set_menu_back
+  set_menu_fore set_menu_format set_menu_grey set_menu_init
+  set_menu_items set_menu_mark set_menu_opts set_menu_pad
+  set_menu_pattern set_menu_spacing set_menu_sub set_menu_term
+  set_menu_userptr set_menu_win set_top_row top_row unpost_menu
 
-Form extension (ncurses and probably SYSV):
-	current_field data_ahead data_behind dup_field
-	dynamic_fieldinfo field_arg field_back field_buffer
-	field_count field_fore field_index field_info field_init
-	field_just field_opts field_opts_off field_opts_on field_pad
-	field_status field_term field_type field_userptr form_driver
-	form_fields form_init form_opts form_opts_off form_opts_on
-	form_page form_request_by_name form_request_name form_sub
-	form_term form_userptr form_win free_field free_form
-	link_field link_fieldtype move_field new_field new_form
-	new_page pos_form_cursor post_form scale_form
-	set_current_field set_field_back set_field_buffer
-	set_field_fore set_field_init set_field_just set_field_opts
-	set_field_pad set_field_status set_field_term set_field_type
-	set_field_userptr set_fieldtype_arg set_fieldtype_choice
-	set_form_fields set_form_init set_form_opts set_form_page
-	set_form_sub set_form_term set_form_userptr set_form_win
-	set_max_field set_new_page unpost_form
+  Form extension (ncurses and probably SYSV):
+  current_field data_ahead data_behind dup_field
+  dynamic_fieldinfo field_arg field_back field_buffer
+  field_count field_fore field_index field_info field_init
+  field_just field_opts field_opts_off field_opts_on field_pad
+  field_status field_term field_type field_userptr form_driver
+  form_fields form_init form_opts form_opts_off form_opts_on
+  form_page form_request_by_name form_request_name form_sub
+  form_term form_userptr form_win free_field free_form
+  link_field link_fieldtype move_field new_field new_form
+  new_page pos_form_cursor post_form scale_form
+  set_current_field set_field_back set_field_buffer
+  set_field_fore set_field_init set_field_just set_field_opts
+  set_field_pad set_field_status set_field_term set_field_type
+  set_field_userptr set_fieldtype_arg set_fieldtype_choice
+  set_form_fields set_form_init set_form_opts set_form_page
+  set_form_sub set_form_term set_form_userptr set_form_win
+  set_max_field set_new_page unpost_form
 
 
- */
+*/
 
 /* Release Number */
 
@@ -116,9 +116,9 @@
 #define CURSES_MODULE
 #include "py_curses.h"
 
-/*  These prototypes are in <term.h>, but including this header 
-    #defines many common symbols (such as "lines") which breaks the 
-    curses module in other ways.  So the code will just specify 
+/*  These prototypes are in <term.h>, but including this header
+    #defines many common symbols (such as "lines") which breaks the
+    curses module in other ways.  So the code will just specify
     explicit prototypes here. */
 extern int setupterm(char *,int,int *);
 #ifdef __sgi
@@ -148,23 +148,23 @@
 static int initialisedcolors = FALSE;
 
 /* Utility Macros */
-#define PyCursesSetupTermCalled \
-  if (initialised_setupterm != TRUE) { \
-                  PyErr_SetString(PyCursesError, \
-                                  "must call (at least) setupterm() first"); \
-                  return 0; }
+#define PyCursesSetupTermCalled                                         \
+    if (initialised_setupterm != TRUE) {                                \
+        PyErr_SetString(PyCursesError,                                  \
+                        "must call (at least) setupterm() first");      \
+        return 0; }
 
-#define PyCursesInitialised \
-  if (initialised != TRUE) { \
-                  PyErr_SetString(PyCursesError, \
-                                  "must call initscr() first"); \
-                  return 0; }
+#define PyCursesInitialised                             \
+    if (initialised != TRUE) {                          \
+        PyErr_SetString(PyCursesError,                  \
+                        "must call initscr() first");   \
+        return 0; }
 
-#define PyCursesInitialisedColor \
-  if (initialisedcolors != TRUE) { \
-                  PyErr_SetString(PyCursesError, \
-                                  "must call start_color() first"); \
-                  return 0; }
+#define PyCursesInitialisedColor                                \
+    if (initialisedcolors != TRUE) {                            \
+        PyErr_SetString(PyCursesError,                          \
+                        "must call start_color() first");       \
+        return 0; }
 
 #ifndef MIN
 #define MIN(x,y) ((x) < (y) ? (x) : (y))
@@ -173,51 +173,51 @@
 /* Utility Functions */
 
 /*
- * Check the return code from a curses function and return None 
+ * Check the return code from a curses function and return None
  * or raise an exception as appropriate.  These are exported using the
- * capsule API. 
+ * capsule API.
  */
 
 static PyObject *
 PyCursesCheckERR(int code, char *fname)
 {
-  if (code != ERR) {
-    Py_INCREF(Py_None);
-    return Py_None;
-  } else {
-    if (fname == NULL) {
-      PyErr_SetString(PyCursesError, catchall_ERR);
+    if (code != ERR) {
+        Py_INCREF(Py_None);
+        return Py_None;
     } else {
-      PyErr_Format(PyCursesError, "%s() returned ERR", fname);
+        if (fname == NULL) {
+            PyErr_SetString(PyCursesError, catchall_ERR);
+        } else {
+            PyErr_Format(PyCursesError, "%s() returned ERR", fname);
+        }
+        return NULL;
     }
-    return NULL;
-  }
 }
 
-static int 
+static int
 PyCurses_ConvertToChtype(PyObject *obj, chtype *ch)
 {
-  if (PyLong_CheckExact(obj)) {
-    int overflow;
-    /* XXX should the truncation by the cast also be reported
-       as an error? */
-    *ch = (chtype) PyLong_AsLongAndOverflow(obj, &overflow);
-    if (overflow)
-      return 0;
-  } else if(PyBytes_Check(obj) 
-	    && (PyBytes_Size(obj) == 1)) {
-    *ch = (chtype) *PyBytes_AsString(obj);
-  } else if (PyUnicode_Check(obj) && PyUnicode_GetSize(obj) == 1) {
-    *ch = (chtype) *PyUnicode_AS_UNICODE(obj);
-  } else {
-    return 0;
-  }
-  return 1;
+    if (PyLong_CheckExact(obj)) {
+        int overflow;
+        /* XXX should the truncation by the cast also be reported
+           as an error? */
+        *ch = (chtype) PyLong_AsLongAndOverflow(obj, &overflow);
+        if (overflow)
+            return 0;
+    } else if(PyBytes_Check(obj)
+              && (PyBytes_Size(obj) == 1)) {
+        *ch = (chtype) *PyBytes_AsString(obj);
+    } else if (PyUnicode_Check(obj) && PyUnicode_GetSize(obj) == 1) {
+        *ch = (chtype) *PyUnicode_AS_UNICODE(obj);
+    } else {
+        return 0;
+    }
+    return 1;
 }
 
 /* Function versions of the 3 functions for tested whether curses has been
    initialised or not. */
-   
+
 static int func_PyCursesSetupTermCalled(void)
 {
     PyCursesSetupTermCalled;
@@ -250,49 +250,49 @@
    TYPE - parameter Type
    ERGSTR - format string for construction of the return value
    PARSESTR - format string for argument parsing
-   */
+*/
 
-#define Window_NoArgNoReturnFunction(X) \
-static PyObject *PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
-{ return PyCursesCheckERR(X(self->win), # X); }
+#define Window_NoArgNoReturnFunction(X)                                 \
+    static PyObject *PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
+    { return PyCursesCheckERR(X(self->win), # X); }
 
-#define Window_NoArgTrueFalseFunction(X) \
-static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
-{ \
-  if (X (self->win) == FALSE) { Py_INCREF(Py_False); return Py_False; } \
-  else { Py_INCREF(Py_True); return Py_True; } }
+#define Window_NoArgTrueFalseFunction(X)                                \
+    static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
+    {                                                                   \
+        if (X (self->win) == FALSE) { Py_INCREF(Py_False); return Py_False; } \
+        else { Py_INCREF(Py_True); return Py_True; } }
 
-#define Window_NoArgNoReturnVoidFunction(X) \
-static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
-{ \
-  X(self->win); Py_INCREF(Py_None); return Py_None; }
+#define Window_NoArgNoReturnVoidFunction(X)                             \
+    static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
+    {                                                                   \
+        X(self->win); Py_INCREF(Py_None); return Py_None; }
 
-#define Window_NoArg2TupleReturnFunction(X, TYPE, ERGSTR) \
-static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
-{ \
-  TYPE arg1, arg2; \
-  X(self->win,arg1,arg2); return Py_BuildValue(ERGSTR, arg1, arg2); } 
+#define Window_NoArg2TupleReturnFunction(X, TYPE, ERGSTR)               \
+    static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
+    {                                                                   \
+        TYPE arg1, arg2;                                                \
+        X(self->win,arg1,arg2); return Py_BuildValue(ERGSTR, arg1, arg2); }
 
-#define Window_OneArgNoReturnVoidFunction(X, TYPE, PARSESTR) \
-static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
-{ \
-  TYPE arg1; \
-  if (!PyArg_ParseTuple(args, PARSESTR, &arg1)) return NULL; \
-  X(self->win,arg1); Py_INCREF(Py_None); return Py_None; }
+#define Window_OneArgNoReturnVoidFunction(X, TYPE, PARSESTR)            \
+    static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
+    {                                                                   \
+        TYPE arg1;                                                      \
+        if (!PyArg_ParseTuple(args, PARSESTR, &arg1)) return NULL;      \
+        X(self->win,arg1); Py_INCREF(Py_None); return Py_None; }
 
-#define Window_OneArgNoReturnFunction(X, TYPE, PARSESTR) \
-static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
-{ \
-  TYPE arg1; \
-  if (!PyArg_ParseTuple(args,PARSESTR, &arg1)) return NULL; \
-  return PyCursesCheckERR(X(self->win, arg1), # X); }
+#define Window_OneArgNoReturnFunction(X, TYPE, PARSESTR)                \
+    static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
+    {                                                                   \
+        TYPE arg1;                                                      \
+        if (!PyArg_ParseTuple(args,PARSESTR, &arg1)) return NULL;       \
+        return PyCursesCheckERR(X(self->win, arg1), # X); }
 
-#define Window_TwoArgNoReturnFunction(X, TYPE, PARSESTR) \
-static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
-{ \
-  TYPE arg1, arg2; \
-  if (!PyArg_ParseTuple(args,PARSESTR, &arg1, &arg2)) return NULL; \
-  return PyCursesCheckERR(X(self->win, arg1, arg2), # X); }
+#define Window_TwoArgNoReturnFunction(X, TYPE, PARSESTR)                \
+    static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
+    {                                                                   \
+        TYPE arg1, arg2;                                                \
+        if (!PyArg_ParseTuple(args,PARSESTR, &arg1, &arg2)) return NULL; \
+        return PyCursesCheckERR(X(self->win, arg1, arg2), # X); }
 
 /* ------------- WINDOW routines --------------- */
 
@@ -353,19 +353,19 @@
 static PyObject *
 PyCursesWindow_New(WINDOW *win)
 {
-	PyCursesWindowObject *wo;
+    PyCursesWindowObject *wo;
 
-	wo = PyObject_NEW(PyCursesWindowObject, &PyCursesWindow_Type);
-	if (wo == NULL) return NULL;
-	wo->win = win;
-	return (PyObject *)wo;
+    wo = PyObject_NEW(PyCursesWindowObject, &PyCursesWindow_Type);
+    if (wo == NULL) return NULL;
+    wo->win = win;
+    return (PyObject *)wo;
 }
 
 static void
 PyCursesWindow_Dealloc(PyCursesWindowObject *wo)
 {
-  if (wo->win != stdscr) delwin(wo->win);
-  PyObject_DEL(wo);
+    if (wo->win != stdscr) delwin(wo->win);
+    PyObject_DEL(wo);
 }
 
 /* Addch, Addstr, Addnstr */
@@ -373,287 +373,287 @@
 static PyObject *
 PyCursesWindow_AddCh(PyCursesWindowObject *self, PyObject *args)
 {
-  int rtn, x, y, use_xy = FALSE;
-  PyObject *temp;
-  chtype ch = 0;
-  attr_t attr = A_NORMAL;
-  long lattr;
-  
-  switch (PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
-	  return NULL;
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &lattr))
-      return NULL;
-    attr = lattr;
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))
-      return NULL;
-    use_xy = TRUE;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr", 
-		     &y, &x, &temp, &lattr))
-      return NULL;
-    attr = lattr;
-    use_xy = TRUE;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "addch requires 1 to 4 arguments");
-    return NULL;
-  }
+    int rtn, x, y, use_xy = FALSE;
+    PyObject *temp;
+    chtype ch = 0;
+    attr_t attr = A_NORMAL;
+    long lattr;
 
-  if (!PyCurses_ConvertToChtype(temp, &ch)) {
-    PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");
-    return NULL;
-  }
-  
-  if (use_xy == TRUE)
-    rtn = mvwaddch(self->win,y,x, ch | attr);
-  else {
-    rtn = waddch(self->win, ch | attr);
-  }
-  return PyCursesCheckERR(rtn, "addch");
+    switch (PyTuple_Size(args)) {
+    case 1:
+        if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
+            return NULL;
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &lattr))
+            return NULL;
+        attr = lattr;
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))
+            return NULL;
+        use_xy = TRUE;
+        break;
+    case 4:
+        if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr",
+                              &y, &x, &temp, &lattr))
+            return NULL;
+        attr = lattr;
+        use_xy = TRUE;
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "addch requires 1 to 4 arguments");
+        return NULL;
+    }
+
+    if (!PyCurses_ConvertToChtype(temp, &ch)) {
+        PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");
+        return NULL;
+    }
+
+    if (use_xy == TRUE)
+        rtn = mvwaddch(self->win,y,x, ch | attr);
+    else {
+        rtn = waddch(self->win, ch | attr);
+    }
+    return PyCursesCheckERR(rtn, "addch");
 }
 
 static PyObject *
 PyCursesWindow_AddStr(PyCursesWindowObject *self, PyObject *args)
 {
-  int rtn;
-  int x, y;
-  char *str;
-  attr_t attr = A_NORMAL , attr_old = A_NORMAL;
-  long lattr;
-  int use_xy = FALSE, use_attr = FALSE;
+    int rtn;
+    int x, y;
+    char *str;
+    attr_t attr = A_NORMAL , attr_old = A_NORMAL;
+    long lattr;
+    int use_xy = FALSE, use_attr = FALSE;
 
-  switch (PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args,"s;str", &str))
-      return NULL;
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))
-      return NULL;
-    attr = lattr;
-    use_attr = TRUE;
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args,"iis;int,int,str", &y, &x, &str))
-      return NULL;
-    use_xy = TRUE;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args,"iisl;int,int,str,attr", &y, &x, &str, &lattr))
-      return NULL;
-    attr = lattr;
-    use_xy = use_attr = TRUE;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "addstr requires 1 to 4 arguments");
-    return NULL;
-  }
+    switch (PyTuple_Size(args)) {
+    case 1:
+        if (!PyArg_ParseTuple(args,"s;str", &str))
+            return NULL;
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))
+            return NULL;
+        attr = lattr;
+        use_attr = TRUE;
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args,"iis;int,int,str", &y, &x, &str))
+            return NULL;
+        use_xy = TRUE;
+        break;
+    case 4:
+        if (!PyArg_ParseTuple(args,"iisl;int,int,str,attr", &y, &x, &str, &lattr))
+            return NULL;
+        attr = lattr;
+        use_xy = use_attr = TRUE;
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "addstr requires 1 to 4 arguments");
+        return NULL;
+    }
 
-  if (use_attr == TRUE) {
-    attr_old = getattrs(self->win);
-    (void)wattrset(self->win,attr);
-  }
-  if (use_xy == TRUE)
-    rtn = mvwaddstr(self->win,y,x,str);
-  else
-    rtn = waddstr(self->win,str);
-  if (use_attr == TRUE)
-    (void)wattrset(self->win,attr_old);
-  return PyCursesCheckERR(rtn, "addstr");
+    if (use_attr == TRUE) {
+        attr_old = getattrs(self->win);
+        (void)wattrset(self->win,attr);
+    }
+    if (use_xy == TRUE)
+        rtn = mvwaddstr(self->win,y,x,str);
+    else
+        rtn = waddstr(self->win,str);
+    if (use_attr == TRUE)
+        (void)wattrset(self->win,attr_old);
+    return PyCursesCheckERR(rtn, "addstr");
 }
 
 static PyObject *
 PyCursesWindow_AddNStr(PyCursesWindowObject *self, PyObject *args)
 {
-  int rtn, x, y, n;
-  char *str;
-  attr_t attr = A_NORMAL , attr_old = A_NORMAL;
-  long lattr;
-  int use_xy = FALSE, use_attr = FALSE;
+    int rtn, x, y, n;
+    char *str;
+    attr_t attr = A_NORMAL , attr_old = A_NORMAL;
+    long lattr;
+    int use_xy = FALSE, use_attr = FALSE;
 
-  switch (PyTuple_Size(args)) {
-  case 2:
-    if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))
-      return NULL;
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))
-      return NULL;
-    attr = lattr;
-    use_attr = TRUE;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))
-      return NULL;
-    use_xy = TRUE;
-    break;
-  case 5:
-    if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))
-      return NULL;
-    attr = lattr;
-    use_xy = use_attr = TRUE;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "addnstr requires 2 to 5 arguments");
-    return NULL;
-  }
+    switch (PyTuple_Size(args)) {
+    case 2:
+        if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))
+            return NULL;
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))
+            return NULL;
+        attr = lattr;
+        use_attr = TRUE;
+        break;
+    case 4:
+        if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))
+            return NULL;
+        use_xy = TRUE;
+        break;
+    case 5:
+        if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))
+            return NULL;
+        attr = lattr;
+        use_xy = use_attr = TRUE;
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "addnstr requires 2 to 5 arguments");
+        return NULL;
+    }
 
-  if (use_attr == TRUE) {
-    attr_old = getattrs(self->win);
-    (void)wattrset(self->win,attr);
-  }
-  if (use_xy == TRUE)
-    rtn = mvwaddnstr(self->win,y,x,str,n);
-  else
-    rtn = waddnstr(self->win,str,n);
-  if (use_attr == TRUE)
-    (void)wattrset(self->win,attr_old);
-  return PyCursesCheckERR(rtn, "addnstr");
+    if (use_attr == TRUE) {
+        attr_old = getattrs(self->win);
+        (void)wattrset(self->win,attr);
+    }
+    if (use_xy == TRUE)
+        rtn = mvwaddnstr(self->win,y,x,str,n);
+    else
+        rtn = waddnstr(self->win,str,n);
+    if (use_attr == TRUE)
+        (void)wattrset(self->win,attr_old);
+    return PyCursesCheckERR(rtn, "addnstr");
 }
 
 static PyObject *
 PyCursesWindow_Bkgd(PyCursesWindowObject *self, PyObject *args)
 {
-  PyObject *temp;
-  chtype bkgd;
-  attr_t attr = A_NORMAL;
-  long lattr;
+    PyObject *temp;
+    chtype bkgd;
+    attr_t attr = A_NORMAL;
+    long lattr;
 
-  switch (PyTuple_Size(args)) {
+    switch (PyTuple_Size(args)) {
     case 1:
-      if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
-        return NULL;
-      break;
+        if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
+            return NULL;
+        break;
     case 2:
-      if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))
-        return NULL;
-      attr = lattr;
-      break;
+        if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))
+            return NULL;
+        attr = lattr;
+        break;
     default:
-      PyErr_SetString(PyExc_TypeError, "bkgd requires 1 or 2 arguments");
-      return NULL;
-  }
+        PyErr_SetString(PyExc_TypeError, "bkgd requires 1 or 2 arguments");
+        return NULL;
+    }
 
-  if (!PyCurses_ConvertToChtype(temp, &bkgd)) {
-    PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");
-    return NULL;
-  }
+    if (!PyCurses_ConvertToChtype(temp, &bkgd)) {
+        PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");
+        return NULL;
+    }
 
-  return PyCursesCheckERR(wbkgd(self->win, bkgd | attr), "bkgd");
+    return PyCursesCheckERR(wbkgd(self->win, bkgd | attr), "bkgd");
 }
 
 static PyObject *
 PyCursesWindow_AttrOff(PyCursesWindowObject *self, PyObject *args)
 {
-  long lattr;
-  if (!PyArg_ParseTuple(args,"l;attr", &lattr))
-    return NULL;
-  return PyCursesCheckERR(wattroff(self->win, (attr_t)lattr), "attroff");
+    long lattr;
+    if (!PyArg_ParseTuple(args,"l;attr", &lattr))
+        return NULL;
+    return PyCursesCheckERR(wattroff(self->win, (attr_t)lattr), "attroff");
 }
 
 static PyObject *
 PyCursesWindow_AttrOn(PyCursesWindowObject *self, PyObject *args)
 {
-  long lattr;
-  if (!PyArg_ParseTuple(args,"l;attr", &lattr))
-    return NULL;
-  return PyCursesCheckERR(wattron(self->win, (attr_t)lattr), "attron");
+    long lattr;
+    if (!PyArg_ParseTuple(args,"l;attr", &lattr))
+        return NULL;
+    return PyCursesCheckERR(wattron(self->win, (attr_t)lattr), "attron");
 }
 
 static PyObject *
 PyCursesWindow_AttrSet(PyCursesWindowObject *self, PyObject *args)
 {
-  long lattr;
-  if (!PyArg_ParseTuple(args,"l;attr", &lattr))
-    return NULL;
-  return PyCursesCheckERR(wattrset(self->win, (attr_t)lattr), "attrset");
+    long lattr;
+    if (!PyArg_ParseTuple(args,"l;attr", &lattr))
+        return NULL;
+    return PyCursesCheckERR(wattrset(self->win, (attr_t)lattr), "attrset");
 }
 
 static PyObject *
 PyCursesWindow_BkgdSet(PyCursesWindowObject *self, PyObject *args)
 {
-  PyObject *temp;
-  chtype bkgd;
-  attr_t attr = A_NORMAL;
-  long lattr;
+    PyObject *temp;
+    chtype bkgd;
+    attr_t attr = A_NORMAL;
+    long lattr;
 
-  switch (PyTuple_Size(args)) {
+    switch (PyTuple_Size(args)) {
     case 1:
-      if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
-        return NULL;
-      break;
+        if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
+            return NULL;
+        break;
     case 2:
-      if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))
-        return NULL;
-      attr = lattr;
-      break;
+        if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))
+            return NULL;
+        attr = lattr;
+        break;
     default:
-      PyErr_SetString(PyExc_TypeError, "bkgdset requires 1 or 2 arguments");
-      return NULL;
-  }
+        PyErr_SetString(PyExc_TypeError, "bkgdset requires 1 or 2 arguments");
+        return NULL;
+    }
 
-  if (!PyCurses_ConvertToChtype(temp, &bkgd)) {
-    PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");
-    return NULL;
-  }
+    if (!PyCurses_ConvertToChtype(temp, &bkgd)) {
+        PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");
+        return NULL;
+    }
 
-  wbkgdset(self->win, bkgd | attr);
-  return PyCursesCheckERR(0, "bkgdset");
+    wbkgdset(self->win, bkgd | attr);
+    return PyCursesCheckERR(0, "bkgdset");
 }
 
 static PyObject *
 PyCursesWindow_Border(PyCursesWindowObject *self, PyObject *args)
 {
-  PyObject *temp[8];
-  chtype ch[8];
-  int i;
+    PyObject *temp[8];
+    chtype ch[8];
+    int i;
 
-  /* Clear the array of parameters */
-  for(i=0; i<8; i++) {
-       temp[i] = NULL;
-       ch[i] = 0;
-  }    
-  
-  if (!PyArg_ParseTuple(args,"|OOOOOOOO;ls,rs,ts,bs,tl,tr,bl,br",
-                        &temp[0], &temp[1], &temp[2], &temp[3],
-                        &temp[4], &temp[5], &temp[6], &temp[7]))
-    return NULL;
+    /* Clear the array of parameters */
+    for(i=0; i<8; i++) {
+        temp[i] = NULL;
+        ch[i] = 0;
+    }
 
-  for(i=0; i<8; i++) {
-      if (temp[i] != NULL && !PyCurses_ConvertToChtype(temp[i], &ch[i])) {
-          PyErr_Format(PyExc_TypeError,
-                       "argument %i must be a ch or an int", i+1);
-          return NULL;
-      }
-  }
-  
-  wborder(self->win,
-          ch[0], ch[1], ch[2], ch[3],
-          ch[4], ch[5], ch[6], ch[7]);
-  Py_INCREF(Py_None);
-  return Py_None;
+    if (!PyArg_ParseTuple(args,"|OOOOOOOO;ls,rs,ts,bs,tl,tr,bl,br",
+                          &temp[0], &temp[1], &temp[2], &temp[3],
+                          &temp[4], &temp[5], &temp[6], &temp[7]))
+        return NULL;
+
+    for(i=0; i<8; i++) {
+        if (temp[i] != NULL && !PyCurses_ConvertToChtype(temp[i], &ch[i])) {
+            PyErr_Format(PyExc_TypeError,
+                         "argument %i must be a ch or an int", i+1);
+            return NULL;
+        }
+    }
+
+    wborder(self->win,
+            ch[0], ch[1], ch[2], ch[3],
+            ch[4], ch[5], ch[6], ch[7]);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 PyCursesWindow_Box(PyCursesWindowObject *self, PyObject *args)
 {
-  chtype ch1=0,ch2=0;
-  switch(PyTuple_Size(args)){
-  case 0: break;
-  default:
-    if (!PyArg_ParseTuple(args,"ll;vertint,horint", &ch1, &ch2))
-      return NULL;
-  }
-  box(self->win,ch1,ch2);
-  Py_INCREF(Py_None);
-  return Py_None;
+    chtype ch1=0,ch2=0;
+    switch(PyTuple_Size(args)){
+    case 0: break;
+    default:
+        if (!PyArg_ParseTuple(args,"ll;vertint,horint", &ch1, &ch2))
+            return NULL;
+    }
+    box(self->win,ch1,ch2);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 #if defined(HAVE_NCURSES_H) || defined(MVWDELCH_IS_EXPRESSION)
@@ -661,10 +661,10 @@
 #else
 int py_mvwdelch(WINDOW *w, int y, int x)
 {
-  mvwdelch(w,y,x);
-  /* On HP/UX, mvwdelch already returns. On other systems,
-     we may well run into this return statement. */
-  return 0;
+    mvwdelch(w,y,x);
+    /* On HP/UX, mvwdelch already returns. On other systems,
+       we may well run into this return statement. */
+    return 0;
 }
 #endif
 
@@ -673,2297 +673,2297 @@
 static PyObject *
 PyCursesWindow_ChgAt(PyCursesWindowObject *self, PyObject *args)
 {
-  int rtn;
-  int x, y;
-  int num = -1;
-  short color;
-  attr_t attr = A_NORMAL;
-  long lattr;
-  int use_xy = FALSE;
+    int rtn;
+    int x, y;
+    int num = -1;
+    short color;
+    attr_t attr = A_NORMAL;
+    long lattr;
+    int use_xy = FALSE;
 
-  switch (PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args,"l;attr", &lattr))
-      return NULL;
-    attr = lattr;
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"il;n,attr", &num, &lattr))
-      return NULL;
-    attr = lattr;
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args,"iil;int,int,attr", &y, &x, &lattr))
-      return NULL;
-    attr = lattr;
-    use_xy = TRUE;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args,"iiil;int,int,n,attr", &y, &x, &num, &lattr))
-      return NULL;
-    attr = lattr;
-    use_xy = TRUE;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "chgat requires 1 to 4 arguments");
-    return NULL;
-  }
+    switch (PyTuple_Size(args)) {
+    case 1:
+        if (!PyArg_ParseTuple(args,"l;attr", &lattr))
+            return NULL;
+        attr = lattr;
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"il;n,attr", &num, &lattr))
+            return NULL;
+        attr = lattr;
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args,"iil;int,int,attr", &y, &x, &lattr))
+            return NULL;
+        attr = lattr;
+        use_xy = TRUE;
+        break;
+    case 4:
+        if (!PyArg_ParseTuple(args,"iiil;int,int,n,attr", &y, &x, &num, &lattr))
+            return NULL;
+        attr = lattr;
+        use_xy = TRUE;
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "chgat requires 1 to 4 arguments");
+        return NULL;
+    }
 
-  color = (short)((attr >> 8) & 0xff);
-  attr = attr - (color << 8);
+    color = (short)((attr >> 8) & 0xff);
+    attr = attr - (color << 8);
 
-  if (use_xy == TRUE) {
-    rtn = mvwchgat(self->win,y,x,num,attr,color,NULL);
-    touchline(self->win,y,1);
-  } else {
-    getyx(self->win,y,x);
-    rtn = wchgat(self->win,num,attr,color,NULL);
-    touchline(self->win,y,1);
-  }
-  return PyCursesCheckERR(rtn, "chgat");
+    if (use_xy == TRUE) {
+        rtn = mvwchgat(self->win,y,x,num,attr,color,NULL);
+        touchline(self->win,y,1);
+    } else {
+        getyx(self->win,y,x);
+        rtn = wchgat(self->win,num,attr,color,NULL);
+        touchline(self->win,y,1);
+    }
+    return PyCursesCheckERR(rtn, "chgat");
 }
 
 
 static PyObject *
 PyCursesWindow_DelCh(PyCursesWindowObject *self, PyObject *args)
 {
-  int rtn;
-  int x, y;
+    int rtn;
+    int x, y;
 
-  switch (PyTuple_Size(args)) {
-  case 0:
-    rtn = wdelch(self->win);
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))
-      return NULL;
-    rtn = py_mvwdelch(self->win,y,x);
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "delch requires 0 or 2 arguments");
-    return NULL;
-  }
-  return PyCursesCheckERR(rtn, "[mv]wdelch");
+    switch (PyTuple_Size(args)) {
+    case 0:
+        rtn = wdelch(self->win);
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))
+            return NULL;
+        rtn = py_mvwdelch(self->win,y,x);
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "delch requires 0 or 2 arguments");
+        return NULL;
+    }
+    return PyCursesCheckERR(rtn, "[mv]wdelch");
 }
 
 static PyObject *
 PyCursesWindow_DerWin(PyCursesWindowObject *self, PyObject *args)
 {
-  WINDOW *win;
-  int nlines, ncols, begin_y, begin_x;
+    WINDOW *win;
+    int nlines, ncols, begin_y, begin_x;
 
-  nlines = 0;
-  ncols  = 0;
-  switch (PyTuple_Size(args)) {
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))
-      return NULL;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
-		   &nlines,&ncols,&begin_y,&begin_x))
-      return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "derwin requires 2 or 4 arguments");
-    return NULL;
-  }
+    nlines = 0;
+    ncols  = 0;
+    switch (PyTuple_Size(args)) {
+    case 2:
+        if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))
+            return NULL;
+        break;
+    case 4:
+        if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
+                              &nlines,&ncols,&begin_y,&begin_x))
+            return NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "derwin requires 2 or 4 arguments");
+        return NULL;
+    }
 
-  win = derwin(self->win,nlines,ncols,begin_y,begin_x);
+    win = derwin(self->win,nlines,ncols,begin_y,begin_x);
 
-  if (win == NULL) {
-    PyErr_SetString(PyCursesError, catchall_NULL);
-    return NULL;
-  }
+    if (win == NULL) {
+        PyErr_SetString(PyCursesError, catchall_NULL);
+        return NULL;
+    }
 
-  return (PyObject *)PyCursesWindow_New(win);
+    return (PyObject *)PyCursesWindow_New(win);
 }
 
 static PyObject *
 PyCursesWindow_EchoChar(PyCursesWindowObject *self, PyObject *args)
 {
-  PyObject *temp;
-  chtype ch;
-  attr_t attr = A_NORMAL;
-  long lattr;
+    PyObject *temp;
+    chtype ch;
+    attr_t attr = A_NORMAL;
+    long lattr;
 
-  switch (PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args,"O;ch or int", &temp))
-      return NULL;
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))
-      return NULL;
-    attr = lattr;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "echochar requires 1 or 2 arguments");
+    switch (PyTuple_Size(args)) {
+    case 1:
+        if (!PyArg_ParseTuple(args,"O;ch or int", &temp))
+            return NULL;
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))
+            return NULL;
+        attr = lattr;
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "echochar requires 1 or 2 arguments");
 
 
-    return NULL;
-  }
+        return NULL;
+    }
 
-  if (!PyCurses_ConvertToChtype(temp, &ch)) {
-    PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");
-    return NULL;
-  }
-  
+    if (!PyCurses_ConvertToChtype(temp, &ch)) {
+        PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");
+        return NULL;
+    }
+
 #ifdef WINDOW_HAS_FLAGS
-  if (self->win->_flags & _ISPAD)
-    return PyCursesCheckERR(pechochar(self->win, ch | attr), 
-			    "echochar");
-  else
+    if (self->win->_flags & _ISPAD)
+        return PyCursesCheckERR(pechochar(self->win, ch | attr),
+                                "echochar");
+    else
 #endif
-    return PyCursesCheckERR(wechochar(self->win, ch | attr), 
-			    "echochar");
+        return PyCursesCheckERR(wechochar(self->win, ch | attr),
+                                "echochar");
 }
 
 #ifdef NCURSES_MOUSE_VERSION
 static PyObject *
 PyCursesWindow_Enclose(PyCursesWindowObject *self, PyObject *args)
 {
-	int x, y;
-	if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))
-		return NULL;
+    int x, y;
+    if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))
+        return NULL;
 
-	return PyLong_FromLong( wenclose(self->win,y,x) );
+    return PyLong_FromLong( wenclose(self->win,y,x) );
 }
 #endif
 
 static PyObject *
 PyCursesWindow_GetBkgd(PyCursesWindowObject *self)
 {
-  return PyLong_FromLong((long) getbkgd(self->win));
+    return PyLong_FromLong((long) getbkgd(self->win));
 }
 
 static PyObject *
 PyCursesWindow_GetCh(PyCursesWindowObject *self, PyObject *args)
 {
-  int x, y;
-  int rtn;
+    int x, y;
+    int rtn;
 
-  switch (PyTuple_Size(args)) {
-  case 0:
-    Py_BEGIN_ALLOW_THREADS
-    rtn = wgetch(self->win);
-    Py_END_ALLOW_THREADS
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
-      return NULL;
-    Py_BEGIN_ALLOW_THREADS
-    rtn = mvwgetch(self->win,y,x);
-    Py_END_ALLOW_THREADS
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "getch requires 0 or 2 arguments");
-    return NULL;
-  }
-  return PyLong_FromLong((long)rtn);
+    switch (PyTuple_Size(args)) {
+    case 0:
+        Py_BEGIN_ALLOW_THREADS
+        rtn = wgetch(self->win);
+        Py_END_ALLOW_THREADS
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
+            return NULL;
+        Py_BEGIN_ALLOW_THREADS
+        rtn = mvwgetch(self->win,y,x);
+        Py_END_ALLOW_THREADS
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "getch requires 0 or 2 arguments");
+        return NULL;
+    }
+    return PyLong_FromLong((long)rtn);
 }
 
 static PyObject *
 PyCursesWindow_GetKey(PyCursesWindowObject *self, PyObject *args)
 {
-  int x, y;
-  int rtn;
+    int x, y;
+    int rtn;
 
-  switch (PyTuple_Size(args)) {
-  case 0:
-    Py_BEGIN_ALLOW_THREADS
-    rtn = wgetch(self->win);
-    Py_END_ALLOW_THREADS
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
-      return NULL;
-    Py_BEGIN_ALLOW_THREADS
-    rtn = mvwgetch(self->win,y,x);
-    Py_END_ALLOW_THREADS
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "getkey requires 0 or 2 arguments");
-    return NULL;
-  }
-  if (rtn == ERR) {
-    /* getch() returns ERR in nodelay mode */
-    PyErr_SetString(PyCursesError, "no input");
-    return NULL;
-  } else if (rtn<=255) {
-    return Py_BuildValue("C", rtn);
-  } else {
-    const char *knp;
+    switch (PyTuple_Size(args)) {
+    case 0:
+        Py_BEGIN_ALLOW_THREADS
+        rtn = wgetch(self->win);
+        Py_END_ALLOW_THREADS
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
+            return NULL;
+        Py_BEGIN_ALLOW_THREADS
+        rtn = mvwgetch(self->win,y,x);
+        Py_END_ALLOW_THREADS
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "getkey requires 0 or 2 arguments");
+        return NULL;
+    }
+    if (rtn == ERR) {
+        /* getch() returns ERR in nodelay mode */
+        PyErr_SetString(PyCursesError, "no input");
+        return NULL;
+    } else if (rtn<=255) {
+        return Py_BuildValue("C", rtn);
+    } else {
+        const char *knp;
 #if defined(__NetBSD__)
-    knp = unctrl(rtn);
+        knp = unctrl(rtn);
 #else
-    knp = keyname(rtn);
+        knp = keyname(rtn);
 #endif
-    return PyUnicode_FromString((knp == NULL) ? "" : knp);
-  }
+        return PyUnicode_FromString((knp == NULL) ? "" : knp);
+    }
 }
 
 static PyObject *
 PyCursesWindow_GetStr(PyCursesWindowObject *self, PyObject *args)
 {
-  int x, y, n;
-  char rtn[1024]; /* This should be big enough.. I hope */
-  int rtn2;
+    int x, y, n;
+    char rtn[1024]; /* This should be big enough.. I hope */
+    int rtn2;
 
-  switch (PyTuple_Size(args)) {
-  case 0:
-    Py_BEGIN_ALLOW_THREADS
-    rtn2 = wgetnstr(self->win,rtn, 1023);
-    Py_END_ALLOW_THREADS
-    break;
-  case 1:
-    if (!PyArg_ParseTuple(args,"i;n", &n))
-      return NULL;
-    Py_BEGIN_ALLOW_THREADS
-    rtn2 = wgetnstr(self->win,rtn,MIN(n, 1023));
-    Py_END_ALLOW_THREADS
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
-      return NULL;
-    Py_BEGIN_ALLOW_THREADS
+    switch (PyTuple_Size(args)) {
+    case 0:
+        Py_BEGIN_ALLOW_THREADS
+        rtn2 = wgetnstr(self->win,rtn, 1023);
+        Py_END_ALLOW_THREADS
+        break;
+    case 1:
+        if (!PyArg_ParseTuple(args,"i;n", &n))
+            return NULL;
+        Py_BEGIN_ALLOW_THREADS
+        rtn2 = wgetnstr(self->win,rtn,MIN(n, 1023));
+        Py_END_ALLOW_THREADS
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
+            return NULL;
+        Py_BEGIN_ALLOW_THREADS
 #ifdef STRICT_SYSV_CURSES
-    rtn2 = wmove(self->win,y,x)==ERR ? ERR : wgetnstr(self->win, rtn, 1023);
+        rtn2 = wmove(self->win,y,x)==ERR ? ERR : wgetnstr(self->win, rtn, 1023);
 #else
-    rtn2 = mvwgetnstr(self->win,y,x,rtn, 1023);
+        rtn2 = mvwgetnstr(self->win,y,x,rtn, 1023);
 #endif
-    Py_END_ALLOW_THREADS
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args,"iii;y,x,n", &y, &x, &n))
-      return NULL;
+        Py_END_ALLOW_THREADS
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args,"iii;y,x,n", &y, &x, &n))
+            return NULL;
 #ifdef STRICT_SYSV_CURSES
-    Py_BEGIN_ALLOW_THREADS
-    rtn2 = wmove(self->win,y,x)==ERR ? ERR :
-      wgetnstr(self->win, rtn, MIN(n, 1023));
-    Py_END_ALLOW_THREADS
+        Py_BEGIN_ALLOW_THREADS
+        rtn2 = wmove(self->win,y,x)==ERR ? ERR :
+        wgetnstr(self->win, rtn, MIN(n, 1023));
+        Py_END_ALLOW_THREADS
 #else
-    Py_BEGIN_ALLOW_THREADS
-    rtn2 = mvwgetnstr(self->win, y, x, rtn, MIN(n, 1023));
-    Py_END_ALLOW_THREADS
+        Py_BEGIN_ALLOW_THREADS
+        rtn2 = mvwgetnstr(self->win, y, x, rtn, MIN(n, 1023));
+        Py_END_ALLOW_THREADS
 #endif
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "getstr requires 0 to 3 arguments");
-    return NULL;
-  }
-  if (rtn2 == ERR)
-    rtn[0] = 0;
-  return PyBytes_FromString(rtn);
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "getstr requires 0 to 3 arguments");
+        return NULL;
+    }
+    if (rtn2 == ERR)
+        rtn[0] = 0;
+    return PyBytes_FromString(rtn);
 }
 
 static PyObject *
 PyCursesWindow_Hline(PyCursesWindowObject *self, PyObject *args)
 {
-  PyObject *temp;
-  chtype ch;
-  int n, x, y, code = OK;
-  attr_t attr = A_NORMAL;
-  long lattr;
+    PyObject *temp;
+    chtype ch;
+    int n, x, y, code = OK;
+    attr_t attr = A_NORMAL;
+    long lattr;
 
-  switch (PyTuple_Size(args)) {
-  case 2:
-    if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
-      return NULL;
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &lattr))
-      return NULL;
-    attr = lattr;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
-      return NULL;
-    code = wmove(self->win, y, x);
-    break;
-  case 5:
-    if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr", 
-		     &y, &x, &temp, &n, &lattr))
-      return NULL;
-    attr = lattr;
-    code = wmove(self->win, y, x);
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "hline requires 2 to 5 arguments");
-    return NULL;
-  }
-
-  if (code != ERR) {
-    if (!PyCurses_ConvertToChtype(temp, &ch)) {
-      PyErr_SetString(PyExc_TypeError, 
-		      "argument 1 or 3 must be a ch or an int");
-      return NULL;
+    switch (PyTuple_Size(args)) {
+    case 2:
+        if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
+            return NULL;
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &lattr))
+            return NULL;
+        attr = lattr;
+        break;
+    case 4:
+        if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
+            return NULL;
+        code = wmove(self->win, y, x);
+        break;
+    case 5:
+        if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr",
+                              &y, &x, &temp, &n, &lattr))
+            return NULL;
+        attr = lattr;
+        code = wmove(self->win, y, x);
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "hline requires 2 to 5 arguments");
+        return NULL;
     }
-    return PyCursesCheckERR(whline(self->win, ch | attr, n), "hline");
-  } else 
-    return PyCursesCheckERR(code, "wmove");
+
+    if (code != ERR) {
+        if (!PyCurses_ConvertToChtype(temp, &ch)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "argument 1 or 3 must be a ch or an int");
+            return NULL;
+        }
+        return PyCursesCheckERR(whline(self->win, ch | attr, n), "hline");
+    } else
+        return PyCursesCheckERR(code, "wmove");
 }
 
 static PyObject *
 PyCursesWindow_InsCh(PyCursesWindowObject *self, PyObject *args)
 {
-  int rtn, x, y, use_xy = FALSE;
-  PyObject *temp;
-  chtype ch = 0;
-  attr_t attr = A_NORMAL;
-  long lattr;
-  
-  switch (PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
-      return NULL;
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &lattr))
-      return NULL;
-    attr = lattr;
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))
-      return NULL;
-    use_xy = TRUE;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr", &y, &x, &temp, &lattr))
-      return NULL;
-    attr = lattr;
-    use_xy = TRUE;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "insch requires 1 or 4 arguments");
-    return NULL;
-  }
+    int rtn, x, y, use_xy = FALSE;
+    PyObject *temp;
+    chtype ch = 0;
+    attr_t attr = A_NORMAL;
+    long lattr;
 
-  if (!PyCurses_ConvertToChtype(temp, &ch)) {
-    PyErr_SetString(PyExc_TypeError, 
-		    "argument 1 or 3 must be a ch or an int");
-    return NULL;
-  }
-  
-  if (use_xy == TRUE)
-    rtn = mvwinsch(self->win,y,x, ch | attr);
-  else {
-    rtn = winsch(self->win, ch | attr);
-  }
-  return PyCursesCheckERR(rtn, "insch");
+    switch (PyTuple_Size(args)) {
+    case 1:
+        if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
+            return NULL;
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &lattr))
+            return NULL;
+        attr = lattr;
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))
+            return NULL;
+        use_xy = TRUE;
+        break;
+    case 4:
+        if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr", &y, &x, &temp, &lattr))
+            return NULL;
+        attr = lattr;
+        use_xy = TRUE;
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "insch requires 1 or 4 arguments");
+        return NULL;
+    }
+
+    if (!PyCurses_ConvertToChtype(temp, &ch)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "argument 1 or 3 must be a ch or an int");
+        return NULL;
+    }
+
+    if (use_xy == TRUE)
+        rtn = mvwinsch(self->win,y,x, ch | attr);
+    else {
+        rtn = winsch(self->win, ch | attr);
+    }
+    return PyCursesCheckERR(rtn, "insch");
 }
 
 static PyObject *
 PyCursesWindow_InCh(PyCursesWindowObject *self, PyObject *args)
 {
-  int x, y, rtn;
+    int x, y, rtn;
 
-  switch (PyTuple_Size(args)) {
-  case 0:
-    rtn = winch(self->win);
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
-      return NULL;
-    rtn = mvwinch(self->win,y,x);
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "inch requires 0 or 2 arguments");
-    return NULL;
-  }
-  return PyLong_FromLong((long) rtn);
+    switch (PyTuple_Size(args)) {
+    case 0:
+        rtn = winch(self->win);
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
+            return NULL;
+        rtn = mvwinch(self->win,y,x);
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "inch requires 0 or 2 arguments");
+        return NULL;
+    }
+    return PyLong_FromLong((long) rtn);
 }
 
 static PyObject *
 PyCursesWindow_InStr(PyCursesWindowObject *self, PyObject *args)
 {
-  int x, y, n;
-  char rtn[1024]; /* This should be big enough.. I hope */
-  int rtn2;
+    int x, y, n;
+    char rtn[1024]; /* This should be big enough.. I hope */
+    int rtn2;
 
-  switch (PyTuple_Size(args)) {
-  case 0:
-    rtn2 = winnstr(self->win,rtn, 1023);
-    break;
-  case 1:
-    if (!PyArg_ParseTuple(args,"i;n", &n))
-      return NULL;
-    rtn2 = winnstr(self->win,rtn,MIN(n,1023));
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
-      return NULL;
-    rtn2 = mvwinnstr(self->win,y,x,rtn,1023);
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args, "iii;y,x,n", &y, &x, &n))
-      return NULL;
-    rtn2 = mvwinnstr(self->win, y, x, rtn, MIN(n,1023));
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "instr requires 0 or 3 arguments");
-    return NULL;
-  }
-  if (rtn2 == ERR)
-    rtn[0] = 0;
-  return PyBytes_FromString(rtn);
+    switch (PyTuple_Size(args)) {
+    case 0:
+        rtn2 = winnstr(self->win,rtn, 1023);
+        break;
+    case 1:
+        if (!PyArg_ParseTuple(args,"i;n", &n))
+            return NULL;
+        rtn2 = winnstr(self->win,rtn,MIN(n,1023));
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
+            return NULL;
+        rtn2 = mvwinnstr(self->win,y,x,rtn,1023);
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args, "iii;y,x,n", &y, &x, &n))
+            return NULL;
+        rtn2 = mvwinnstr(self->win, y, x, rtn, MIN(n,1023));
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "instr requires 0 or 3 arguments");
+        return NULL;
+    }
+    if (rtn2 == ERR)
+        rtn[0] = 0;
+    return PyBytes_FromString(rtn);
 }
 
 static PyObject *
 PyCursesWindow_InsStr(PyCursesWindowObject *self, PyObject *args)
 {
-  int rtn;
-  int x, y;
-  char *str;
-  attr_t attr = A_NORMAL , attr_old = A_NORMAL;
-  long lattr;
-  int use_xy = FALSE, use_attr = FALSE;
+    int rtn;
+    int x, y;
+    char *str;
+    attr_t attr = A_NORMAL , attr_old = A_NORMAL;
+    long lattr;
+    int use_xy = FALSE, use_attr = FALSE;
 
-  switch (PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args,"s;str", &str))
-      return NULL;
-    break;
-  case 2:
-    if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))
-      return NULL;
-    attr = lattr;
-    use_attr = TRUE;
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args,"iis;y,x,str", &y, &x, &str))
-      return NULL;
-    use_xy = TRUE;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args,"iisl;y,x,str,attr", &y, &x, &str, &lattr))
-      return NULL;
-    attr = lattr;
-    use_xy = use_attr = TRUE;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "insstr requires 1 to 4 arguments");
-    return NULL;
-  }
+    switch (PyTuple_Size(args)) {
+    case 1:
+        if (!PyArg_ParseTuple(args,"s;str", &str))
+            return NULL;
+        break;
+    case 2:
+        if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))
+            return NULL;
+        attr = lattr;
+        use_attr = TRUE;
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args,"iis;y,x,str", &y, &x, &str))
+            return NULL;
+        use_xy = TRUE;
+        break;
+    case 4:
+        if (!PyArg_ParseTuple(args,"iisl;y,x,str,attr", &y, &x, &str, &lattr))
+            return NULL;
+        attr = lattr;
+        use_xy = use_attr = TRUE;
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "insstr requires 1 to 4 arguments");
+        return NULL;
+    }
 
-  if (use_attr == TRUE) {
-    attr_old = getattrs(self->win);
-    (void)wattrset(self->win,attr);
-  }
-  if (use_xy == TRUE)
-    rtn = mvwinsstr(self->win,y,x,str);
-  else
-    rtn = winsstr(self->win,str);
-  if (use_attr == TRUE)
-    (void)wattrset(self->win,attr_old);
-  return PyCursesCheckERR(rtn, "insstr");
+    if (use_attr == TRUE) {
+        attr_old = getattrs(self->win);
+        (void)wattrset(self->win,attr);
+    }
+    if (use_xy == TRUE)
+        rtn = mvwinsstr(self->win,y,x,str);
+    else
+        rtn = winsstr(self->win,str);
+    if (use_attr == TRUE)
+        (void)wattrset(self->win,attr_old);
+    return PyCursesCheckERR(rtn, "insstr");
 }
 
 static PyObject *
 PyCursesWindow_InsNStr(PyCursesWindowObject *self, PyObject *args)
 {
-  int rtn, x, y, n;
-  char *str;
-  attr_t attr = A_NORMAL , attr_old = A_NORMAL;
-  long lattr;
-  int use_xy = FALSE, use_attr = FALSE;
+    int rtn, x, y, n;
+    char *str;
+    attr_t attr = A_NORMAL , attr_old = A_NORMAL;
+    long lattr;
+    int use_xy = FALSE, use_attr = FALSE;
 
-  switch (PyTuple_Size(args)) {
-  case 2:
-    if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))
-      return NULL;
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))
-      return NULL;
-    attr = lattr;
-    use_attr = TRUE;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))
-      return NULL;
-    use_xy = TRUE;
-    break;
-  case 5:
-    if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))
-      return NULL;
-    attr = lattr;
-    use_xy = use_attr = TRUE;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "insnstr requires 2 to 5 arguments");
-    return NULL;
-  }
+    switch (PyTuple_Size(args)) {
+    case 2:
+        if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))
+            return NULL;
+        break;
+    case 3:
+        if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))
+            return NULL;
+        attr = lattr;
+        use_attr = TRUE;
+        break;
+    case 4:
+        if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))
+            return NULL;
+        use_xy = TRUE;
+        break;
+    case 5:
+        if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))
+            return NULL;
+        attr = lattr;
+        use_xy = use_attr = TRUE;
+        break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "insnstr requires 2 to 5 arguments");
+        return NULL;
+    }
 
-  if (use_attr == TRUE) {
-    attr_old = getattrs(self->win);
-    (void)wattrset(self->win,attr);
-  }
-  if (use_xy == TRUE)
-    rtn = mvwinsnstr(self->win,y,x,str,n);
-  else
-    rtn = winsnstr(self->win,str,n);
-  if (use_attr == TRUE)
-    (void)wattrset(self->win,attr_old);
-  return PyCursesCheckERR(rtn, "insnstr");
+    if (use_attr == TRUE) {
+        attr_old = getattrs(self->win);
+        (void)wattrset(self->win,attr);
+    }
+    if (use_xy == TRUE)
+        rtn = mvwinsnstr(self->win,y,x,str,n);
+    else
+        rtn = winsnstr(self->win,str,n);
+    if (use_attr == TRUE)
+        (void)wattrset(self->win,attr_old);
+    return PyCursesCheckERR(rtn, "insnstr");
 }
 
 static PyObject *
 PyCursesWindow_Is_LineTouched(PyCursesWindowObject *self, PyObject *args)
 {
-  int line, erg;
-  if (!PyArg_ParseTuple(args,"i;line", &line))
-    return NULL;
-  erg = is_linetouched(self->win, line);
-  if (erg == ERR) {
-    PyErr_SetString(PyExc_TypeError, 
-		    "is_linetouched: line number outside of boundaries");
-    return NULL;
-  } else 
-    if (erg == FALSE) {
-      Py_INCREF(Py_False);
-      return Py_False;
-    } else {
-      Py_INCREF(Py_True);
-      return Py_True;
-    }
+    int line, erg;
+    if (!PyArg_ParseTuple(args,"i;line", &line))
+        return NULL;
+    erg = is_linetouched(self->win, line);
+    if (erg == ERR) {
+        PyErr_SetString(PyExc_TypeError,
+                        "is_linetouched: line number outside of boundaries");
+        return NULL;
+    } else
+        if (erg == FALSE) {
+            Py_INCREF(Py_False);
+            return Py_False;
+        } else {
+            Py_INCREF(Py_True);
+            return Py_True;
+        }
 }
 
 static PyObject *
 PyCursesWindow_NoOutRefresh(PyCursesWindowObject *self, PyObject *args)
 {
-  int pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol;
-  int rtn;
+    int pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol;
+    int rtn;
 
 #ifndef WINDOW_HAS_FLAGS
-  if (0) {
+    if (0) {
 #else
-  if (self->win->_flags & _ISPAD) {
+        if (self->win->_flags & _ISPAD) {
 #endif
-    switch(PyTuple_Size(args)) {
-    case 6:
-      if (!PyArg_ParseTuple(args, 
-		       "iiiiii;" \
-		       "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol", 
-		       &pminrow, &pmincol, &sminrow, 
-		       &smincol, &smaxrow, &smaxcol))
-	return NULL;
-      Py_BEGIN_ALLOW_THREADS
-      rtn = pnoutrefresh(self->win,
-			 pminrow, pmincol, sminrow, 
-			 smincol, smaxrow, smaxcol);
-      Py_END_ALLOW_THREADS
-      return PyCursesCheckERR(rtn, "pnoutrefresh");
-    default:
-      PyErr_SetString(PyCursesError, 
-		      "noutrefresh() called for a pad " 
-		      "requires 6 arguments");
-      return NULL;
-    }
-  } else {
-    if (!PyArg_ParseTuple(args, ":noutrefresh"))
-      return NULL;    
+            switch(PyTuple_Size(args)) {
+            case 6:
+                if (!PyArg_ParseTuple(args,
+                                      "iiiiii;" \
+                                      "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol",
+                                      &pminrow, &pmincol, &sminrow,
+                                      &smincol, &smaxrow, &smaxcol))
+                    return NULL;
+                Py_BEGIN_ALLOW_THREADS
+                rtn = pnoutrefresh(self->win,
+                                   pminrow, pmincol, sminrow,
+                                   smincol, smaxrow, smaxcol);
+                Py_END_ALLOW_THREADS
+                return PyCursesCheckERR(rtn, "pnoutrefresh");
+            default:
+                PyErr_SetString(PyCursesError,
+                                "noutrefresh() called for a pad "
+                                "requires 6 arguments");
+                return NULL;
+            }
+        } else {
+            if (!PyArg_ParseTuple(args, ":noutrefresh"))
+                return NULL;
 
-    Py_BEGIN_ALLOW_THREADS
-    rtn = wnoutrefresh(self->win);
-    Py_END_ALLOW_THREADS
-    return PyCursesCheckERR(rtn, "wnoutrefresh");
-  }
-}
-
-static PyObject *
-PyCursesWindow_Overlay(PyCursesWindowObject *self, PyObject *args)
-{
-    PyCursesWindowObject *temp;
-    int use_copywin = FALSE;
-    int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
-    int rtn;
-    
-    switch (PyTuple_Size(args)) {
-    case 1:
-	if (!PyArg_ParseTuple(args, "O!;window object",
-			      &PyCursesWindow_Type, &temp))
-	    return NULL;
-	break;
-    case 7:
-	if (!PyArg_ParseTuple(args, "O!iiiiii;window object, int, int, int, int, int, int",
-			      &PyCursesWindow_Type, &temp, &sminrow, &smincol,
-			      &dminrow, &dmincol, &dmaxrow, &dmaxcol))
-	    return NULL;
-	use_copywin = TRUE;
-	break;
-    default:
-	PyErr_SetString(PyExc_TypeError,
-			"overlay requires one or seven arguments");
-	return NULL;
+            Py_BEGIN_ALLOW_THREADS
+            rtn = wnoutrefresh(self->win);
+            Py_END_ALLOW_THREADS
+            return PyCursesCheckERR(rtn, "wnoutrefresh");
+        }
     }
 
-    if (use_copywin == TRUE) {
-	    rtn = copywin(self->win, temp->win, sminrow, smincol,
-			  dminrow, dmincol, dmaxrow, dmaxcol, TRUE);
-	    return PyCursesCheckERR(rtn, "copywin");
-    }
-    else {
-	    rtn = overlay(self->win, temp->win);
-	    return PyCursesCheckERR(rtn, "overlay");
-    }
-}
+    static PyObject *
+        PyCursesWindow_Overlay(PyCursesWindowObject *self, PyObject *args)
+    {
+        PyCursesWindowObject *temp;
+        int use_copywin = FALSE;
+        int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
+        int rtn;
 
-static PyObject *
-PyCursesWindow_Overwrite(PyCursesWindowObject *self, PyObject *args)
-{
-    PyCursesWindowObject *temp;
-    int use_copywin = FALSE;
-    int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
-    int rtn;
-    
-    switch (PyTuple_Size(args)) {
-    case 1:
-	if (!PyArg_ParseTuple(args, "O!;window object",
-			      &PyCursesWindow_Type, &temp))
-	    return NULL;
-	break;
-    case 7:
-	if (!PyArg_ParseTuple(args, "O!iiiiii;window object, int, int, int, int, int, int",
-			      &PyCursesWindow_Type, &temp, &sminrow, &smincol,
-			      &dminrow, &dmincol, &dmaxrow, &dmaxcol))
-	    return NULL;
-	use_copywin = TRUE;
-	break;
-    default:
-	PyErr_SetString(PyExc_TypeError,
-			"overwrite requires one or seven arguments");
-	return NULL;
+        switch (PyTuple_Size(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "O!;window object",
+                                  &PyCursesWindow_Type, &temp))
+                return NULL;
+            break;
+        case 7:
+            if (!PyArg_ParseTuple(args, "O!iiiiii;window object, int, int, int, int, int, int",
+                                  &PyCursesWindow_Type, &temp, &sminrow, &smincol,
+                                  &dminrow, &dmincol, &dmaxrow, &dmaxcol))
+                return NULL;
+            use_copywin = TRUE;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError,
+                            "overlay requires one or seven arguments");
+            return NULL;
+        }
+
+        if (use_copywin == TRUE) {
+            rtn = copywin(self->win, temp->win, sminrow, smincol,
+                          dminrow, dmincol, dmaxrow, dmaxcol, TRUE);
+            return PyCursesCheckERR(rtn, "copywin");
+        }
+        else {
+            rtn = overlay(self->win, temp->win);
+            return PyCursesCheckERR(rtn, "overlay");
+        }
     }
 
-    if (use_copywin == TRUE) {
-	rtn = copywin(self->win, temp->win, sminrow, smincol,
-		      dminrow, dmincol, dmaxrow, dmaxcol, FALSE);
-        return PyCursesCheckERR(rtn, "copywin");
+    static PyObject *
+        PyCursesWindow_Overwrite(PyCursesWindowObject *self, PyObject *args)
+    {
+        PyCursesWindowObject *temp;
+        int use_copywin = FALSE;
+        int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
+        int rtn;
+
+        switch (PyTuple_Size(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "O!;window object",
+                                  &PyCursesWindow_Type, &temp))
+                return NULL;
+            break;
+        case 7:
+            if (!PyArg_ParseTuple(args, "O!iiiiii;window object, int, int, int, int, int, int",
+                                  &PyCursesWindow_Type, &temp, &sminrow, &smincol,
+                                  &dminrow, &dmincol, &dmaxrow, &dmaxcol))
+                return NULL;
+            use_copywin = TRUE;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError,
+                            "overwrite requires one or seven arguments");
+            return NULL;
+        }
+
+        if (use_copywin == TRUE) {
+            rtn = copywin(self->win, temp->win, sminrow, smincol,
+                          dminrow, dmincol, dmaxrow, dmaxcol, FALSE);
+            return PyCursesCheckERR(rtn, "copywin");
+        }
+        else {
+            rtn = overwrite(self->win, temp->win);
+            return PyCursesCheckERR(rtn, "overwrite");
+        }
     }
-    else {
-	    rtn = overwrite(self->win, temp->win);
-	    return PyCursesCheckERR(rtn, "overwrite");
+
+    static PyObject *
+        PyCursesWindow_PutWin(PyCursesWindowObject *self, PyObject *stream)
+    {
+        /* We have to simulate this by writing to a temporary FILE*,
+           then reading back, then writing to the argument stream. */
+        char fn[100];
+        int fd;
+        FILE *fp;
+        PyObject *res;
+
+        strcpy(fn, "/tmp/py.curses.putwin.XXXXXX");
+        fd = mkstemp(fn);
+        if (fd < 0)
+            return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
+        fp = fdopen(fd, "wb+");
+        if (fp == NULL) {
+            close(fd);
+            remove(fn);
+            return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
+        }
+        res = PyCursesCheckERR(putwin(self->win, fp), "putwin");
+        if (res == NULL) {
+            fclose(fp);
+            remove(fn);
+            return res;
+        }
+        fseek(fp, 0, 0);
+        while (1) {
+            char buf[BUFSIZ];
+            int n = fread(buf, 1, BUFSIZ, fp);
+            if (n <= 0)
+                break;
+            Py_DECREF(res);
+            res = PyObject_CallMethod(stream, "write", "y#", buf, n);
+            if (res == NULL)
+                break;
+        }
+        fclose(fp);
+        remove(fn);
+        return res;
     }
-}
 
-static PyObject *
-PyCursesWindow_PutWin(PyCursesWindowObject *self, PyObject *stream)
-{
-  /* We have to simulate this by writing to a temporary FILE*,
-     then reading back, then writing to the argument stream. */
-  char fn[100];
-  int fd;
-  FILE *fp;
-  PyObject *res;
+    static PyObject *
+        PyCursesWindow_RedrawLine(PyCursesWindowObject *self, PyObject *args)
+    {
+        int beg, num;
+        if (!PyArg_ParseTuple(args, "ii;beg,num", &beg, &num))
+            return NULL;
+        return PyCursesCheckERR(wredrawln(self->win,beg,num), "redrawln");
+    }
 
-  strcpy(fn, "/tmp/py.curses.putwin.XXXXXX");
-  fd = mkstemp(fn);
-  if (fd < 0)
-    return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
-  fp = fdopen(fd, "wb+");
-  if (fp == NULL) {
-    close(fd);
-    remove(fn);
-    return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
-  }
-  res = PyCursesCheckERR(putwin(self->win, fp), "putwin");
-  if (res == NULL) {
-    fclose(fp);
-    remove(fn);
-    return res;
-  }
-  fseek(fp, 0, 0);
-  while (1) {
-    char buf[BUFSIZ];
-    int n = fread(buf, 1, BUFSIZ, fp);
-    if (n <= 0)
-      break;
-    Py_DECREF(res);
-    res = PyObject_CallMethod(stream, "write", "y#", buf, n);
-    if (res == NULL)
-      break;
-  }
-  fclose(fp);
-  remove(fn);
-  return res;
-}
+    static PyObject *
+        PyCursesWindow_Refresh(PyCursesWindowObject *self, PyObject *args)
+    {
+        int pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol;
+        int rtn;
 
-static PyObject *
-PyCursesWindow_RedrawLine(PyCursesWindowObject *self, PyObject *args)
-{
-  int beg, num;
-  if (!PyArg_ParseTuple(args, "ii;beg,num", &beg, &num))
-    return NULL;
-  return PyCursesCheckERR(wredrawln(self->win,beg,num), "redrawln");
-}
-
-static PyObject *
-PyCursesWindow_Refresh(PyCursesWindowObject *self, PyObject *args)
-{
-  int pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol;
-  int rtn;
-  
 #ifndef WINDOW_HAS_FLAGS
-  if (0) {
+        if (0) {
 #else
-  if (self->win->_flags & _ISPAD) {
+            if (self->win->_flags & _ISPAD) {
 #endif
-    switch(PyTuple_Size(args)) {
-    case 6:
-      if (!PyArg_ParseTuple(args, 
-		       "iiiiii;" \
-		       "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol", 
-		       &pminrow, &pmincol, &sminrow, 
-		       &smincol, &smaxrow, &smaxcol))
-	return NULL;
+                switch(PyTuple_Size(args)) {
+                case 6:
+                    if (!PyArg_ParseTuple(args,
+                                          "iiiiii;" \
+                                          "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol",
+                                          &pminrow, &pmincol, &sminrow,
+                                          &smincol, &smaxrow, &smaxcol))
+                        return NULL;
 
-      Py_BEGIN_ALLOW_THREADS
-      rtn = prefresh(self->win,
-		     pminrow, pmincol, sminrow, 
-		     smincol, smaxrow, smaxcol);
-      Py_END_ALLOW_THREADS
-      return PyCursesCheckERR(rtn, "prefresh");
-    default:
-      PyErr_SetString(PyCursesError, 
-		      "refresh() for a pad requires 6 arguments");
-      return NULL;
-    }
-  } else {
-    if (!PyArg_ParseTuple(args, ":refresh"))
-      return NULL;    
-    Py_BEGIN_ALLOW_THREADS
-    rtn = wrefresh(self->win);
-    Py_END_ALLOW_THREADS
-    return PyCursesCheckERR(rtn, "prefresh");    
-  }
-}
+                    Py_BEGIN_ALLOW_THREADS
+                    rtn = prefresh(self->win,
+                                   pminrow, pmincol, sminrow,
+                                   smincol, smaxrow, smaxcol);
+                    Py_END_ALLOW_THREADS
+                    return PyCursesCheckERR(rtn, "prefresh");
+                default:
+                    PyErr_SetString(PyCursesError,
+                                    "refresh() for a pad requires 6 arguments");
+                    return NULL;
+                }
+            } else {
+                if (!PyArg_ParseTuple(args, ":refresh"))
+                    return NULL;
+                Py_BEGIN_ALLOW_THREADS
+                rtn = wrefresh(self->win);
+                Py_END_ALLOW_THREADS
+                return PyCursesCheckERR(rtn, "prefresh");
+            }
+        }
 
-static PyObject *
-PyCursesWindow_SetScrollRegion(PyCursesWindowObject *self, PyObject *args)
-{
-  int x, y;
-  if (!PyArg_ParseTuple(args,"ii;top, bottom",&y,&x))
-    return NULL;
-  return PyCursesCheckERR(wsetscrreg(self->win,y,x), "wsetscrreg");
-}
+        static PyObject *
+            PyCursesWindow_SetScrollRegion(PyCursesWindowObject *self, PyObject *args)
+        {
+            int x, y;
+            if (!PyArg_ParseTuple(args,"ii;top, bottom",&y,&x))
+                return NULL;
+            return PyCursesCheckERR(wsetscrreg(self->win,y,x), "wsetscrreg");
+        }
 
-static PyObject *
-PyCursesWindow_SubWin(PyCursesWindowObject *self, PyObject *args)
-{
-  WINDOW *win;
-  int nlines, ncols, begin_y, begin_x;
+        static PyObject *
+            PyCursesWindow_SubWin(PyCursesWindowObject *self, PyObject *args)
+        {
+            WINDOW *win;
+            int nlines, ncols, begin_y, begin_x;
 
-  nlines = 0;
-  ncols  = 0;
-  switch (PyTuple_Size(args)) {
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))
-      return NULL;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
-		   &nlines,&ncols,&begin_y,&begin_x))
-      return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "subwin requires 2 or 4 arguments");
-    return NULL;
-  }
+            nlines = 0;
+            ncols  = 0;
+            switch (PyTuple_Size(args)) {
+            case 2:
+                if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))
+                    return NULL;
+                break;
+            case 4:
+                if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
+                                      &nlines,&ncols,&begin_y,&begin_x))
+                    return NULL;
+                break;
+            default:
+                PyErr_SetString(PyExc_TypeError, "subwin requires 2 or 4 arguments");
+                return NULL;
+            }
 
-  /* printf("Subwin: %i %i %i %i   \n", nlines, ncols, begin_y, begin_x); */
+            /* printf("Subwin: %i %i %i %i   \n", nlines, ncols, begin_y, begin_x); */
 #ifdef WINDOW_HAS_FLAGS
-  if (self->win->_flags & _ISPAD)
-    win = subpad(self->win, nlines, ncols, begin_y, begin_x);
-  else
+            if (self->win->_flags & _ISPAD)
+                win = subpad(self->win, nlines, ncols, begin_y, begin_x);
+            else
 #endif
-    win = subwin(self->win, nlines, ncols, begin_y, begin_x);
+                win = subwin(self->win, nlines, ncols, begin_y, begin_x);
 
-  if (win == NULL) {
-    PyErr_SetString(PyCursesError, catchall_NULL);
-    return NULL;
-  }
-  
-  return (PyObject *)PyCursesWindow_New(win);
-}
+            if (win == NULL) {
+                PyErr_SetString(PyCursesError, catchall_NULL);
+                return NULL;
+            }
 
-static PyObject *
-PyCursesWindow_Scroll(PyCursesWindowObject *self, PyObject *args)
-{
-  int nlines;
-  switch(PyTuple_Size(args)) {
-  case 0:
-    return PyCursesCheckERR(scroll(self->win), "scroll");
-  case 1:
-    if (!PyArg_ParseTuple(args, "i;nlines", &nlines))
-      return NULL;
-    return PyCursesCheckERR(wscrl(self->win, nlines), "scroll");
-  default:
-    PyErr_SetString(PyExc_TypeError, "scroll requires 0 or 1 arguments");
-    return NULL;
-  }
-}
+            return (PyObject *)PyCursesWindow_New(win);
+        }
 
-static PyObject *
-PyCursesWindow_TouchLine(PyCursesWindowObject *self, PyObject *args)
-{
-  int st, cnt, val;
-  switch (PyTuple_Size(args)) {
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;start,count",&st,&cnt))
-      return NULL;
-    return PyCursesCheckERR(touchline(self->win,st,cnt), "touchline");
-  case 3:
-    if (!PyArg_ParseTuple(args, "iii;start,count,val", &st, &cnt, &val))
-      return NULL;
-    return PyCursesCheckERR(wtouchln(self->win, st, cnt, val), "touchline");
-  default:
-    PyErr_SetString(PyExc_TypeError, "touchline requires 2 or 3 arguments");
-    return NULL;
-  }
-}
+        static PyObject *
+            PyCursesWindow_Scroll(PyCursesWindowObject *self, PyObject *args)
+        {
+            int nlines;
+            switch(PyTuple_Size(args)) {
+            case 0:
+                return PyCursesCheckERR(scroll(self->win), "scroll");
+            case 1:
+                if (!PyArg_ParseTuple(args, "i;nlines", &nlines))
+                    return NULL;
+                return PyCursesCheckERR(wscrl(self->win, nlines), "scroll");
+            default:
+                PyErr_SetString(PyExc_TypeError, "scroll requires 0 or 1 arguments");
+                return NULL;
+            }
+        }
 
-static PyObject *
-PyCursesWindow_Vline(PyCursesWindowObject *self, PyObject *args)
-{
-  PyObject *temp;
-  chtype ch;
-  int n, x, y, code = OK;
-  attr_t attr = A_NORMAL;
-  long lattr;
+        static PyObject *
+            PyCursesWindow_TouchLine(PyCursesWindowObject *self, PyObject *args)
+        {
+            int st, cnt, val;
+            switch (PyTuple_Size(args)) {
+            case 2:
+                if (!PyArg_ParseTuple(args,"ii;start,count",&st,&cnt))
+                    return NULL;
+                return PyCursesCheckERR(touchline(self->win,st,cnt), "touchline");
+            case 3:
+                if (!PyArg_ParseTuple(args, "iii;start,count,val", &st, &cnt, &val))
+                    return NULL;
+                return PyCursesCheckERR(wtouchln(self->win, st, cnt, val), "touchline");
+            default:
+                PyErr_SetString(PyExc_TypeError, "touchline requires 2 or 3 arguments");
+                return NULL;
+            }
+        }
 
-  switch (PyTuple_Size(args)) {
-  case 2:
-    if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
-      return NULL;
-    break;
-  case 3:
-    if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &lattr))
-      return NULL;
-    attr = lattr;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
-      return NULL;
-    code = wmove(self->win, y, x);
-    break;
-  case 5:
-    if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr", 
-		     &y, &x, &temp, &n, &lattr))
-      return NULL;
-    attr = lattr;
-    code = wmove(self->win, y, x);
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "vline requires 2 to 5 arguments");
-    return NULL;
-  }
+        static PyObject *
+            PyCursesWindow_Vline(PyCursesWindowObject *self, PyObject *args)
+        {
+            PyObject *temp;
+            chtype ch;
+            int n, x, y, code = OK;
+            attr_t attr = A_NORMAL;
+            long lattr;
 
-  if (code != ERR) {
-    if (!PyCurses_ConvertToChtype(temp, &ch)) {
-      PyErr_SetString(PyExc_TypeError, 
-		      "argument 1 or 3 must be a ch or an int");
-      return NULL;
-    }
-    return PyCursesCheckERR(wvline(self->win, ch | attr, n), "vline");
-  } else
-    return PyCursesCheckERR(code, "wmove");
-}
+            switch (PyTuple_Size(args)) {
+            case 2:
+                if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
+                    return NULL;
+                break;
+            case 3:
+                if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &lattr))
+                    return NULL;
+                attr = lattr;
+                break;
+            case 4:
+                if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
+                    return NULL;
+                code = wmove(self->win, y, x);
+                break;
+            case 5:
+                if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr",
+                                      &y, &x, &temp, &n, &lattr))
+                    return NULL;
+                attr = lattr;
+                code = wmove(self->win, y, x);
+                break;
+            default:
+                PyErr_SetString(PyExc_TypeError, "vline requires 2 to 5 arguments");
+                return NULL;
+            }
 
-static PyMethodDef PyCursesWindow_Methods[] = {
-	{"addch",           (PyCFunction)PyCursesWindow_AddCh, METH_VARARGS},
-	{"addnstr",         (PyCFunction)PyCursesWindow_AddNStr, METH_VARARGS},
-	{"addstr",          (PyCFunction)PyCursesWindow_AddStr, METH_VARARGS},
-	{"attroff",         (PyCFunction)PyCursesWindow_AttrOff, METH_VARARGS},
-	{"attron",          (PyCFunction)PyCursesWindow_AttrOn, METH_VARARGS},
-	{"attrset",         (PyCFunction)PyCursesWindow_AttrSet, METH_VARARGS},
-	{"bkgd",            (PyCFunction)PyCursesWindow_Bkgd, METH_VARARGS},
-	{"chgat",           (PyCFunction)PyCursesWindow_ChgAt, METH_VARARGS},
-	{"bkgdset",         (PyCFunction)PyCursesWindow_BkgdSet, METH_VARARGS},
-	{"border",          (PyCFunction)PyCursesWindow_Border, METH_VARARGS},
-	{"box",             (PyCFunction)PyCursesWindow_Box, METH_VARARGS},
-	{"clear",           (PyCFunction)PyCursesWindow_wclear, METH_NOARGS},
-	{"clearok",         (PyCFunction)PyCursesWindow_clearok, METH_VARARGS},
-	{"clrtobot",        (PyCFunction)PyCursesWindow_wclrtobot, METH_NOARGS},
-	{"clrtoeol",        (PyCFunction)PyCursesWindow_wclrtoeol, METH_NOARGS},
-	{"cursyncup",       (PyCFunction)PyCursesWindow_wcursyncup, METH_NOARGS},
-	{"delch",           (PyCFunction)PyCursesWindow_DelCh, METH_VARARGS},
-	{"deleteln",        (PyCFunction)PyCursesWindow_wdeleteln, METH_NOARGS},
-	{"derwin",          (PyCFunction)PyCursesWindow_DerWin, METH_VARARGS},
-	{"echochar",        (PyCFunction)PyCursesWindow_EchoChar, METH_VARARGS},
+            if (code != ERR) {
+                if (!PyCurses_ConvertToChtype(temp, &ch)) {
+                    PyErr_SetString(PyExc_TypeError,
+                                    "argument 1 or 3 must be a ch or an int");
+                    return NULL;
+                }
+                return PyCursesCheckERR(wvline(self->win, ch | attr, n), "vline");
+            } else
+                return PyCursesCheckERR(code, "wmove");
+        }
+
+        static PyMethodDef PyCursesWindow_Methods[] = {
+            {"addch",           (PyCFunction)PyCursesWindow_AddCh, METH_VARARGS},
+            {"addnstr",         (PyCFunction)PyCursesWindow_AddNStr, METH_VARARGS},
+            {"addstr",          (PyCFunction)PyCursesWindow_AddStr, METH_VARARGS},
+            {"attroff",         (PyCFunction)PyCursesWindow_AttrOff, METH_VARARGS},
+            {"attron",          (PyCFunction)PyCursesWindow_AttrOn, METH_VARARGS},
+            {"attrset",         (PyCFunction)PyCursesWindow_AttrSet, METH_VARARGS},
+            {"bkgd",            (PyCFunction)PyCursesWindow_Bkgd, METH_VARARGS},
+            {"chgat",           (PyCFunction)PyCursesWindow_ChgAt, METH_VARARGS},
+            {"bkgdset",         (PyCFunction)PyCursesWindow_BkgdSet, METH_VARARGS},
+            {"border",          (PyCFunction)PyCursesWindow_Border, METH_VARARGS},
+            {"box",             (PyCFunction)PyCursesWindow_Box, METH_VARARGS},
+            {"clear",           (PyCFunction)PyCursesWindow_wclear, METH_NOARGS},
+            {"clearok",         (PyCFunction)PyCursesWindow_clearok, METH_VARARGS},
+            {"clrtobot",        (PyCFunction)PyCursesWindow_wclrtobot, METH_NOARGS},
+            {"clrtoeol",        (PyCFunction)PyCursesWindow_wclrtoeol, METH_NOARGS},
+            {"cursyncup",       (PyCFunction)PyCursesWindow_wcursyncup, METH_NOARGS},
+            {"delch",           (PyCFunction)PyCursesWindow_DelCh, METH_VARARGS},
+            {"deleteln",        (PyCFunction)PyCursesWindow_wdeleteln, METH_NOARGS},
+            {"derwin",          (PyCFunction)PyCursesWindow_DerWin, METH_VARARGS},
+            {"echochar",        (PyCFunction)PyCursesWindow_EchoChar, METH_VARARGS},
 #ifdef NCURSES_MOUSE_VERSION
-	{"enclose",         (PyCFunction)PyCursesWindow_Enclose, METH_VARARGS},
+            {"enclose",         (PyCFunction)PyCursesWindow_Enclose, METH_VARARGS},
 #endif
-	{"erase",           (PyCFunction)PyCursesWindow_werase, METH_NOARGS},
-	{"getbegyx",        (PyCFunction)PyCursesWindow_getbegyx, METH_NOARGS},
-	{"getbkgd",         (PyCFunction)PyCursesWindow_GetBkgd, METH_NOARGS},
-	{"getch",           (PyCFunction)PyCursesWindow_GetCh, METH_VARARGS},
-	{"getkey",          (PyCFunction)PyCursesWindow_GetKey, METH_VARARGS},
-	{"getmaxyx",        (PyCFunction)PyCursesWindow_getmaxyx, METH_NOARGS},
-	{"getparyx",        (PyCFunction)PyCursesWindow_getparyx, METH_NOARGS},
-	{"getstr",          (PyCFunction)PyCursesWindow_GetStr, METH_VARARGS},
-	{"getyx",           (PyCFunction)PyCursesWindow_getyx, METH_NOARGS},
-	{"hline",           (PyCFunction)PyCursesWindow_Hline, METH_VARARGS},
-	{"idcok",           (PyCFunction)PyCursesWindow_idcok, METH_VARARGS},
-	{"idlok",           (PyCFunction)PyCursesWindow_idlok, METH_VARARGS},
-	{"immedok",         (PyCFunction)PyCursesWindow_immedok, METH_VARARGS},
-	{"inch",            (PyCFunction)PyCursesWindow_InCh, METH_VARARGS},
-	{"insch",           (PyCFunction)PyCursesWindow_InsCh, METH_VARARGS},
-	{"insdelln",        (PyCFunction)PyCursesWindow_winsdelln, METH_VARARGS},
-	{"insertln",        (PyCFunction)PyCursesWindow_winsertln, METH_NOARGS},
-	{"insnstr",         (PyCFunction)PyCursesWindow_InsNStr, METH_VARARGS},
-	{"insstr",          (PyCFunction)PyCursesWindow_InsStr, METH_VARARGS},
-	{"instr",           (PyCFunction)PyCursesWindow_InStr, METH_VARARGS},
-	{"is_linetouched",  (PyCFunction)PyCursesWindow_Is_LineTouched, METH_VARARGS},
-	{"is_wintouched",   (PyCFunction)PyCursesWindow_is_wintouched, METH_NOARGS},
-	{"keypad",          (PyCFunction)PyCursesWindow_keypad, METH_VARARGS},
-	{"leaveok",         (PyCFunction)PyCursesWindow_leaveok, METH_VARARGS},
-	{"move",            (PyCFunction)PyCursesWindow_wmove, METH_VARARGS},
-	{"mvderwin",        (PyCFunction)PyCursesWindow_mvderwin, METH_VARARGS},
-	{"mvwin",           (PyCFunction)PyCursesWindow_mvwin, METH_VARARGS},
-	{"nodelay",         (PyCFunction)PyCursesWindow_nodelay, METH_VARARGS},
-	{"notimeout",       (PyCFunction)PyCursesWindow_notimeout, METH_VARARGS},
-	{"noutrefresh",     (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
-        /* Backward compatibility alias -- remove in Python 2.3 */
-	{"nooutrefresh",    (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
-	{"overlay",         (PyCFunction)PyCursesWindow_Overlay, METH_VARARGS},
-	{"overwrite",       (PyCFunction)PyCursesWindow_Overwrite,
-         METH_VARARGS},
-	{"putwin",          (PyCFunction)PyCursesWindow_PutWin, METH_O},
-	{"redrawln",        (PyCFunction)PyCursesWindow_RedrawLine, METH_VARARGS},
-	{"redrawwin",       (PyCFunction)PyCursesWindow_redrawwin, METH_NOARGS},
-	{"refresh",         (PyCFunction)PyCursesWindow_Refresh, METH_VARARGS},
+            {"erase",           (PyCFunction)PyCursesWindow_werase, METH_NOARGS},
+            {"getbegyx",        (PyCFunction)PyCursesWindow_getbegyx, METH_NOARGS},
+            {"getbkgd",         (PyCFunction)PyCursesWindow_GetBkgd, METH_NOARGS},
+            {"getch",           (PyCFunction)PyCursesWindow_GetCh, METH_VARARGS},
+            {"getkey",          (PyCFunction)PyCursesWindow_GetKey, METH_VARARGS},
+            {"getmaxyx",        (PyCFunction)PyCursesWindow_getmaxyx, METH_NOARGS},
+            {"getparyx",        (PyCFunction)PyCursesWindow_getparyx, METH_NOARGS},
+            {"getstr",          (PyCFunction)PyCursesWindow_GetStr, METH_VARARGS},
+            {"getyx",           (PyCFunction)PyCursesWindow_getyx, METH_NOARGS},
+            {"hline",           (PyCFunction)PyCursesWindow_Hline, METH_VARARGS},
+            {"idcok",           (PyCFunction)PyCursesWindow_idcok, METH_VARARGS},
+            {"idlok",           (PyCFunction)PyCursesWindow_idlok, METH_VARARGS},
+            {"immedok",         (PyCFunction)PyCursesWindow_immedok, METH_VARARGS},
+            {"inch",            (PyCFunction)PyCursesWindow_InCh, METH_VARARGS},
+            {"insch",           (PyCFunction)PyCursesWindow_InsCh, METH_VARARGS},
+            {"insdelln",        (PyCFunction)PyCursesWindow_winsdelln, METH_VARARGS},
+            {"insertln",        (PyCFunction)PyCursesWindow_winsertln, METH_NOARGS},
+            {"insnstr",         (PyCFunction)PyCursesWindow_InsNStr, METH_VARARGS},
+            {"insstr",          (PyCFunction)PyCursesWindow_InsStr, METH_VARARGS},
+            {"instr",           (PyCFunction)PyCursesWindow_InStr, METH_VARARGS},
+            {"is_linetouched",  (PyCFunction)PyCursesWindow_Is_LineTouched, METH_VARARGS},
+            {"is_wintouched",   (PyCFunction)PyCursesWindow_is_wintouched, METH_NOARGS},
+            {"keypad",          (PyCFunction)PyCursesWindow_keypad, METH_VARARGS},
+            {"leaveok",         (PyCFunction)PyCursesWindow_leaveok, METH_VARARGS},
+            {"move",            (PyCFunction)PyCursesWindow_wmove, METH_VARARGS},
+            {"mvderwin",        (PyCFunction)PyCursesWindow_mvderwin, METH_VARARGS},
+            {"mvwin",           (PyCFunction)PyCursesWindow_mvwin, METH_VARARGS},
+            {"nodelay",         (PyCFunction)PyCursesWindow_nodelay, METH_VARARGS},
+            {"notimeout",       (PyCFunction)PyCursesWindow_notimeout, METH_VARARGS},
+            {"noutrefresh",     (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
+            /* Backward compatibility alias -- remove in Python 2.3 */
+            {"nooutrefresh",    (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
+            {"overlay",         (PyCFunction)PyCursesWindow_Overlay, METH_VARARGS},
+            {"overwrite",       (PyCFunction)PyCursesWindow_Overwrite,
+             METH_VARARGS},
+            {"putwin",          (PyCFunction)PyCursesWindow_PutWin, METH_O},
+            {"redrawln",        (PyCFunction)PyCursesWindow_RedrawLine, METH_VARARGS},
+            {"redrawwin",       (PyCFunction)PyCursesWindow_redrawwin, METH_NOARGS},
+            {"refresh",         (PyCFunction)PyCursesWindow_Refresh, METH_VARARGS},
 #ifndef STRICT_SYSV_CURSES
-	{"resize",          (PyCFunction)PyCursesWindow_wresize, METH_VARARGS},
+            {"resize",          (PyCFunction)PyCursesWindow_wresize, METH_VARARGS},
 #endif
-	{"scroll",          (PyCFunction)PyCursesWindow_Scroll, METH_VARARGS},
-	{"scrollok",        (PyCFunction)PyCursesWindow_scrollok, METH_VARARGS},
-	{"setscrreg",       (PyCFunction)PyCursesWindow_SetScrollRegion, METH_VARARGS},
-	{"standend",        (PyCFunction)PyCursesWindow_wstandend, METH_NOARGS},
-	{"standout",        (PyCFunction)PyCursesWindow_wstandout, METH_NOARGS},
-	{"subpad",          (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
-	{"subwin",          (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
-	{"syncdown",        (PyCFunction)PyCursesWindow_wsyncdown, METH_NOARGS},
-	{"syncok",          (PyCFunction)PyCursesWindow_syncok, METH_VARARGS},
-	{"syncup",          (PyCFunction)PyCursesWindow_wsyncup, METH_NOARGS},
-	{"timeout",         (PyCFunction)PyCursesWindow_wtimeout, METH_VARARGS},
-	{"touchline",       (PyCFunction)PyCursesWindow_TouchLine, METH_VARARGS},
-	{"touchwin",        (PyCFunction)PyCursesWindow_touchwin, METH_NOARGS},
-	{"untouchwin",      (PyCFunction)PyCursesWindow_untouchwin, METH_NOARGS},
-	{"vline",           (PyCFunction)PyCursesWindow_Vline, METH_VARARGS},
-	{NULL,		    NULL}   /* sentinel */
-};
+            {"scroll",          (PyCFunction)PyCursesWindow_Scroll, METH_VARARGS},
+            {"scrollok",        (PyCFunction)PyCursesWindow_scrollok, METH_VARARGS},
+            {"setscrreg",       (PyCFunction)PyCursesWindow_SetScrollRegion, METH_VARARGS},
+            {"standend",        (PyCFunction)PyCursesWindow_wstandend, METH_NOARGS},
+            {"standout",        (PyCFunction)PyCursesWindow_wstandout, METH_NOARGS},
+            {"subpad",          (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
+            {"subwin",          (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
+            {"syncdown",        (PyCFunction)PyCursesWindow_wsyncdown, METH_NOARGS},
+            {"syncok",          (PyCFunction)PyCursesWindow_syncok, METH_VARARGS},
+            {"syncup",          (PyCFunction)PyCursesWindow_wsyncup, METH_NOARGS},
+            {"timeout",         (PyCFunction)PyCursesWindow_wtimeout, METH_VARARGS},
+            {"touchline",       (PyCFunction)PyCursesWindow_TouchLine, METH_VARARGS},
+            {"touchwin",        (PyCFunction)PyCursesWindow_touchwin, METH_NOARGS},
+            {"untouchwin",      (PyCFunction)PyCursesWindow_untouchwin, METH_NOARGS},
+            {"vline",           (PyCFunction)PyCursesWindow_Vline, METH_VARARGS},
+            {NULL,                  NULL}   /* sentinel */
+        };
 
 /* -------------------------------------------------------*/
 
-PyTypeObject PyCursesWindow_Type = {
-	PyVarObject_HEAD_INIT(NULL, 0)
-	"_curses.curses window",	/*tp_name*/
-	sizeof(PyCursesWindowObject),	/*tp_basicsize*/
-	0,			/*tp_itemsize*/
-	/* methods */
-	(destructor)PyCursesWindow_Dealloc, /*tp_dealloc*/
-	0,			/*tp_print*/
-	(getattrfunc)0,		/*tp_getattr*/
-	(setattrfunc)0,		/*tp_setattr*/
-	0,			/*tp_reserved*/
-	0,			/*tp_repr*/
-	0,			/*tp_as_number*/
-	0,			/*tp_as_sequence*/
-	0,			/*tp_as_mapping*/
-	0,			/*tp_hash*/
-	0,			/*tp_call*/
-	0,			/*tp_str*/
-	0,			/*tp_getattro*/
-	0,			/*tp_setattro*/
-	0,			/*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT,	/*tp_flags*/
-	0,			/*tp_doc*/
-	0,			/*tp_traverse*/
-	0,			/*tp_clear*/
-	0,			/*tp_richcompare*/
-	0,			/*tp_weaklistoffset*/
-	0,			/*tp_iter*/
-	0,			/*tp_iternext*/
-	PyCursesWindow_Methods,	/*tp_methods*/
-};
+        PyTypeObject PyCursesWindow_Type = {
+            PyVarObject_HEAD_INIT(NULL, 0)
+            "_curses.curses window",            /*tp_name*/
+            sizeof(PyCursesWindowObject),       /*tp_basicsize*/
+            0,                          /*tp_itemsize*/
+            /* methods */
+            (destructor)PyCursesWindow_Dealloc, /*tp_dealloc*/
+            0,                          /*tp_print*/
+            (getattrfunc)0,             /*tp_getattr*/
+            (setattrfunc)0,             /*tp_setattr*/
+            0,                          /*tp_reserved*/
+            0,                          /*tp_repr*/
+            0,                          /*tp_as_number*/
+            0,                          /*tp_as_sequence*/
+            0,                          /*tp_as_mapping*/
+            0,                          /*tp_hash*/
+            0,                          /*tp_call*/
+            0,                          /*tp_str*/
+            0,                          /*tp_getattro*/
+            0,                          /*tp_setattro*/
+            0,                          /*tp_as_buffer*/
+            Py_TPFLAGS_DEFAULT,         /*tp_flags*/
+            0,                          /*tp_doc*/
+            0,                          /*tp_traverse*/
+            0,                          /*tp_clear*/
+            0,                          /*tp_richcompare*/
+            0,                          /*tp_weaklistoffset*/
+            0,                          /*tp_iter*/
+            0,                          /*tp_iternext*/
+            PyCursesWindow_Methods,     /*tp_methods*/
+        };
 
 /*********************************************************************
  Global Functions
 **********************************************************************/
 
-NoArgNoReturnFunction(beep)
-NoArgNoReturnFunction(def_prog_mode)
-NoArgNoReturnFunction(def_shell_mode)
-NoArgNoReturnFunction(doupdate)
-NoArgNoReturnFunction(endwin)
-NoArgNoReturnFunction(flash)
-NoArgNoReturnFunction(nocbreak)
-NoArgNoReturnFunction(noecho)
-NoArgNoReturnFunction(nonl)
-NoArgNoReturnFunction(noraw)
-NoArgNoReturnFunction(reset_prog_mode)
-NoArgNoReturnFunction(reset_shell_mode)
-NoArgNoReturnFunction(resetty)
-NoArgNoReturnFunction(savetty)
+        NoArgNoReturnFunction(beep)
+            NoArgNoReturnFunction(def_prog_mode)
+            NoArgNoReturnFunction(def_shell_mode)
+            NoArgNoReturnFunction(doupdate)
+            NoArgNoReturnFunction(endwin)
+            NoArgNoReturnFunction(flash)
+            NoArgNoReturnFunction(nocbreak)
+            NoArgNoReturnFunction(noecho)
+            NoArgNoReturnFunction(nonl)
+            NoArgNoReturnFunction(noraw)
+            NoArgNoReturnFunction(reset_prog_mode)
+            NoArgNoReturnFunction(reset_shell_mode)
+            NoArgNoReturnFunction(resetty)
+            NoArgNoReturnFunction(savetty)
 
-NoArgOrFlagNoReturnFunction(cbreak)
-NoArgOrFlagNoReturnFunction(echo)
-NoArgOrFlagNoReturnFunction(nl)
-NoArgOrFlagNoReturnFunction(raw)
+            NoArgOrFlagNoReturnFunction(cbreak)
+            NoArgOrFlagNoReturnFunction(echo)
+            NoArgOrFlagNoReturnFunction(nl)
+            NoArgOrFlagNoReturnFunction(raw)
 
-NoArgReturnIntFunction(baudrate)
-NoArgReturnIntFunction(termattrs)
+            NoArgReturnIntFunction(baudrate)
+            NoArgReturnIntFunction(termattrs)
 
-NoArgReturnStringFunction(termname)
-NoArgReturnStringFunction(longname)
+            NoArgReturnStringFunction(termname)
+            NoArgReturnStringFunction(longname)
 
-NoArgTrueFalseFunction(can_change_color)
-NoArgTrueFalseFunction(has_colors)
-NoArgTrueFalseFunction(has_ic)
-NoArgTrueFalseFunction(has_il)
-NoArgTrueFalseFunction(isendwin)
-NoArgNoReturnVoidFunction(flushinp)
-NoArgNoReturnVoidFunction(noqiflush)
+            NoArgTrueFalseFunction(can_change_color)
+            NoArgTrueFalseFunction(has_colors)
+            NoArgTrueFalseFunction(has_ic)
+            NoArgTrueFalseFunction(has_il)
+            NoArgTrueFalseFunction(isendwin)
+            NoArgNoReturnVoidFunction(flushinp)
+            NoArgNoReturnVoidFunction(noqiflush)
 
-static PyObject *
-PyCurses_filter(PyObject *self)
-{
-  /* not checking for PyCursesInitialised here since filter() must
-     be called before initscr() */
-  filter();
-  Py_INCREF(Py_None);
-  return Py_None;
-}
+            static PyObject *
+            PyCurses_filter(PyObject *self)
+        {
+            /* not checking for PyCursesInitialised here since filter() must
+               be called before initscr() */
+            filter();
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
 
-static PyObject *
-PyCurses_Color_Content(PyObject *self, PyObject *args)
-{
-  short color,r,g,b;
+        static PyObject *
+            PyCurses_Color_Content(PyObject *self, PyObject *args)
+        {
+            short color,r,g,b;
 
-  PyCursesInitialised
-  PyCursesInitialisedColor
+            PyCursesInitialised
+                PyCursesInitialisedColor
 
-  if (!PyArg_ParseTuple(args, "h:color_content", &color)) return NULL;
+                if (!PyArg_ParseTuple(args, "h:color_content", &color)) return NULL;
 
-  if (color_content(color, &r, &g, &b) != ERR)
-    return Py_BuildValue("(iii)", r, g, b);
-  else {
-    PyErr_SetString(PyCursesError, 
-		    "Argument 1 was out of range. Check value of COLORS.");
-    return NULL;
-  }
-}
+            if (color_content(color, &r, &g, &b) != ERR)
+                return Py_BuildValue("(iii)", r, g, b);
+            else {
+                PyErr_SetString(PyCursesError,
+                                "Argument 1 was out of range. Check value of COLORS.");
+                return NULL;
+            }
+        }
 
-static PyObject *
-PyCurses_color_pair(PyObject *self, PyObject *args)
-{
-  int n;
+        static PyObject *
+            PyCurses_color_pair(PyObject *self, PyObject *args)
+        {
+            int n;
 
-  PyCursesInitialised
-  PyCursesInitialisedColor
+            PyCursesInitialised
+                PyCursesInitialisedColor
 
-  if (!PyArg_ParseTuple(args, "i:color_pair", &n)) return NULL;
-  return PyLong_FromLong((long) (n << 8));
-}
+                if (!PyArg_ParseTuple(args, "i:color_pair", &n)) return NULL;
+            return PyLong_FromLong((long) (n << 8));
+        }
 
-static PyObject *
-PyCurses_Curs_Set(PyObject *self, PyObject *args)
-{
-  int vis,erg;
+        static PyObject *
+            PyCurses_Curs_Set(PyObject *self, PyObject *args)
+        {
+            int vis,erg;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  if (!PyArg_ParseTuple(args, "i:curs_set", &vis)) return NULL;
+                if (!PyArg_ParseTuple(args, "i:curs_set", &vis)) return NULL;
 
-  erg = curs_set(vis);
-  if (erg == ERR) return PyCursesCheckERR(erg, "curs_set");
+            erg = curs_set(vis);
+            if (erg == ERR) return PyCursesCheckERR(erg, "curs_set");
 
-  return PyLong_FromLong((long) erg);
-}
+            return PyLong_FromLong((long) erg);
+        }
 
-static PyObject *
-PyCurses_Delay_Output(PyObject *self, PyObject *args)
-{
-  int ms;
+        static PyObject *
+            PyCurses_Delay_Output(PyObject *self, PyObject *args)
+        {
+            int ms;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  if (!PyArg_ParseTuple(args, "i:delay_output", &ms)) return NULL;
+                if (!PyArg_ParseTuple(args, "i:delay_output", &ms)) return NULL;
 
-  return PyCursesCheckERR(delay_output(ms), "delay_output");
-}
+            return PyCursesCheckERR(delay_output(ms), "delay_output");
+        }
 
-static PyObject *
-PyCurses_EraseChar(PyObject *self)
-{
-  char ch;
+        static PyObject *
+            PyCurses_EraseChar(PyObject *self)
+        {
+            char ch;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  ch = erasechar();
+                ch = erasechar();
 
-  return PyBytes_FromStringAndSize(&ch, 1);
-}
+            return PyBytes_FromStringAndSize(&ch, 1);
+        }
 
-static PyObject *
-PyCurses_getsyx(PyObject *self)
-{
-  int x = 0;
-  int y = 0;
+        static PyObject *
+            PyCurses_getsyx(PyObject *self)
+        {
+            int x = 0;
+            int y = 0;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  getsyx(y, x);
+                getsyx(y, x);
 
-  return Py_BuildValue("(ii)", y, x);
-}
+            return Py_BuildValue("(ii)", y, x);
+        }
 
 #ifdef NCURSES_MOUSE_VERSION
-static PyObject *
-PyCurses_GetMouse(PyObject *self)
-{
-	int rtn;
-	MEVENT event;
+        static PyObject *
+            PyCurses_GetMouse(PyObject *self)
+        {
+            int rtn;
+            MEVENT event;
 
-	PyCursesInitialised
+            PyCursesInitialised
 
-	rtn = getmouse( &event );
-	if (rtn == ERR) {
-		PyErr_SetString(PyCursesError, "getmouse() returned ERR");
-		return NULL;
-	}
-	return Py_BuildValue("(hiiil)", 
-			     (short)event.id, 
-			     event.x, event.y, event.z,
-			     (long) event.bstate);
-}
+                rtn = getmouse( &event );
+            if (rtn == ERR) {
+                PyErr_SetString(PyCursesError, "getmouse() returned ERR");
+                return NULL;
+            }
+            return Py_BuildValue("(hiiil)",
+                                 (short)event.id,
+                                 event.x, event.y, event.z,
+                                 (long) event.bstate);
+        }
 
-static PyObject *
-PyCurses_UngetMouse(PyObject *self, PyObject *args)
-{
-	MEVENT event;
+        static PyObject *
+            PyCurses_UngetMouse(PyObject *self, PyObject *args)
+        {
+            MEVENT event;
 
-	PyCursesInitialised
-	if (!PyArg_ParseTuple(args, "hiiil",
-			     &event.id, 
-			     &event.x, &event.y, &event.z,
-			     (int *) &event.bstate))
-	  return NULL;
+            PyCursesInitialised
+                if (!PyArg_ParseTuple(args, "hiiil",
+                                      &event.id,
+                                      &event.x, &event.y, &event.z,
+                                      (int *) &event.bstate))
+                    return NULL;
 
-	return PyCursesCheckERR(ungetmouse(&event), "ungetmouse");
-}
+            return PyCursesCheckERR(ungetmouse(&event), "ungetmouse");
+        }
 #endif
 
-static PyObject *
-PyCurses_GetWin(PyCursesWindowObject *self, PyObject *stream)
-{
-  char fn[100];
-  int fd;
-  FILE *fp;
-  PyObject *data;
-  size_t datalen;
-  WINDOW *win;
+        static PyObject *
+            PyCurses_GetWin(PyCursesWindowObject *self, PyObject *stream)
+        {
+            char fn[100];
+            int fd;
+            FILE *fp;
+            PyObject *data;
+            size_t datalen;
+            WINDOW *win;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  strcpy(fn, "/tmp/py.curses.getwin.XXXXXX");
-  fd = mkstemp(fn);
-  if (fd < 0)
-    return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
-  fp = fdopen(fd, "wb+");
-  if (fp == NULL) {
-    close(fd);
-    remove(fn);
-    return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
-  }
-  data = PyObject_CallMethod(stream, "read", "");
-  if (data == NULL) {
-    fclose(fp);
-    remove(fn);
-    return NULL;
-  }
-  if (!PyBytes_Check(data)) {
-    PyErr_Format(PyExc_TypeError,
-                 "f.read() returned %.100s instead of bytes",
-                 data->ob_type->tp_name);
-    Py_DECREF(data);
-    fclose(fp);
-    remove(fn);
-    return NULL;
-  }
-  datalen = PyBytes_GET_SIZE(data);
-  if (fwrite(PyBytes_AS_STRING(data), 1, datalen, fp) != datalen) {
-    Py_DECREF(data);
-    fclose(fp);
-    remove(fn);
-    return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
-  }
-  Py_DECREF(data);
-  fseek(fp, 0, 0);
-  win = getwin(fp);
-  fclose(fp);
-  remove(fn);
-  if (win == NULL) {
-    PyErr_SetString(PyCursesError, catchall_NULL);
-    return NULL;
-  }
-  return PyCursesWindow_New(win);
-}
+                strcpy(fn, "/tmp/py.curses.getwin.XXXXXX");
+            fd = mkstemp(fn);
+            if (fd < 0)
+                return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
+            fp = fdopen(fd, "wb+");
+            if (fp == NULL) {
+                close(fd);
+                remove(fn);
+                return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
+            }
+            data = PyObject_CallMethod(stream, "read", "");
+            if (data == NULL) {
+                fclose(fp);
+                remove(fn);
+                return NULL;
+            }
+            if (!PyBytes_Check(data)) {
+                PyErr_Format(PyExc_TypeError,
+                             "f.read() returned %.100s instead of bytes",
+                             data->ob_type->tp_name);
+                Py_DECREF(data);
+                fclose(fp);
+                remove(fn);
+                return NULL;
+            }
+            datalen = PyBytes_GET_SIZE(data);
+            if (fwrite(PyBytes_AS_STRING(data), 1, datalen, fp) != datalen) {
+                Py_DECREF(data);
+                fclose(fp);
+                remove(fn);
+                return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
+            }
+            Py_DECREF(data);
+            fseek(fp, 0, 0);
+            win = getwin(fp);
+            fclose(fp);
+            remove(fn);
+            if (win == NULL) {
+                PyErr_SetString(PyCursesError, catchall_NULL);
+                return NULL;
+            }
+            return PyCursesWindow_New(win);
+        }
 
-static PyObject *
-PyCurses_HalfDelay(PyObject *self, PyObject *args)
-{
-  unsigned char tenths;
+        static PyObject *
+            PyCurses_HalfDelay(PyObject *self, PyObject *args)
+        {
+            unsigned char tenths;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  if (!PyArg_ParseTuple(args, "b:halfdelay", &tenths)) return NULL;
+                if (!PyArg_ParseTuple(args, "b:halfdelay", &tenths)) return NULL;
 
-  return PyCursesCheckERR(halfdelay(tenths), "halfdelay");
-}
+            return PyCursesCheckERR(halfdelay(tenths), "halfdelay");
+        }
 
 #ifndef STRICT_SYSV_CURSES
- /* No has_key! */
-static PyObject * PyCurses_has_key(PyObject *self, PyObject *args)
-{
-  int ch;
+        /* No has_key! */
+        static PyObject * PyCurses_has_key(PyObject *self, PyObject *args)
+        {
+            int ch;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
+                if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
 
-  if (has_key(ch) == FALSE) {
-    Py_INCREF(Py_False);
-    return Py_False;
-  }
-  Py_INCREF(Py_True);
-  return Py_True; 
-}
+            if (has_key(ch) == FALSE) {
+                Py_INCREF(Py_False);
+                return Py_False;
+            }
+            Py_INCREF(Py_True);
+            return Py_True;
+        }
 #endif /* STRICT_SYSV_CURSES */
 
-static PyObject *
-PyCurses_Init_Color(PyObject *self, PyObject *args)
-{
-  short color, r, g, b;
+        static PyObject *
+            PyCurses_Init_Color(PyObject *self, PyObject *args)
+        {
+            short color, r, g, b;
 
-  PyCursesInitialised
-  PyCursesInitialisedColor
+            PyCursesInitialised
+                PyCursesInitialisedColor
 
-  switch(PyTuple_Size(args)) {
-  case 4:
-    if (!PyArg_ParseTuple(args, "hhhh;color,r,g,b", &color, &r, &g, &b)) return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "init_color requires 4 arguments");
-    return NULL;
-  }
+                switch(PyTuple_Size(args)) {
+                case 4:
+                    if (!PyArg_ParseTuple(args, "hhhh;color,r,g,b", &color, &r, &g, &b)) return NULL;
+                    break;
+                default:
+                    PyErr_SetString(PyExc_TypeError, "init_color requires 4 arguments");
+                    return NULL;
+                }
 
-  return PyCursesCheckERR(init_color(color, r, g, b), "init_color");
-}
+            return PyCursesCheckERR(init_color(color, r, g, b), "init_color");
+        }
 
-static PyObject *
-PyCurses_Init_Pair(PyObject *self, PyObject *args)
-{
-  short pair, f, b;
+        static PyObject *
+            PyCurses_Init_Pair(PyObject *self, PyObject *args)
+        {
+            short pair, f, b;
 
-  PyCursesInitialised
-  PyCursesInitialisedColor
+            PyCursesInitialised
+                PyCursesInitialisedColor
 
-  if (PyTuple_Size(args) != 3) {
-    PyErr_SetString(PyExc_TypeError, "init_pair requires 3 arguments");
-    return NULL;
-  }
+                if (PyTuple_Size(args) != 3) {
+                    PyErr_SetString(PyExc_TypeError, "init_pair requires 3 arguments");
+                    return NULL;
+                }
 
-  if (!PyArg_ParseTuple(args, "hhh;pair, f, b", &pair, &f, &b)) return NULL;
+            if (!PyArg_ParseTuple(args, "hhh;pair, f, b", &pair, &f, &b)) return NULL;
 
-  return PyCursesCheckERR(init_pair(pair, f, b), "init_pair");
-}
+            return PyCursesCheckERR(init_pair(pair, f, b), "init_pair");
+        }
 
-static PyObject *ModDict;
+        static PyObject *ModDict;
 
-static PyObject * 
-PyCurses_InitScr(PyObject *self)
-{
-  WINDOW *win;
+        static PyObject *
+            PyCurses_InitScr(PyObject *self)
+        {
+            WINDOW *win;
 
-  if (initialised == TRUE) {
-    wrefresh(stdscr);
-    return (PyObject *)PyCursesWindow_New(stdscr);
-  }
+            if (initialised == TRUE) {
+                wrefresh(stdscr);
+                return (PyObject *)PyCursesWindow_New(stdscr);
+            }
 
-  win = initscr();
+            win = initscr();
 
-  if (win == NULL) {
-    PyErr_SetString(PyCursesError, catchall_NULL);
-    return NULL;
-  }
+            if (win == NULL) {
+                PyErr_SetString(PyCursesError, catchall_NULL);
+                return NULL;
+            }
 
-  initialised = initialised_setupterm = TRUE;
+            initialised = initialised_setupterm = TRUE;
 
 /* This was moved from initcurses() because it core dumped on SGI,
    where they're not defined until you've called initscr() */
-#define SetDictInt(string,ch) \
-    do {							\
-	PyObject *o = PyLong_FromLong((long) (ch));		\
-	if (o && PyDict_SetItemString(ModDict, string, o) == 0)	{ \
-	    Py_DECREF(o);					\
-	}							\
-    } while (0)
+#define SetDictInt(string,ch)                                           \
+            do {                                                        \
+                PyObject *o = PyLong_FromLong((long) (ch));             \
+                if (o && PyDict_SetItemString(ModDict, string, o) == 0)     { \
+                    Py_DECREF(o);                                       \
+                }                                                       \
+            } while (0)
 
-	/* Here are some graphic symbols you can use */
-        SetDictInt("ACS_ULCORNER",      (ACS_ULCORNER));
-	SetDictInt("ACS_LLCORNER",      (ACS_LLCORNER));
-	SetDictInt("ACS_URCORNER",      (ACS_URCORNER));
-	SetDictInt("ACS_LRCORNER",      (ACS_LRCORNER));
-	SetDictInt("ACS_LTEE",          (ACS_LTEE));
-	SetDictInt("ACS_RTEE",          (ACS_RTEE));
-	SetDictInt("ACS_BTEE",          (ACS_BTEE));
-	SetDictInt("ACS_TTEE",          (ACS_TTEE));
-	SetDictInt("ACS_HLINE",         (ACS_HLINE));
-	SetDictInt("ACS_VLINE",         (ACS_VLINE));
-	SetDictInt("ACS_PLUS",          (ACS_PLUS));
+            /* Here are some graphic symbols you can use */
+            SetDictInt("ACS_ULCORNER",      (ACS_ULCORNER));
+            SetDictInt("ACS_LLCORNER",      (ACS_LLCORNER));
+            SetDictInt("ACS_URCORNER",      (ACS_URCORNER));
+            SetDictInt("ACS_LRCORNER",      (ACS_LRCORNER));
+            SetDictInt("ACS_LTEE",          (ACS_LTEE));
+            SetDictInt("ACS_RTEE",          (ACS_RTEE));
+            SetDictInt("ACS_BTEE",          (ACS_BTEE));
+            SetDictInt("ACS_TTEE",          (ACS_TTEE));
+            SetDictInt("ACS_HLINE",         (ACS_HLINE));
+            SetDictInt("ACS_VLINE",         (ACS_VLINE));
+            SetDictInt("ACS_PLUS",          (ACS_PLUS));
 #if !defined(__hpux) || defined(HAVE_NCURSES_H)
-        /* On HP/UX 11, these are of type cchar_t, which is not an
-           integral type. If this is a problem on more platforms, a
-           configure test should be added to determine whether ACS_S1
-           is of integral type. */
-	SetDictInt("ACS_S1",            (ACS_S1));
-	SetDictInt("ACS_S9",            (ACS_S9));
-	SetDictInt("ACS_DIAMOND",       (ACS_DIAMOND));
-	SetDictInt("ACS_CKBOARD",       (ACS_CKBOARD));
-	SetDictInt("ACS_DEGREE",        (ACS_DEGREE));
-	SetDictInt("ACS_PLMINUS",       (ACS_PLMINUS));
-	SetDictInt("ACS_BULLET",        (ACS_BULLET));
-	SetDictInt("ACS_LARROW",        (ACS_LARROW));
-	SetDictInt("ACS_RARROW",        (ACS_RARROW));
-	SetDictInt("ACS_DARROW",        (ACS_DARROW));
-	SetDictInt("ACS_UARROW",        (ACS_UARROW));
-	SetDictInt("ACS_BOARD",         (ACS_BOARD));
-	SetDictInt("ACS_LANTERN",       (ACS_LANTERN));
-	SetDictInt("ACS_BLOCK",         (ACS_BLOCK));
+            /* On HP/UX 11, these are of type cchar_t, which is not an
+               integral type. If this is a problem on more platforms, a
+               configure test should be added to determine whether ACS_S1
+               is of integral type. */
+            SetDictInt("ACS_S1",            (ACS_S1));
+            SetDictInt("ACS_S9",            (ACS_S9));
+            SetDictInt("ACS_DIAMOND",       (ACS_DIAMOND));
+            SetDictInt("ACS_CKBOARD",       (ACS_CKBOARD));
+            SetDictInt("ACS_DEGREE",        (ACS_DEGREE));
+            SetDictInt("ACS_PLMINUS",       (ACS_PLMINUS));
+            SetDictInt("ACS_BULLET",        (ACS_BULLET));
+            SetDictInt("ACS_LARROW",        (ACS_LARROW));
+            SetDictInt("ACS_RARROW",        (ACS_RARROW));
+            SetDictInt("ACS_DARROW",        (ACS_DARROW));
+            SetDictInt("ACS_UARROW",        (ACS_UARROW));
+            SetDictInt("ACS_BOARD",         (ACS_BOARD));
+            SetDictInt("ACS_LANTERN",       (ACS_LANTERN));
+            SetDictInt("ACS_BLOCK",         (ACS_BLOCK));
 #endif
-	SetDictInt("ACS_BSSB",          (ACS_ULCORNER));
-	SetDictInt("ACS_SSBB",          (ACS_LLCORNER));
-	SetDictInt("ACS_BBSS",          (ACS_URCORNER));
-	SetDictInt("ACS_SBBS",          (ACS_LRCORNER));
-	SetDictInt("ACS_SBSS",          (ACS_RTEE));
-	SetDictInt("ACS_SSSB",          (ACS_LTEE));
-	SetDictInt("ACS_SSBS",          (ACS_BTEE));
-	SetDictInt("ACS_BSSS",          (ACS_TTEE));
-	SetDictInt("ACS_BSBS",          (ACS_HLINE));
-	SetDictInt("ACS_SBSB",          (ACS_VLINE));
-	SetDictInt("ACS_SSSS",          (ACS_PLUS));
+            SetDictInt("ACS_BSSB",          (ACS_ULCORNER));
+            SetDictInt("ACS_SSBB",          (ACS_LLCORNER));
+            SetDictInt("ACS_BBSS",          (ACS_URCORNER));
+            SetDictInt("ACS_SBBS",          (ACS_LRCORNER));
+            SetDictInt("ACS_SBSS",          (ACS_RTEE));
+            SetDictInt("ACS_SSSB",          (ACS_LTEE));
+            SetDictInt("ACS_SSBS",          (ACS_BTEE));
+            SetDictInt("ACS_BSSS",          (ACS_TTEE));
+            SetDictInt("ACS_BSBS",          (ACS_HLINE));
+            SetDictInt("ACS_SBSB",          (ACS_VLINE));
+            SetDictInt("ACS_SSSS",          (ACS_PLUS));
 
-	/* The following are never available with strict SYSV curses */
+            /* The following are never available with strict SYSV curses */
 #ifdef ACS_S3
-	SetDictInt("ACS_S3",            (ACS_S3));
+            SetDictInt("ACS_S3",            (ACS_S3));
 #endif
 #ifdef ACS_S7
-	SetDictInt("ACS_S7",            (ACS_S7));
+            SetDictInt("ACS_S7",            (ACS_S7));
 #endif
 #ifdef ACS_LEQUAL
-	SetDictInt("ACS_LEQUAL",        (ACS_LEQUAL));
+            SetDictInt("ACS_LEQUAL",        (ACS_LEQUAL));
 #endif
 #ifdef ACS_GEQUAL
-	SetDictInt("ACS_GEQUAL",        (ACS_GEQUAL));
+            SetDictInt("ACS_GEQUAL",        (ACS_GEQUAL));
 #endif
 #ifdef ACS_PI
-	SetDictInt("ACS_PI",            (ACS_PI));
+            SetDictInt("ACS_PI",            (ACS_PI));
 #endif
 #ifdef ACS_NEQUAL
-	SetDictInt("ACS_NEQUAL",        (ACS_NEQUAL));
+            SetDictInt("ACS_NEQUAL",        (ACS_NEQUAL));
 #endif
 #ifdef ACS_STERLING
-	SetDictInt("ACS_STERLING",      (ACS_STERLING));
+            SetDictInt("ACS_STERLING",      (ACS_STERLING));
 #endif
 
-  SetDictInt("LINES", LINES);
-  SetDictInt("COLS", COLS);
+            SetDictInt("LINES", LINES);
+            SetDictInt("COLS", COLS);
 
-  return (PyObject *)PyCursesWindow_New(win);
-}
+            return (PyObject *)PyCursesWindow_New(win);
+        }
 
-static PyObject *
-PyCurses_setupterm(PyObject* self, PyObject *args, PyObject* keywds)
-{
-	int fd = -1;
-	int err;
-	char* termstr = NULL;
+        static PyObject *
+            PyCurses_setupterm(PyObject* self, PyObject *args, PyObject* keywds)
+        {
+            int fd = -1;
+            int err;
+            char* termstr = NULL;
 
-	static char *kwlist[] = {"term", "fd", NULL};
+            static char *kwlist[] = {"term", "fd", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(
-		args, keywds, "|zi:setupterm", kwlist, &termstr, &fd)) {
-		return NULL;
-	}
-	
-	if (fd == -1) {
-		PyObject* sys_stdout;
+            if (!PyArg_ParseTupleAndKeywords(
+                    args, keywds, "|zi:setupterm", kwlist, &termstr, &fd)) {
+                return NULL;
+            }
 
-		sys_stdout = PySys_GetObject("stdout");
+            if (fd == -1) {
+                PyObject* sys_stdout;
 
-		if (sys_stdout == NULL || sys_stdout == Py_None) {
-			PyErr_SetString(
-				PyCursesError,
-				"lost sys.stdout");
-			return NULL;
-		}
+                sys_stdout = PySys_GetObject("stdout");
 
-		fd = PyObject_AsFileDescriptor(sys_stdout);
+                if (sys_stdout == NULL || sys_stdout == Py_None) {
+                    PyErr_SetString(
+                        PyCursesError,
+                        "lost sys.stdout");
+                    return NULL;
+                }
 
-		if (fd == -1) {
-			return NULL;
-		}
-	}
+                fd = PyObject_AsFileDescriptor(sys_stdout);
 
-	if (setupterm(termstr,fd,&err) == ERR) {
-		char* s = "setupterm: unknown error";
-		
-		if (err == 0) {
-			s = "setupterm: could not find terminal";
-		} else if (err == -1) {
-			s = "setupterm: could not find terminfo database";
-		}
+                if (fd == -1) {
+                    return NULL;
+                }
+            }
 
-		PyErr_SetString(PyCursesError,s);
-		return NULL;
-	}
+            if (setupterm(termstr,fd,&err) == ERR) {
+                char* s = "setupterm: unknown error";
 
-	initialised_setupterm = TRUE;
+                if (err == 0) {
+                    s = "setupterm: could not find terminal";
+                } else if (err == -1) {
+                    s = "setupterm: could not find terminfo database";
+                }
 
-	Py_INCREF(Py_None);
-	return Py_None;	
-}
+                PyErr_SetString(PyCursesError,s);
+                return NULL;
+            }
 
-static PyObject *
-PyCurses_IntrFlush(PyObject *self, PyObject *args)
-{
-  int ch;
+            initialised_setupterm = TRUE;
 
-  PyCursesInitialised
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
 
-  switch(PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "intrflush requires 1 argument");
-    return NULL;
-  }
+        static PyObject *
+            PyCurses_IntrFlush(PyObject *self, PyObject *args)
+        {
+            int ch;
 
-  return PyCursesCheckERR(intrflush(NULL,ch), "intrflush");
-}
+            PyCursesInitialised
+
+                switch(PyTuple_Size(args)) {
+                case 1:
+                    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
+                    break;
+                default:
+                    PyErr_SetString(PyExc_TypeError, "intrflush requires 1 argument");
+                    return NULL;
+                }
+
+            return PyCursesCheckERR(intrflush(NULL,ch), "intrflush");
+        }
 
 #ifdef HAVE_CURSES_IS_TERM_RESIZED
-static PyObject *
-PyCurses_Is_Term_Resized(PyObject *self, PyObject *args)
-{
-  int lines;
-  int columns;
-  int result;
+        static PyObject *
+            PyCurses_Is_Term_Resized(PyObject *self, PyObject *args)
+        {
+            int lines;
+            int columns;
+            int result;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  if (!PyArg_ParseTuple(args,"ii:is_term_resized", &lines, &columns))
-    return NULL;
-  result = is_term_resized(lines, columns);
-  if (result == TRUE) {
-    Py_INCREF(Py_True);
-    return Py_True;
-  } else {
-    Py_INCREF(Py_False);
-    return Py_False;
-  }
-}
+                if (!PyArg_ParseTuple(args,"ii:is_term_resized", &lines, &columns))
+                    return NULL;
+            result = is_term_resized(lines, columns);
+            if (result == TRUE) {
+                Py_INCREF(Py_True);
+                return Py_True;
+            } else {
+                Py_INCREF(Py_False);
+                return Py_False;
+            }
+        }
 #endif /* HAVE_CURSES_IS_TERM_RESIZED */
 
 #if !defined(__NetBSD__)
-static PyObject *
-PyCurses_KeyName(PyObject *self, PyObject *args)
-{
-  const char *knp;
-  int ch;
+        static PyObject *
+            PyCurses_KeyName(PyObject *self, PyObject *args)
+        {
+            const char *knp;
+            int ch;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
+                if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
 
-  if (ch < 0) {
-    PyErr_SetString(PyExc_ValueError, "invalid key number");
-    return NULL;
-  }
-  knp = keyname(ch);
+            if (ch < 0) {
+                PyErr_SetString(PyExc_ValueError, "invalid key number");
+                return NULL;
+            }
+            knp = keyname(ch);
 
-  return PyBytes_FromString((knp == NULL) ? "" : (char *)knp);
-}
+            return PyBytes_FromString((knp == NULL) ? "" : (char *)knp);
+        }
 #endif
 
-static PyObject *  
-PyCurses_KillChar(PyObject *self)  
-{  
-  char ch;  
+        static PyObject *
+            PyCurses_KillChar(PyObject *self)
+        {
+            char ch;
 
-  ch = killchar();  
+            ch = killchar();
 
-  return PyBytes_FromStringAndSize(&ch, 1);  
-}  
+            return PyBytes_FromStringAndSize(&ch, 1);
+        }
 
-static PyObject *
-PyCurses_Meta(PyObject *self, PyObject *args)
-{
-  int ch;
+        static PyObject *
+            PyCurses_Meta(PyObject *self, PyObject *args)
+        {
+            int ch;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  switch(PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "meta requires 1 argument");
-    return NULL;
-  }
+                switch(PyTuple_Size(args)) {
+                case 1:
+                    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
+                    break;
+                default:
+                    PyErr_SetString(PyExc_TypeError, "meta requires 1 argument");
+                    return NULL;
+                }
 
-  return PyCursesCheckERR(meta(stdscr, ch), "meta");
-}
+            return PyCursesCheckERR(meta(stdscr, ch), "meta");
+        }
 
 #ifdef NCURSES_MOUSE_VERSION
-static PyObject *
-PyCurses_MouseInterval(PyObject *self, PyObject *args)
-{
-	int interval;
-	PyCursesInitialised 
+        static PyObject *
+            PyCurses_MouseInterval(PyObject *self, PyObject *args)
+        {
+            int interval;
+            PyCursesInitialised
 
-	if (!PyArg_ParseTuple(args,"i;interval",&interval)) 
-		return NULL;
-	return PyCursesCheckERR(mouseinterval(interval), "mouseinterval");
-}
+                if (!PyArg_ParseTuple(args,"i;interval",&interval))
+                    return NULL;
+            return PyCursesCheckERR(mouseinterval(interval), "mouseinterval");
+        }
 
-static PyObject *
-PyCurses_MouseMask(PyObject *self, PyObject *args)
-{
-	int newmask;
-	mmask_t oldmask, availmask;
+        static PyObject *
+            PyCurses_MouseMask(PyObject *self, PyObject *args)
+        {
+            int newmask;
+            mmask_t oldmask, availmask;
 
-	PyCursesInitialised 
-	if (!PyArg_ParseTuple(args,"i;mousemask",&newmask)) 
-		return NULL;
-	availmask = mousemask(newmask, &oldmask);
-	return Py_BuildValue("(ll)", (long)availmask, (long)oldmask);
-}
+            PyCursesInitialised
+                if (!PyArg_ParseTuple(args,"i;mousemask",&newmask))
+                    return NULL;
+            availmask = mousemask(newmask, &oldmask);
+            return Py_BuildValue("(ll)", (long)availmask, (long)oldmask);
+        }
 #endif
 
-static PyObject *
-PyCurses_Napms(PyObject *self, PyObject *args)
-{
-    int ms;
+        static PyObject *
+            PyCurses_Napms(PyObject *self, PyObject *args)
+        {
+            int ms;
 
-    PyCursesInitialised
-    if (!PyArg_ParseTuple(args, "i;ms", &ms)) return NULL;
+            PyCursesInitialised
+                if (!PyArg_ParseTuple(args, "i;ms", &ms)) return NULL;
 
-    return Py_BuildValue("i", napms(ms));
-}
+            return Py_BuildValue("i", napms(ms));
+        }
 
 
-static PyObject *
-PyCurses_NewPad(PyObject *self, PyObject *args)
-{
-  WINDOW *win;
-  int nlines, ncols;
+        static PyObject *
+            PyCurses_NewPad(PyObject *self, PyObject *args)
+        {
+            WINDOW *win;
+            int nlines, ncols;
 
-  PyCursesInitialised 
+            PyCursesInitialised
 
-  if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols)) return NULL;
+                if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols)) return NULL;
 
-  win = newpad(nlines, ncols);
-  
-  if (win == NULL) {
-    PyErr_SetString(PyCursesError, catchall_NULL);
-    return NULL;
-  }
+            win = newpad(nlines, ncols);
 
-  return (PyObject *)PyCursesWindow_New(win);
-}
+            if (win == NULL) {
+                PyErr_SetString(PyCursesError, catchall_NULL);
+                return NULL;
+            }
 
-static PyObject *
-PyCurses_NewWindow(PyObject *self, PyObject *args)
-{
-  WINDOW *win;
-  int nlines, ncols, begin_y=0, begin_x=0;
+            return (PyObject *)PyCursesWindow_New(win);
+        }
 
-  PyCursesInitialised
+        static PyObject *
+            PyCurses_NewWindow(PyObject *self, PyObject *args)
+        {
+            WINDOW *win;
+            int nlines, ncols, begin_y=0, begin_x=0;
 
-  switch (PyTuple_Size(args)) {
-  case 2:
-    if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols))
-      return NULL;
-    break;
-  case 4:
-    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
-		   &nlines,&ncols,&begin_y,&begin_x))
-      return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "newwin requires 2 or 4 arguments");
-    return NULL;
-  }
+            PyCursesInitialised
 
-  win = newwin(nlines,ncols,begin_y,begin_x);
-  if (win == NULL) {
-    PyErr_SetString(PyCursesError, catchall_NULL);
-    return NULL;
-  }
+                switch (PyTuple_Size(args)) {
+                case 2:
+                    if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols))
+                        return NULL;
+                    break;
+                case 4:
+                    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
+                                          &nlines,&ncols,&begin_y,&begin_x))
+                        return NULL;
+                    break;
+                default:
+                    PyErr_SetString(PyExc_TypeError, "newwin requires 2 or 4 arguments");
+                    return NULL;
+                }
 
-  return (PyObject *)PyCursesWindow_New(win);
-}
+            win = newwin(nlines,ncols,begin_y,begin_x);
+            if (win == NULL) {
+                PyErr_SetString(PyCursesError, catchall_NULL);
+                return NULL;
+            }
 
-static PyObject *
-PyCurses_Pair_Content(PyObject *self, PyObject *args)
-{
-  short pair,f,b;
+            return (PyObject *)PyCursesWindow_New(win);
+        }
 
-  PyCursesInitialised
-  PyCursesInitialisedColor
+        static PyObject *
+            PyCurses_Pair_Content(PyObject *self, PyObject *args)
+        {
+            short pair,f,b;
 
-  switch(PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args, "h;pair", &pair)) return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "pair_content requires 1 argument");
-    return NULL;
-  }
+            PyCursesInitialised
+                PyCursesInitialisedColor
 
-  if (pair_content(pair, &f, &b)==ERR) {
-    PyErr_SetString(PyCursesError,
-		    "Argument 1 was out of range. (1..COLOR_PAIRS-1)");
-    return NULL;
-  }
+                switch(PyTuple_Size(args)) {
+                case 1:
+                    if (!PyArg_ParseTuple(args, "h;pair", &pair)) return NULL;
+                    break;
+                default:
+                    PyErr_SetString(PyExc_TypeError, "pair_content requires 1 argument");
+                    return NULL;
+                }
 
-  return Py_BuildValue("(ii)", f, b);
-}
+            if (pair_content(pair, &f, &b)==ERR) {
+                PyErr_SetString(PyCursesError,
+                                "Argument 1 was out of range. (1..COLOR_PAIRS-1)");
+                return NULL;
+            }
 
-static PyObject *
-PyCurses_pair_number(PyObject *self, PyObject *args)
-{
-  int n;
+            return Py_BuildValue("(ii)", f, b);
+        }
 
-  PyCursesInitialised
-  PyCursesInitialisedColor
+        static PyObject *
+            PyCurses_pair_number(PyObject *self, PyObject *args)
+        {
+            int n;
 
-  switch(PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args, "i;pairvalue", &n)) return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError,
-                    "pair_number requires 1 argument");
-    return NULL;
-  }
+            PyCursesInitialised
+                PyCursesInitialisedColor
 
-  return PyLong_FromLong((long) ((n & A_COLOR) >> 8));
-}
+                switch(PyTuple_Size(args)) {
+                case 1:
+                    if (!PyArg_ParseTuple(args, "i;pairvalue", &n)) return NULL;
+                    break;
+                default:
+                    PyErr_SetString(PyExc_TypeError,
+                                    "pair_number requires 1 argument");
+                    return NULL;
+                }
 
-static PyObject *
-PyCurses_Putp(PyObject *self, PyObject *args)
-{
-  char *str;
+            return PyLong_FromLong((long) ((n & A_COLOR) >> 8));
+        }
 
-  if (!PyArg_ParseTuple(args,"s;str", &str)) return NULL;
-  return PyCursesCheckERR(putp(str), "putp");
-}
+        static PyObject *
+            PyCurses_Putp(PyObject *self, PyObject *args)
+        {
+            char *str;
 
-static PyObject *
-PyCurses_QiFlush(PyObject *self, PyObject *args)
-{
-  int flag = 0;
+            if (!PyArg_ParseTuple(args,"s;str", &str)) return NULL;
+            return PyCursesCheckERR(putp(str), "putp");
+        }
 
-  PyCursesInitialised
+        static PyObject *
+            PyCurses_QiFlush(PyObject *self, PyObject *args)
+        {
+            int flag = 0;
 
-  switch(PyTuple_Size(args)) {
-  case 0:
-    qiflush();
-    Py_INCREF(Py_None);
-    return Py_None;
-  case 1:
-    if (!PyArg_ParseTuple(args, "i;True(1) or False(0)", &flag)) return NULL;
-    if (flag) qiflush();
-    else noqiflush();
-    Py_INCREF(Py_None);
-    return Py_None;
-  default:
-    PyErr_SetString(PyExc_TypeError, "qiflush requires 0 or 1 arguments");
-    return NULL;
-  }
-}
+            PyCursesInitialised
+
+                switch(PyTuple_Size(args)) {
+                case 0:
+                    qiflush();
+                    Py_INCREF(Py_None);
+                    return Py_None;
+                case 1:
+                    if (!PyArg_ParseTuple(args, "i;True(1) or False(0)", &flag)) return NULL;
+                    if (flag) qiflush();
+                    else noqiflush();
+                    Py_INCREF(Py_None);
+                    return Py_None;
+                default:
+                    PyErr_SetString(PyExc_TypeError, "qiflush requires 0 or 1 arguments");
+                    return NULL;
+                }
+        }
 
 /* Internal helper used for updating curses.LINES, curses.COLS, _curses.LINES
  * and _curses.COLS */
 #if defined(HAVE_CURSES_RESIZETERM) || defined(HAVE_CURSES_RESIZE_TERM)
-static int
-update_lines_cols(void)
-{
-  PyObject *o;
-  PyObject *m = PyImport_ImportModuleNoBlock("curses");
+        static int
+            update_lines_cols(void)
+        {
+            PyObject *o;
+            PyObject *m = PyImport_ImportModuleNoBlock("curses");
 
-  if (!m)
-    return 0;
+            if (!m)
+                return 0;
 
-  o = PyLong_FromLong(LINES);
-  if (!o) {
-    Py_DECREF(m);
-    return 0;
-  }
-  if (PyObject_SetAttrString(m, "LINES", o)) {
-    Py_DECREF(m);
-    Py_DECREF(o);
-    return 0;
-  }
-  if (PyDict_SetItemString(ModDict, "LINES", o)) {
-    Py_DECREF(m);
-    Py_DECREF(o);
-    return 0;
-  }
-  Py_DECREF(o);
-  o = PyLong_FromLong(COLS);
-  if (!o) {
-    Py_DECREF(m);
-    return 0;
-  }
-  if (PyObject_SetAttrString(m, "COLS", o)) {
-    Py_DECREF(m);
-    Py_DECREF(o);
-    return 0;
-  }
-  if (PyDict_SetItemString(ModDict, "COLS", o)) {
-    Py_DECREF(m);
-    Py_DECREF(o);
-    return 0;
-  }
-  Py_DECREF(o);
-  Py_DECREF(m);
-  return 1;
-}
+            o = PyLong_FromLong(LINES);
+            if (!o) {
+                Py_DECREF(m);
+                return 0;
+            }
+            if (PyObject_SetAttrString(m, "LINES", o)) {
+                Py_DECREF(m);
+                Py_DECREF(o);
+                return 0;
+            }
+            if (PyDict_SetItemString(ModDict, "LINES", o)) {
+                Py_DECREF(m);
+                Py_DECREF(o);
+                return 0;
+            }
+            Py_DECREF(o);
+            o = PyLong_FromLong(COLS);
+            if (!o) {
+                Py_DECREF(m);
+                return 0;
+            }
+            if (PyObject_SetAttrString(m, "COLS", o)) {
+                Py_DECREF(m);
+                Py_DECREF(o);
+                return 0;
+            }
+            if (PyDict_SetItemString(ModDict, "COLS", o)) {
+                Py_DECREF(m);
+                Py_DECREF(o);
+                return 0;
+            }
+            Py_DECREF(o);
+            Py_DECREF(m);
+            return 1;
+        }
 #endif
 
 #ifdef HAVE_CURSES_RESIZETERM
-static PyObject *
-PyCurses_ResizeTerm(PyObject *self, PyObject *args)
-{
-  int lines;
-  int columns;
-  PyObject *result;
+        static PyObject *
+            PyCurses_ResizeTerm(PyObject *self, PyObject *args)
+        {
+            int lines;
+            int columns;
+            PyObject *result;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  if (!PyArg_ParseTuple(args,"ii:resizeterm", &lines, &columns))
-    return NULL;
+                if (!PyArg_ParseTuple(args,"ii:resizeterm", &lines, &columns))
+                    return NULL;
 
-  result = PyCursesCheckERR(resizeterm(lines, columns), "resizeterm");
-  if (!result)
-    return NULL;
-  if (!update_lines_cols())
-    return NULL;
-  return result;
-}
+            result = PyCursesCheckERR(resizeterm(lines, columns), "resizeterm");
+            if (!result)
+                return NULL;
+            if (!update_lines_cols())
+                return NULL;
+            return result;
+        }
 
 #endif
 
 #ifdef HAVE_CURSES_RESIZE_TERM
-static PyObject *
-PyCurses_Resize_Term(PyObject *self, PyObject *args)
-{
-  int lines;
-  int columns;
+        static PyObject *
+            PyCurses_Resize_Term(PyObject *self, PyObject *args)
+        {
+            int lines;
+            int columns;
 
-  PyObject *result;
+            PyObject *result;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  if (!PyArg_ParseTuple(args,"ii:resize_term", &lines, &columns))
-    return NULL;
+                if (!PyArg_ParseTuple(args,"ii:resize_term", &lines, &columns))
+                    return NULL;
 
-  result = PyCursesCheckERR(resize_term(lines, columns), "resize_term");
-  if (!result)
-    return NULL;
-  if (!update_lines_cols())
-    return NULL;
-  return result;
-}
+            result = PyCursesCheckERR(resize_term(lines, columns), "resize_term");
+            if (!result)
+                return NULL;
+            if (!update_lines_cols())
+                return NULL;
+            return result;
+        }
 #endif /* HAVE_CURSES_RESIZE_TERM */
 
-static PyObject *
-PyCurses_setsyx(PyObject *self, PyObject *args)
-{
-  int y,x;
+        static PyObject *
+            PyCurses_setsyx(PyObject *self, PyObject *args)
+        {
+            int y,x;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  if (PyTuple_Size(args)!=2) {
-    PyErr_SetString(PyExc_TypeError, "setsyx requires 2 arguments");
-    return NULL;
-  }
+                if (PyTuple_Size(args)!=2) {
+                    PyErr_SetString(PyExc_TypeError, "setsyx requires 2 arguments");
+                    return NULL;
+                }
 
-  if (!PyArg_ParseTuple(args, "ii;y, x", &y, &x)) return NULL;
+            if (!PyArg_ParseTuple(args, "ii;y, x", &y, &x)) return NULL;
 
-  setsyx(y,x);
+            setsyx(y,x);
 
-  Py_INCREF(Py_None);
-  return Py_None;
-}
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
 
-static PyObject *
-PyCurses_Start_Color(PyObject *self)
-{
-  int code;
-  PyObject *c, *cp;
+        static PyObject *
+            PyCurses_Start_Color(PyObject *self)
+        {
+            int code;
+            PyObject *c, *cp;
 
-  PyCursesInitialised
+            PyCursesInitialised
 
-  code = start_color();
-  if (code != ERR) {
-    initialisedcolors = TRUE;
-    c = PyLong_FromLong((long) COLORS);
-    PyDict_SetItemString(ModDict, "COLORS", c);
-    Py_DECREF(c);
-    cp = PyLong_FromLong((long) COLOR_PAIRS);
-    PyDict_SetItemString(ModDict, "COLOR_PAIRS", cp);
-    Py_DECREF(cp);
-    Py_INCREF(Py_None);
-    return Py_None;
-  } else {
-    PyErr_SetString(PyCursesError, "start_color() returned ERR");
-    return NULL;
-  }
-}
+                code = start_color();
+            if (code != ERR) {
+                initialisedcolors = TRUE;
+                c = PyLong_FromLong((long) COLORS);
+                PyDict_SetItemString(ModDict, "COLORS", c);
+                Py_DECREF(c);
+                cp = PyLong_FromLong((long) COLOR_PAIRS);
+                PyDict_SetItemString(ModDict, "COLOR_PAIRS", cp);
+                Py_DECREF(cp);
+                Py_INCREF(Py_None);
+                return Py_None;
+            } else {
+                PyErr_SetString(PyCursesError, "start_color() returned ERR");
+                return NULL;
+            }
+        }
 
-static PyObject *
-PyCurses_tigetflag(PyObject *self, PyObject *args)
-{
-	char *capname;
+        static PyObject *
+            PyCurses_tigetflag(PyObject *self, PyObject *args)
+        {
+            char *capname;
 
-	PyCursesSetupTermCalled;
-		
-	if (!PyArg_ParseTuple(args, "s", &capname))
-		return NULL;
+            PyCursesSetupTermCalled;
 
-	return PyLong_FromLong( (long) tigetflag( capname ) );
-}
+            if (!PyArg_ParseTuple(args, "s", &capname))
+                return NULL;
 
-static PyObject *
-PyCurses_tigetnum(PyObject *self, PyObject *args)
-{
-	char *capname;
+            return PyLong_FromLong( (long) tigetflag( capname ) );
+        }
 
-	PyCursesSetupTermCalled;
-		
-	if (!PyArg_ParseTuple(args, "s", &capname))
-		return NULL;
+        static PyObject *
+            PyCurses_tigetnum(PyObject *self, PyObject *args)
+        {
+            char *capname;
 
-	return PyLong_FromLong( (long) tigetnum( capname ) );
-}
+            PyCursesSetupTermCalled;
 
-static PyObject *
-PyCurses_tigetstr(PyObject *self, PyObject *args)
-{
-	char *capname;
+            if (!PyArg_ParseTuple(args, "s", &capname))
+                return NULL;
 
-	PyCursesSetupTermCalled;
-		
-	if (!PyArg_ParseTuple(args, "s", &capname))
-		return NULL;
+            return PyLong_FromLong( (long) tigetnum( capname ) );
+        }
 
-	capname = tigetstr( capname );
-	if (capname == 0 || capname == (char*) -1) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	return PyBytes_FromString( capname );
-}
+        static PyObject *
+            PyCurses_tigetstr(PyObject *self, PyObject *args)
+        {
+            char *capname;
 
-static PyObject *
-PyCurses_tparm(PyObject *self, PyObject *args)
-{
-	char* fmt;
-	char* result = NULL;
-	int i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;
+            PyCursesSetupTermCalled;
 
-	PyCursesSetupTermCalled;
+            if (!PyArg_ParseTuple(args, "s", &capname))
+                return NULL;
 
-	if (!PyArg_ParseTuple(args, "s|iiiiiiiii:tparm", 
-			      &fmt, &i1, &i2, &i3, &i4, 
-			      &i5, &i6, &i7, &i8, &i9)) {
-		return NULL;
-	}
+            capname = tigetstr( capname );
+            if (capname == 0 || capname == (char*) -1) {
+                Py_INCREF(Py_None);
+                return Py_None;
+            }
+            return PyBytes_FromString( capname );
+        }
 
-	result = tparm(fmt,i1,i2,i3,i4,i5,i6,i7,i8,i9);
-	if (!result) {
-		PyErr_SetString(PyCursesError, "tparm() returned NULL");
-  		return NULL;
-	}
+        static PyObject *
+            PyCurses_tparm(PyObject *self, PyObject *args)
+        {
+            char* fmt;
+            char* result = NULL;
+            int i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;
 
-	return PyBytes_FromString(result);
-}
+            PyCursesSetupTermCalled;
 
-static PyObject *
-PyCurses_TypeAhead(PyObject *self, PyObject *args)
-{
-  int fd;
+            if (!PyArg_ParseTuple(args, "s|iiiiiiiii:tparm",
+                                  &fmt, &i1, &i2, &i3, &i4,
+                                  &i5, &i6, &i7, &i8, &i9)) {
+                return NULL;
+            }
 
-  PyCursesInitialised
+            result = tparm(fmt,i1,i2,i3,i4,i5,i6,i7,i8,i9);
+            if (!result) {
+                PyErr_SetString(PyCursesError, "tparm() returned NULL");
+                return NULL;
+            }
 
-  if (!PyArg_ParseTuple(args,"i;fd",&fd)) return NULL;
+            return PyBytes_FromString(result);
+        }
 
-  return PyCursesCheckERR(typeahead( fd ), "typeahead");
-}
+        static PyObject *
+            PyCurses_TypeAhead(PyObject *self, PyObject *args)
+        {
+            int fd;
 
-static PyObject *
-PyCurses_UnCtrl(PyObject *self, PyObject *args)
-{
-  PyObject *temp;
-  chtype ch;
+            PyCursesInitialised
 
-  PyCursesInitialised
+                if (!PyArg_ParseTuple(args,"i;fd",&fd)) return NULL;
 
-  if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
+            return PyCursesCheckERR(typeahead( fd ), "typeahead");
+        }
 
-  if (!PyCurses_ConvertToChtype(temp, &ch)) {
-    PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
-    return NULL;
-  }
+        static PyObject *
+            PyCurses_UnCtrl(PyObject *self, PyObject *args)
+        {
+            PyObject *temp;
+            chtype ch;
 
-  return PyBytes_FromString(unctrl(ch));
-}
+            PyCursesInitialised
 
-static PyObject *
-PyCurses_UngetCh(PyObject *self, PyObject *args)
-{
-  PyObject *temp;
-  chtype ch;
+                if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
 
-  PyCursesInitialised
+            if (!PyCurses_ConvertToChtype(temp, &ch)) {
+                PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
+                return NULL;
+            }
 
-  if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
+            return PyBytes_FromString(unctrl(ch));
+        }
 
-  if (!PyCurses_ConvertToChtype(temp, &ch)) {
-    PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
-    return NULL;
-  }
+        static PyObject *
+            PyCurses_UngetCh(PyObject *self, PyObject *args)
+        {
+            PyObject *temp;
+            chtype ch;
 
-  return PyCursesCheckERR(ungetch(ch), "ungetch");
-}
+            PyCursesInitialised
 
-static PyObject *
-PyCurses_Use_Env(PyObject *self, PyObject *args)
-{
-  int flag;
+                if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
 
-  switch(PyTuple_Size(args)) {
-  case 1:
-    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&flag))
-      return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "use_env requires 1 argument");
-    return NULL;
-  }
-  use_env(flag);
-  Py_INCREF(Py_None);
-  return Py_None;
-}
+            if (!PyCurses_ConvertToChtype(temp, &ch)) {
+                PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
+                return NULL;
+            }
+
+            return PyCursesCheckERR(ungetch(ch), "ungetch");
+        }
+
+        static PyObject *
+            PyCurses_Use_Env(PyObject *self, PyObject *args)
+        {
+            int flag;
+
+            switch(PyTuple_Size(args)) {
+            case 1:
+                if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&flag))
+                    return NULL;
+                break;
+            default:
+                PyErr_SetString(PyExc_TypeError, "use_env requires 1 argument");
+                return NULL;
+            }
+            use_env(flag);
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
 
 #ifndef STRICT_SYSV_CURSES
-static PyObject *
-PyCurses_Use_Default_Colors(PyObject *self)
-{
-  int code;
+        static PyObject *
+            PyCurses_Use_Default_Colors(PyObject *self)
+        {
+            int code;
 
-  PyCursesInitialised
-  PyCursesInitialisedColor
+            PyCursesInitialised
+                PyCursesInitialisedColor
 
-  code = use_default_colors();
-  if (code != ERR) {
-    Py_INCREF(Py_None);
-    return Py_None;
-  } else {
-    PyErr_SetString(PyCursesError, "use_default_colors() returned ERR");
-    return NULL;
-  }
-}
+                code = use_default_colors();
+            if (code != ERR) {
+                Py_INCREF(Py_None);
+                return Py_None;
+            } else {
+                PyErr_SetString(PyCursesError, "use_default_colors() returned ERR");
+                return NULL;
+            }
+        }
 #endif /* STRICT_SYSV_CURSES */
 
 /* List of functions defined in the module */
 
-static PyMethodDef PyCurses_methods[] = {
-  {"baudrate",            (PyCFunction)PyCurses_baudrate, METH_NOARGS},
-  {"beep",                (PyCFunction)PyCurses_beep, METH_NOARGS},
-  {"can_change_color",    (PyCFunction)PyCurses_can_change_color, METH_NOARGS},
-  {"cbreak",              (PyCFunction)PyCurses_cbreak, METH_VARARGS},
-  {"color_content",       (PyCFunction)PyCurses_Color_Content, METH_VARARGS},
-  {"color_pair",          (PyCFunction)PyCurses_color_pair, METH_VARARGS},
-  {"curs_set",            (PyCFunction)PyCurses_Curs_Set, METH_VARARGS},
-  {"def_prog_mode",       (PyCFunction)PyCurses_def_prog_mode, METH_NOARGS},
-  {"def_shell_mode",      (PyCFunction)PyCurses_def_shell_mode, METH_NOARGS},
-  {"delay_output",        (PyCFunction)PyCurses_Delay_Output, METH_VARARGS},
-  {"doupdate",            (PyCFunction)PyCurses_doupdate, METH_NOARGS},
-  {"echo",                (PyCFunction)PyCurses_echo, METH_VARARGS},
-  {"endwin",              (PyCFunction)PyCurses_endwin, METH_NOARGS},
-  {"erasechar",           (PyCFunction)PyCurses_EraseChar, METH_NOARGS},
-  {"filter",              (PyCFunction)PyCurses_filter, METH_NOARGS},
-  {"flash",               (PyCFunction)PyCurses_flash, METH_NOARGS},
-  {"flushinp",            (PyCFunction)PyCurses_flushinp, METH_NOARGS},
+        static PyMethodDef PyCurses_methods[] = {
+            {"baudrate",            (PyCFunction)PyCurses_baudrate, METH_NOARGS},
+            {"beep",                (PyCFunction)PyCurses_beep, METH_NOARGS},
+            {"can_change_color",    (PyCFunction)PyCurses_can_change_color, METH_NOARGS},
+            {"cbreak",              (PyCFunction)PyCurses_cbreak, METH_VARARGS},
+            {"color_content",       (PyCFunction)PyCurses_Color_Content, METH_VARARGS},
+            {"color_pair",          (PyCFunction)PyCurses_color_pair, METH_VARARGS},
+            {"curs_set",            (PyCFunction)PyCurses_Curs_Set, METH_VARARGS},
+            {"def_prog_mode",       (PyCFunction)PyCurses_def_prog_mode, METH_NOARGS},
+            {"def_shell_mode",      (PyCFunction)PyCurses_def_shell_mode, METH_NOARGS},
+            {"delay_output",        (PyCFunction)PyCurses_Delay_Output, METH_VARARGS},
+            {"doupdate",            (PyCFunction)PyCurses_doupdate, METH_NOARGS},
+            {"echo",                (PyCFunction)PyCurses_echo, METH_VARARGS},
+            {"endwin",              (PyCFunction)PyCurses_endwin, METH_NOARGS},
+            {"erasechar",           (PyCFunction)PyCurses_EraseChar, METH_NOARGS},
+            {"filter",              (PyCFunction)PyCurses_filter, METH_NOARGS},
+            {"flash",               (PyCFunction)PyCurses_flash, METH_NOARGS},
+            {"flushinp",            (PyCFunction)PyCurses_flushinp, METH_NOARGS},
 #ifdef NCURSES_MOUSE_VERSION
-  {"getmouse",            (PyCFunction)PyCurses_GetMouse, METH_NOARGS},
-  {"ungetmouse",          (PyCFunction)PyCurses_UngetMouse, METH_VARARGS},
+            {"getmouse",            (PyCFunction)PyCurses_GetMouse, METH_NOARGS},
+            {"ungetmouse",          (PyCFunction)PyCurses_UngetMouse, METH_VARARGS},
 #endif
-  {"getsyx",              (PyCFunction)PyCurses_getsyx, METH_NOARGS},
-  {"getwin",              (PyCFunction)PyCurses_GetWin, METH_O},
-  {"has_colors",          (PyCFunction)PyCurses_has_colors, METH_NOARGS},
-  {"has_ic",              (PyCFunction)PyCurses_has_ic, METH_NOARGS},
-  {"has_il",              (PyCFunction)PyCurses_has_il, METH_NOARGS},
+            {"getsyx",              (PyCFunction)PyCurses_getsyx, METH_NOARGS},
+            {"getwin",              (PyCFunction)PyCurses_GetWin, METH_O},
+            {"has_colors",          (PyCFunction)PyCurses_has_colors, METH_NOARGS},
+            {"has_ic",              (PyCFunction)PyCurses_has_ic, METH_NOARGS},
+            {"has_il",              (PyCFunction)PyCurses_has_il, METH_NOARGS},
 #ifndef STRICT_SYSV_CURSES
-  {"has_key",             (PyCFunction)PyCurses_has_key, METH_VARARGS},
+            {"has_key",             (PyCFunction)PyCurses_has_key, METH_VARARGS},
 #endif
-  {"halfdelay",           (PyCFunction)PyCurses_HalfDelay, METH_VARARGS},
-  {"init_color",          (PyCFunction)PyCurses_Init_Color, METH_VARARGS},
-  {"init_pair",           (PyCFunction)PyCurses_Init_Pair, METH_VARARGS},
-  {"initscr",             (PyCFunction)PyCurses_InitScr, METH_NOARGS},
-  {"intrflush",           (PyCFunction)PyCurses_IntrFlush, METH_VARARGS},
-  {"isendwin",            (PyCFunction)PyCurses_isendwin, METH_NOARGS},
+            {"halfdelay",           (PyCFunction)PyCurses_HalfDelay, METH_VARARGS},
+            {"init_color",          (PyCFunction)PyCurses_Init_Color, METH_VARARGS},
+            {"init_pair",           (PyCFunction)PyCurses_Init_Pair, METH_VARARGS},
+            {"initscr",             (PyCFunction)PyCurses_InitScr, METH_NOARGS},
+            {"intrflush",           (PyCFunction)PyCurses_IntrFlush, METH_VARARGS},
+            {"isendwin",            (PyCFunction)PyCurses_isendwin, METH_NOARGS},
 #ifdef HAVE_CURSES_IS_TERM_RESIZED
-  {"is_term_resized",     (PyCFunction)PyCurses_Is_Term_Resized, METH_VARARGS},
+            {"is_term_resized",     (PyCFunction)PyCurses_Is_Term_Resized, METH_VARARGS},
 #endif
 #if !defined(__NetBSD__)
-  {"keyname",             (PyCFunction)PyCurses_KeyName, METH_VARARGS},
+            {"keyname",             (PyCFunction)PyCurses_KeyName, METH_VARARGS},
 #endif
-  {"killchar",            (PyCFunction)PyCurses_KillChar, METH_NOARGS}, 
-  {"longname",            (PyCFunction)PyCurses_longname, METH_NOARGS}, 
-  {"meta",                (PyCFunction)PyCurses_Meta, METH_VARARGS},
+            {"killchar",            (PyCFunction)PyCurses_KillChar, METH_NOARGS},
+            {"longname",            (PyCFunction)PyCurses_longname, METH_NOARGS},
+            {"meta",                (PyCFunction)PyCurses_Meta, METH_VARARGS},
 #ifdef NCURSES_MOUSE_VERSION
-  {"mouseinterval",       (PyCFunction)PyCurses_MouseInterval, METH_VARARGS},
-  {"mousemask",           (PyCFunction)PyCurses_MouseMask, METH_VARARGS},
+            {"mouseinterval",       (PyCFunction)PyCurses_MouseInterval, METH_VARARGS},
+            {"mousemask",           (PyCFunction)PyCurses_MouseMask, METH_VARARGS},
 #endif
-  {"napms",               (PyCFunction)PyCurses_Napms, METH_VARARGS},
-  {"newpad",              (PyCFunction)PyCurses_NewPad, METH_VARARGS},
-  {"newwin",              (PyCFunction)PyCurses_NewWindow, METH_VARARGS},
-  {"nl",                  (PyCFunction)PyCurses_nl, METH_VARARGS},
-  {"nocbreak",            (PyCFunction)PyCurses_nocbreak, METH_NOARGS},
-  {"noecho",              (PyCFunction)PyCurses_noecho, METH_NOARGS},
-  {"nonl",                (PyCFunction)PyCurses_nonl, METH_NOARGS},
-  {"noqiflush",           (PyCFunction)PyCurses_noqiflush, METH_NOARGS},
-  {"noraw",               (PyCFunction)PyCurses_noraw, METH_NOARGS},
-  {"pair_content",        (PyCFunction)PyCurses_Pair_Content, METH_VARARGS},
-  {"pair_number",         (PyCFunction)PyCurses_pair_number, METH_VARARGS},
-  {"putp",                (PyCFunction)PyCurses_Putp, METH_VARARGS},
-  {"qiflush",             (PyCFunction)PyCurses_QiFlush, METH_VARARGS},
-  {"raw",                 (PyCFunction)PyCurses_raw, METH_VARARGS},
-  {"reset_prog_mode",     (PyCFunction)PyCurses_reset_prog_mode, METH_NOARGS},
-  {"reset_shell_mode",    (PyCFunction)PyCurses_reset_shell_mode, METH_NOARGS},
-  {"resetty",             (PyCFunction)PyCurses_resetty, METH_NOARGS},
+            {"napms",               (PyCFunction)PyCurses_Napms, METH_VARARGS},
+            {"newpad",              (PyCFunction)PyCurses_NewPad, METH_VARARGS},
+            {"newwin",              (PyCFunction)PyCurses_NewWindow, METH_VARARGS},
+            {"nl",                  (PyCFunction)PyCurses_nl, METH_VARARGS},
+            {"nocbreak",            (PyCFunction)PyCurses_nocbreak, METH_NOARGS},
+            {"noecho",              (PyCFunction)PyCurses_noecho, METH_NOARGS},
+            {"nonl",                (PyCFunction)PyCurses_nonl, METH_NOARGS},
+            {"noqiflush",           (PyCFunction)PyCurses_noqiflush, METH_NOARGS},
+            {"noraw",               (PyCFunction)PyCurses_noraw, METH_NOARGS},
+            {"pair_content",        (PyCFunction)PyCurses_Pair_Content, METH_VARARGS},
+            {"pair_number",         (PyCFunction)PyCurses_pair_number, METH_VARARGS},
+            {"putp",                (PyCFunction)PyCurses_Putp, METH_VARARGS},
+            {"qiflush",             (PyCFunction)PyCurses_QiFlush, METH_VARARGS},
+            {"raw",                 (PyCFunction)PyCurses_raw, METH_VARARGS},
+            {"reset_prog_mode",     (PyCFunction)PyCurses_reset_prog_mode, METH_NOARGS},
+            {"reset_shell_mode",    (PyCFunction)PyCurses_reset_shell_mode, METH_NOARGS},
+            {"resetty",             (PyCFunction)PyCurses_resetty, METH_NOARGS},
 #ifdef HAVE_CURSES_RESIZETERM
-  {"resizeterm",          (PyCFunction)PyCurses_ResizeTerm, METH_VARARGS},
+            {"resizeterm",          (PyCFunction)PyCurses_ResizeTerm, METH_VARARGS},
 #endif
 #ifdef HAVE_CURSES_RESIZE_TERM
-  {"resize_term",         (PyCFunction)PyCurses_Resize_Term, METH_VARARGS},
+            {"resize_term",         (PyCFunction)PyCurses_Resize_Term, METH_VARARGS},
 #endif
-  {"savetty",             (PyCFunction)PyCurses_savetty, METH_NOARGS},
-  {"setsyx",              (PyCFunction)PyCurses_setsyx, METH_VARARGS},
-  {"setupterm",           (PyCFunction)PyCurses_setupterm,
-   METH_VARARGS|METH_KEYWORDS},
-  {"start_color",         (PyCFunction)PyCurses_Start_Color, METH_NOARGS},
-  {"termattrs",           (PyCFunction)PyCurses_termattrs, METH_NOARGS},
-  {"termname",            (PyCFunction)PyCurses_termname, METH_NOARGS},
-  {"tigetflag",		  (PyCFunction)PyCurses_tigetflag, METH_VARARGS},
-  {"tigetnum",		  (PyCFunction)PyCurses_tigetnum, METH_VARARGS},
-  {"tigetstr",		  (PyCFunction)PyCurses_tigetstr, METH_VARARGS},
-  {"tparm",               (PyCFunction)PyCurses_tparm, METH_VARARGS},
-  {"typeahead",           (PyCFunction)PyCurses_TypeAhead, METH_VARARGS},
-  {"unctrl",              (PyCFunction)PyCurses_UnCtrl, METH_VARARGS},
-  {"ungetch",             (PyCFunction)PyCurses_UngetCh, METH_VARARGS},
-  {"use_env",             (PyCFunction)PyCurses_Use_Env, METH_VARARGS},
+            {"savetty",             (PyCFunction)PyCurses_savetty, METH_NOARGS},
+            {"setsyx",              (PyCFunction)PyCurses_setsyx, METH_VARARGS},
+            {"setupterm",           (PyCFunction)PyCurses_setupterm,
+             METH_VARARGS|METH_KEYWORDS},
+            {"start_color",         (PyCFunction)PyCurses_Start_Color, METH_NOARGS},
+            {"termattrs",           (PyCFunction)PyCurses_termattrs, METH_NOARGS},
+            {"termname",            (PyCFunction)PyCurses_termname, METH_NOARGS},
+            {"tigetflag",           (PyCFunction)PyCurses_tigetflag, METH_VARARGS},
+            {"tigetnum",            (PyCFunction)PyCurses_tigetnum, METH_VARARGS},
+            {"tigetstr",            (PyCFunction)PyCurses_tigetstr, METH_VARARGS},
+            {"tparm",               (PyCFunction)PyCurses_tparm, METH_VARARGS},
+            {"typeahead",           (PyCFunction)PyCurses_TypeAhead, METH_VARARGS},
+            {"unctrl",              (PyCFunction)PyCurses_UnCtrl, METH_VARARGS},
+            {"ungetch",             (PyCFunction)PyCurses_UngetCh, METH_VARARGS},
+            {"use_env",             (PyCFunction)PyCurses_Use_Env, METH_VARARGS},
 #ifndef STRICT_SYSV_CURSES
-  {"use_default_colors",  (PyCFunction)PyCurses_Use_Default_Colors, METH_NOARGS},
+            {"use_default_colors",  (PyCFunction)PyCurses_Use_Default_Colors, METH_NOARGS},
 #endif
-  {NULL,		  NULL}		/* sentinel */
-};
+            {NULL,                  NULL}         /* sentinel */
+        };
 
 /* Initialization function for the module */
 
 
-static struct PyModuleDef _cursesmodule = {
-	PyModuleDef_HEAD_INIT,
-	"_curses",
-	NULL,
-	-1,
-	PyCurses_methods,
-	NULL,
-	NULL,
-	NULL,
-	NULL
-};
+        static struct PyModuleDef _cursesmodule = {
+            PyModuleDef_HEAD_INIT,
+            "_curses",
+            NULL,
+            -1,
+            PyCurses_methods,
+            NULL,
+            NULL,
+            NULL,
+            NULL
+        };
 
-PyMODINIT_FUNC
-PyInit__curses(void)
-{
-	PyObject *m, *d, *v, *c_api_object;
-	static void *PyCurses_API[PyCurses_API_pointers];
+        PyMODINIT_FUNC
+            PyInit__curses(void)
+        {
+            PyObject *m, *d, *v, *c_api_object;
+            static void *PyCurses_API[PyCurses_API_pointers];
 
-	/* Initialize object type */
-	if (PyType_Ready(&PyCursesWindow_Type) < 0)
-		return NULL;
+            /* Initialize object type */
+            if (PyType_Ready(&PyCursesWindow_Type) < 0)
+                return NULL;
 
-	/* Initialize the C API pointer array */
-	PyCurses_API[0] = (void *)&PyCursesWindow_Type;
-	PyCurses_API[1] = (void *)func_PyCursesSetupTermCalled;
-	PyCurses_API[2] = (void *)func_PyCursesInitialised;
-	PyCurses_API[3] = (void *)func_PyCursesInitialisedColor;
+            /* Initialize the C API pointer array */
+            PyCurses_API[0] = (void *)&PyCursesWindow_Type;
+            PyCurses_API[1] = (void *)func_PyCursesSetupTermCalled;
+            PyCurses_API[2] = (void *)func_PyCursesInitialised;
+            PyCurses_API[3] = (void *)func_PyCursesInitialisedColor;
 
-	/* Create the module and add the functions */
-	m = PyModule_Create(&_cursesmodule);
-	if (m == NULL)
-    		return NULL;
+            /* Create the module and add the functions */
+            m = PyModule_Create(&_cursesmodule);
+            if (m == NULL)
+                return NULL;
 
-	/* Add some symbolic constants to the module */
-	d = PyModule_GetDict(m);
-	if (d == NULL)
-		return NULL;
-	ModDict = d; /* For PyCurses_InitScr to use later */
+            /* Add some symbolic constants to the module */
+            d = PyModule_GetDict(m);
+            if (d == NULL)
+                return NULL;
+            ModDict = d; /* For PyCurses_InitScr to use later */
 
-	/* Add a capsule for the C API */
-	c_api_object = PyCapsule_New(PyCurses_API, PyCurses_CAPSULE_NAME, NULL);
-	PyDict_SetItemString(d, "_C_API", c_api_object);
-	Py_DECREF(c_api_object);
+            /* Add a capsule for the C API */
+            c_api_object = PyCapsule_New(PyCurses_API, PyCurses_CAPSULE_NAME, NULL);
+            PyDict_SetItemString(d, "_C_API", c_api_object);
+            Py_DECREF(c_api_object);
 
-	/* For exception curses.error */
-	PyCursesError = PyErr_NewException("_curses.error", NULL, NULL);
-	PyDict_SetItemString(d, "error", PyCursesError);
+            /* For exception curses.error */
+            PyCursesError = PyErr_NewException("_curses.error", NULL, NULL);
+            PyDict_SetItemString(d, "error", PyCursesError);
 
-	/* Make the version available */
-	v = PyBytes_FromString(PyCursesVersion);
-	PyDict_SetItemString(d, "version", v);
-	PyDict_SetItemString(d, "__version__", v);
-	Py_DECREF(v);
+            /* Make the version available */
+            v = PyBytes_FromString(PyCursesVersion);
+            PyDict_SetItemString(d, "version", v);
+            PyDict_SetItemString(d, "__version__", v);
+            Py_DECREF(v);
 
-        SetDictInt("ERR", ERR);
-        SetDictInt("OK", OK);
+            SetDictInt("ERR", ERR);
+            SetDictInt("OK", OK);
 
-	/* Here are some attributes you can add to chars to print */
-	
-	SetDictInt("A_ATTRIBUTES",      A_ATTRIBUTES);
-	SetDictInt("A_NORMAL",		A_NORMAL);
-	SetDictInt("A_STANDOUT",	A_STANDOUT);
-	SetDictInt("A_UNDERLINE",	A_UNDERLINE);
-	SetDictInt("A_REVERSE",		A_REVERSE);
-	SetDictInt("A_BLINK",		A_BLINK);
-	SetDictInt("A_DIM",		A_DIM);
-	SetDictInt("A_BOLD",		A_BOLD);
-	SetDictInt("A_ALTCHARSET",	A_ALTCHARSET);
+            /* Here are some attributes you can add to chars to print */
+
+            SetDictInt("A_ATTRIBUTES",      A_ATTRIBUTES);
+            SetDictInt("A_NORMAL",              A_NORMAL);
+            SetDictInt("A_STANDOUT",            A_STANDOUT);
+            SetDictInt("A_UNDERLINE",           A_UNDERLINE);
+            SetDictInt("A_REVERSE",             A_REVERSE);
+            SetDictInt("A_BLINK",               A_BLINK);
+            SetDictInt("A_DIM",                 A_DIM);
+            SetDictInt("A_BOLD",                A_BOLD);
+            SetDictInt("A_ALTCHARSET",          A_ALTCHARSET);
 #if !defined(__NetBSD__)
-	SetDictInt("A_INVIS",           A_INVIS);
+            SetDictInt("A_INVIS",           A_INVIS);
 #endif
-	SetDictInt("A_PROTECT",         A_PROTECT);
-	SetDictInt("A_CHARTEXT",        A_CHARTEXT);
-	SetDictInt("A_COLOR",           A_COLOR);
+            SetDictInt("A_PROTECT",         A_PROTECT);
+            SetDictInt("A_CHARTEXT",        A_CHARTEXT);
+            SetDictInt("A_COLOR",           A_COLOR);
 
-	/* The following are never available with strict SYSV curses */
+            /* The following are never available with strict SYSV curses */
 #ifdef A_HORIZONTAL
-	SetDictInt("A_HORIZONTAL",      A_HORIZONTAL);
+            SetDictInt("A_HORIZONTAL",      A_HORIZONTAL);
 #endif
 #ifdef A_LEFT
-	SetDictInt("A_LEFT",            A_LEFT);
+            SetDictInt("A_LEFT",            A_LEFT);
 #endif
 #ifdef A_LOW
-	SetDictInt("A_LOW",             A_LOW);
+            SetDictInt("A_LOW",             A_LOW);
 #endif
 #ifdef A_RIGHT
-	SetDictInt("A_RIGHT",           A_RIGHT);
+            SetDictInt("A_RIGHT",           A_RIGHT);
 #endif
 #ifdef A_TOP
-	SetDictInt("A_TOP",             A_TOP);
+            SetDictInt("A_TOP",             A_TOP);
 #endif
 #ifdef A_VERTICAL
-	SetDictInt("A_VERTICAL",        A_VERTICAL);
+            SetDictInt("A_VERTICAL",        A_VERTICAL);
 #endif
 
-	SetDictInt("COLOR_BLACK",       COLOR_BLACK);
-	SetDictInt("COLOR_RED",         COLOR_RED);
-	SetDictInt("COLOR_GREEN",       COLOR_GREEN);
-	SetDictInt("COLOR_YELLOW",      COLOR_YELLOW);
-	SetDictInt("COLOR_BLUE",        COLOR_BLUE);
-	SetDictInt("COLOR_MAGENTA",     COLOR_MAGENTA);
-	SetDictInt("COLOR_CYAN",        COLOR_CYAN);
-	SetDictInt("COLOR_WHITE",       COLOR_WHITE);
+            SetDictInt("COLOR_BLACK",       COLOR_BLACK);
+            SetDictInt("COLOR_RED",         COLOR_RED);
+            SetDictInt("COLOR_GREEN",       COLOR_GREEN);
+            SetDictInt("COLOR_YELLOW",      COLOR_YELLOW);
+            SetDictInt("COLOR_BLUE",        COLOR_BLUE);
+            SetDictInt("COLOR_MAGENTA",     COLOR_MAGENTA);
+            SetDictInt("COLOR_CYAN",        COLOR_CYAN);
+            SetDictInt("COLOR_WHITE",       COLOR_WHITE);
 
 #ifdef NCURSES_MOUSE_VERSION
-	/* Mouse-related constants */
-	SetDictInt("BUTTON1_PRESSED",          BUTTON1_PRESSED);
-	SetDictInt("BUTTON1_RELEASED",         BUTTON1_RELEASED);
-	SetDictInt("BUTTON1_CLICKED",          BUTTON1_CLICKED);
-	SetDictInt("BUTTON1_DOUBLE_CLICKED",   BUTTON1_DOUBLE_CLICKED);
-	SetDictInt("BUTTON1_TRIPLE_CLICKED",   BUTTON1_TRIPLE_CLICKED);
+            /* Mouse-related constants */
+            SetDictInt("BUTTON1_PRESSED",          BUTTON1_PRESSED);
+            SetDictInt("BUTTON1_RELEASED",         BUTTON1_RELEASED);
+            SetDictInt("BUTTON1_CLICKED",          BUTTON1_CLICKED);
+            SetDictInt("BUTTON1_DOUBLE_CLICKED",   BUTTON1_DOUBLE_CLICKED);
+            SetDictInt("BUTTON1_TRIPLE_CLICKED",   BUTTON1_TRIPLE_CLICKED);
 
-	SetDictInt("BUTTON2_PRESSED",          BUTTON2_PRESSED);
-	SetDictInt("BUTTON2_RELEASED",         BUTTON2_RELEASED);
-	SetDictInt("BUTTON2_CLICKED",          BUTTON2_CLICKED);
-	SetDictInt("BUTTON2_DOUBLE_CLICKED",   BUTTON2_DOUBLE_CLICKED);
-	SetDictInt("BUTTON2_TRIPLE_CLICKED",   BUTTON2_TRIPLE_CLICKED);
+            SetDictInt("BUTTON2_PRESSED",          BUTTON2_PRESSED);
+            SetDictInt("BUTTON2_RELEASED",         BUTTON2_RELEASED);
+            SetDictInt("BUTTON2_CLICKED",          BUTTON2_CLICKED);
+            SetDictInt("BUTTON2_DOUBLE_CLICKED",   BUTTON2_DOUBLE_CLICKED);
+            SetDictInt("BUTTON2_TRIPLE_CLICKED",   BUTTON2_TRIPLE_CLICKED);
 
-	SetDictInt("BUTTON3_PRESSED",          BUTTON3_PRESSED);
-	SetDictInt("BUTTON3_RELEASED",         BUTTON3_RELEASED);
-	SetDictInt("BUTTON3_CLICKED",          BUTTON3_CLICKED);
-	SetDictInt("BUTTON3_DOUBLE_CLICKED",   BUTTON3_DOUBLE_CLICKED);
-	SetDictInt("BUTTON3_TRIPLE_CLICKED",   BUTTON3_TRIPLE_CLICKED);
+            SetDictInt("BUTTON3_PRESSED",          BUTTON3_PRESSED);
+            SetDictInt("BUTTON3_RELEASED",         BUTTON3_RELEASED);
+            SetDictInt("BUTTON3_CLICKED",          BUTTON3_CLICKED);
+            SetDictInt("BUTTON3_DOUBLE_CLICKED",   BUTTON3_DOUBLE_CLICKED);
+            SetDictInt("BUTTON3_TRIPLE_CLICKED",   BUTTON3_TRIPLE_CLICKED);
 
-	SetDictInt("BUTTON4_PRESSED",          BUTTON4_PRESSED);
-	SetDictInt("BUTTON4_RELEASED",         BUTTON4_RELEASED);
-	SetDictInt("BUTTON4_CLICKED",          BUTTON4_CLICKED);
-	SetDictInt("BUTTON4_DOUBLE_CLICKED",   BUTTON4_DOUBLE_CLICKED);
-	SetDictInt("BUTTON4_TRIPLE_CLICKED",   BUTTON4_TRIPLE_CLICKED);
+            SetDictInt("BUTTON4_PRESSED",          BUTTON4_PRESSED);
+            SetDictInt("BUTTON4_RELEASED",         BUTTON4_RELEASED);
+            SetDictInt("BUTTON4_CLICKED",          BUTTON4_CLICKED);
+            SetDictInt("BUTTON4_DOUBLE_CLICKED",   BUTTON4_DOUBLE_CLICKED);
+            SetDictInt("BUTTON4_TRIPLE_CLICKED",   BUTTON4_TRIPLE_CLICKED);
 
-	SetDictInt("BUTTON_SHIFT",             BUTTON_SHIFT);
-	SetDictInt("BUTTON_CTRL",              BUTTON_CTRL);
-	SetDictInt("BUTTON_ALT",               BUTTON_ALT);
+            SetDictInt("BUTTON_SHIFT",             BUTTON_SHIFT);
+            SetDictInt("BUTTON_CTRL",              BUTTON_CTRL);
+            SetDictInt("BUTTON_ALT",               BUTTON_ALT);
 
-	SetDictInt("ALL_MOUSE_EVENTS",         ALL_MOUSE_EVENTS);
-	SetDictInt("REPORT_MOUSE_POSITION",    REPORT_MOUSE_POSITION);
+            SetDictInt("ALL_MOUSE_EVENTS",         ALL_MOUSE_EVENTS);
+            SetDictInt("REPORT_MOUSE_POSITION",    REPORT_MOUSE_POSITION);
 #endif
-	/* Now set everything up for KEY_ variables */
-	{
-	  int key;
-	  char *key_n;
-	  char *key_n2;
+            /* Now set everything up for KEY_ variables */
+            {
+                int key;
+                char *key_n;
+                char *key_n2;
 #if !defined(__NetBSD__)
-	  for (key=KEY_MIN;key < KEY_MAX; key++) {
-	    key_n = (char *)keyname(key);
-	    if (key_n == NULL || strcmp(key_n,"UNKNOWN KEY")==0)
-	      continue;
-	    if (strncmp(key_n,"KEY_F(",6)==0) {
-	      char *p1, *p2;
-	      key_n2 = malloc(strlen(key_n)+1);
-	      if (!key_n2) {
-		PyErr_NoMemory();
-		break;
-              }
-	      p1 = key_n;
-	      p2 = key_n2;
-	      while (*p1) {
-		if (*p1 != '(' && *p1 != ')') {
-		  *p2 = *p1;
-		  p2++;
-		}
-		p1++;
-	      }
-	      *p2 = (char)0;
-	    } else
-	      key_n2 = key_n;
-	    SetDictInt(key_n2,key);
-	    if (key_n2 != key_n)
-	      free(key_n2);
-	  }
+                for (key=KEY_MIN;key < KEY_MAX; key++) {
+                    key_n = (char *)keyname(key);
+                    if (key_n == NULL || strcmp(key_n,"UNKNOWN KEY")==0)
+                        continue;
+                    if (strncmp(key_n,"KEY_F(",6)==0) {
+                        char *p1, *p2;
+                        key_n2 = malloc(strlen(key_n)+1);
+                        if (!key_n2) {
+                            PyErr_NoMemory();
+                            break;
+                        }
+                        p1 = key_n;
+                        p2 = key_n2;
+                        while (*p1) {
+                            if (*p1 != '(' && *p1 != ')') {
+                                *p2 = *p1;
+                                p2++;
+                            }
+                            p1++;
+                        }
+                        *p2 = (char)0;
+                    } else
+                        key_n2 = key_n;
+                    SetDictInt(key_n2,key);
+                    if (key_n2 != key_n)
+                        free(key_n2);
+                }
 #endif
-	  SetDictInt("KEY_MIN", KEY_MIN);
-	  SetDictInt("KEY_MAX", KEY_MAX);
-	}
-	return m;
-}
+                SetDictInt("KEY_MIN", KEY_MIN);
+                SetDictInt("KEY_MAX", KEY_MAX);
+            }
+            return m;
+        }