Use newtypes in Gtk.Widgets to support new overlapping instance detection algorithm in the compiler; add GtkEntry and instance tune w (GtkExpand,GtkExpand) | gtkWidget w

4 files changed, 333 insertions, 250 deletions

diff --git a/src/Gtk/Internal.dcl b/src/Gtk/Internal.dcl
index 7a565e8..c038fee 100644
--- a/src/Gtk/Internal.dcl
+++ b/src/Gtk/Internal.dcl
@@ -41,6 +41,10 @@ gtk_dialog_run :: !Pointer !.a -> (!Int, !.a)
 gtk_dialog_set_default_response :: !Pointer !Int !.a -> .a
 gtk_dialog_set_modal :: !Pointer !Bool !.a -> .a
 
+gtk_entry_get_text :: !Pointer !.a -> (!String, !.a)
+gtk_entry_new :: !.a -> (!Pointer, !.a)
+gtk_entry_set_text :: !Pointer !String !.a -> .a
+
 gtk_events_pending :: !.a -> (!Bool, !.a)
 
 gtk_file_chooser_add_filter :: !Pointer !Pointer !.a -> .a
@@ -141,6 +145,7 @@ gtk_widget_get_screen :: !Pointer !.a -> (!Pointer, !.a)
 gtk_widget_get_style_context :: !Pointer !.a -> (!Pointer, !.a)
 gtk_widget_hide :: !Pointer !.a -> .a
 gtk_widget_set_halign :: !Pointer !Int !.a -> .a
+gtk_widget_set_hexpand :: !Pointer !Bool !.a -> .a
 gtk_widget_set_margin_bottom :: !Pointer !Int !.a -> .a
 gtk_widget_set_margin_left :: !Pointer !Int !.a -> .a
 gtk_widget_set_margin_right :: !Pointer !Int !.a -> .a
@@ -148,6 +153,7 @@ gtk_widget_set_margin_top :: !Pointer !Int !.a -> .a
 gtk_widget_set_sensitive :: !Pointer !Bool !.a -> .a
 gtk_widget_set_size_request :: !Pointer !Int !Int !.a -> .a
 gtk_widget_set_valign :: !Pointer !Int !.a -> .a
+gtk_widget_set_vexpand :: !Pointer !Bool !.a -> .a
 gtk_widget_show :: !Pointer !.a -> .a
 
 gtk_window_new :: !Bool !.a -> (!Pointer, !.a)
diff --git a/src/Gtk/Internal.icl b/src/Gtk/Internal.icl
index 976e6c3..380e73f 100644
--- a/src/Gtk/Internal.icl
+++ b/src/Gtk/Internal.icl
@@ -144,6 +144,29 @@ gtk_dialog_set_modal dialog setting env = code {
 	ccall gtk_dialog_set_modal "pI:V:A"
 }
 
+gtk_entry_get_text :: !Pointer !.a -> (!String, !.a)
+gtk_entry_get_text entry env
+	# (ptr,env) = get entry env
+	= (derefString ptr, env)
+where
+	get :: !Pointer !.a -> (!Pointer, !.a)
+	get _ _ = code {
+		ccall gtk_entry_get_text "p:p:A"
+	}
+
+gtk_entry_new :: !.a -> (!Pointer, !.a)
+gtk_entry_new env = code {
+	ccall gtk_entry_new ":p:A"
+}
+
+gtk_entry_set_text :: !Pointer !String !.a -> .a
+gtk_entry_set_text entry text env = set entry (packString text) env
+where
+	set :: !Pointer !String !.a -> .a
+	set _ _ _ = code {
+		ccall gtk_entry_set_text "ps:V:A"
+	}
+
 gtk_events_pending :: !.a -> (!Bool, !.a)
 gtk_events_pending _ = code {
 	ccall gtk_events_pending ":I:A"
@@ -665,6 +688,11 @@ gtk_widget_set_halign widget align env = code {
 	ccall gtk_widget_set_halign "pI:V:A"
 }
 
+gtk_widget_set_hexpand :: !Pointer !Bool !.a -> .a
+gtk_widget_set_hexpand widget align env = code {
+	ccall gtk_widget_set_hexpand "pI:V:A"
+}
+
 gtk_widget_set_margin_bottom :: !Pointer !Int !.a -> .a
 gtk_widget_set_margin_bottom widget padding env = code {
 	ccall gtk_widget_set_margin_bottom "pI:V:A"
@@ -700,6 +728,11 @@ gtk_widget_set_valign widget align env = code {
 	ccall gtk_widget_set_valign "pI:V:A"
 }
 
+gtk_widget_set_vexpand :: !Pointer !Bool !.a -> .a
+gtk_widget_set_vexpand widget align env = code {
+	ccall gtk_widget_set_vexpand "pI:V:A"
+}
+
 gtk_widget_show :: !Pointer !.a -> .a
 gtk_widget_show widget env = code {
 	ccall gtk_widget_show "p:V:A"
diff --git a/src/Gtk/Widgets.dcl b/src/Gtk/Widgets.dcl
index 10de329..233160c 100644
--- a/src/Gtk/Widgets.dcl
+++ b/src/Gtk/Widgets.dcl
@@ -20,13 +20,13 @@ where
 	toPtr   :: !a -> Pointer
 	fromPtr :: !Pointer -> a
 
-:: GtkActionBar
+:: GtkActionBar =: GtkActionBar Pointer
 instance gtkWidget GtkActionBar
 
 newActionBar :: GtkM GtkActionBar
 packActionBar :: !GtkActionBar !GtkDirection !w -> GtkM w | gtkWidget w
 
-:: GtkBox
+:: GtkBox =: GtkBox Pointer
 instance gtkWidget GtkBox
 instance gtkContainer GtkBox
 instance gtkOrientable GtkBox
@@ -36,13 +36,13 @@ packBox :: !GtkBox !GtkDirection !GtkExpand !w -> GtkM w | gtkWidget w
 
 instance tune GtkBox GtkSpacing
 
-:: GtkButton
+:: GtkButton =: GtkButton Pointer
 instance gtkWidget GtkButton
 instance ptr GtkButton
 
 newButtonFromIconName :: !String -> GtkM GtkButton
 
-:: GtkContainer
+:: GtkContainer =: GtkContainer Pointer
 
 class gtkContainer a :: !a -> GtkContainer
 
@@ -52,7 +52,7 @@ instance ptr GtkContainer
 
 addToContainer :: !c !w -> GtkM w | gtkWidget w & gtkContainer c
 
-:: GtkDialog
+:: GtkDialog =: GtkDialog Pointer
 
 class gtkDialog a :: !a -> GtkDialog
 
@@ -72,7 +72,15 @@ getContentArea :: !d -> GtkBox | gtkDialog d
 newMessageDialog :: !GtkWindow !GtkMessageType !GtkButtonsType !String -> GtkM GtkDialog
 getFileWithDialog :: !GtkWindow !GtkFileChooserAction !(Maybe String) -> GtkM (Maybe FilePath)
 
-:: GtkFrame
+:: GtkEntry =: GtkEntry Pointer
+instance gtkWidget GtkEntry
+
+newEntry :: GtkM GtkEntry
+getText :: !GtkEntry -> GtkM String
+
+instance tune GtkEntry GtkText
+
+:: GtkFrame =: GtkFrame Pointer
 instance gtkWidget GtkFrame
 instance gtkContainer GtkFrame
 instance ptr GtkFrame
@@ -80,36 +88,36 @@ instance ptr GtkFrame
 newFrame :: !GtkTitle !w -> GtkM GtkFrame | gtkWidget w
 framed :: !GtkTitle !(GtkM w) -> GtkM (w, GtkFrame) | gtkWidget w
 
-:: GtkGrid
+:: GtkGrid =: GtkGrid Pointer
 instance gtkWidget GtkGrid
 
 newGrid :: GtkM GtkGrid
 attachGrid :: !GtkGrid !(!Int,!Int) !(!Int,!Int) !w -> GtkM w | gtkWidget w
 
-:: GtkLabel
+:: GtkLabel =: GtkLabel Pointer
 instance gtkWidget GtkLabel
 
 newLabel :: GtkM GtkLabel
 instance tune GtkLabel GtkText
 
-:: GtkListStore
+:: GtkListStore =: GtkListStore Pointer
 
 newListStore :: ![GType] -> GtkM GtkListStore
 clearListStore :: !GtkListStore -> GtkM GtkListStore
 appendToListStore :: ![GValue] !GtkListStore -> GtkM GtkListStore
 swapItems :: !Int !Int !GtkListStore -> GtkM Bool
 
-:: GtkMenu
+:: GtkMenu =: GtkMenu Pointer
 instance gtkWidget GtkMenu
 
 newMenu :: GtkM GtkMenu
 
-:: GtkMenuBar
+:: GtkMenuBar =: GtkMenuBar Pointer
 instance gtkWidget GtkMenuBar
 
 newMenuBar :: GtkM GtkMenuBar
 
-:: GtkMenuItem
+:: GtkMenuItem =: GtkMenuItem Pointer
 
 class gtkMenuItem a :: !a -> GtkMenuItem
 
@@ -119,7 +127,7 @@ instance gtkMenuItem GtkMenuItem
 newMenuItem :: !String -> GtkM GtkMenuItem
 setSubMenu :: !mi !GtkMenu -> GtkM GtkMenu | gtkMenuItem mi
 
-:: GtkCheckMenuItem
+:: GtkCheckMenuItem =: GtkCheckMenuItem Pointer
 instance gtkWidget GtkCheckMenuItem
 instance gtkMenuItem GtkCheckMenuItem
 instance ptr GtkCheckMenuItem
@@ -128,7 +136,7 @@ newCheckMenuItem :: !String -> GtkM GtkCheckMenuItem
 isActive :: !GtkCheckMenuItem -> GtkM Bool
 setActive :: !Bool !GtkCheckMenuItem -> GtkM GtkCheckMenuItem
 
-:: GtkMenuShell
+:: GtkMenuShell =: GtkMenuShell Pointer
 instance gtkWidget GtkMenuShell
 
 class gtkMenuShell a :: !a -> GtkMenuShell
@@ -136,13 +144,13 @@ instance gtkMenuShell GtkMenu, GtkMenuBar, GtkMenuShell
 
 appendToMenuShell :: !s !mi -> GtkM mi | gtkMenuShell s & gtkMenuItem mi
 
-:: GtkOrientable
+:: GtkOrientable =: GtkOrientable Pointer
 
 class gtkOrientable a :: !a -> GtkOrientable
 
 instance tune o GtkOrientation | gtkOrientable o
 
-:: GtkPaned
+:: GtkPaned =: GtkPaned Pointer
 instance gtkWidget GtkPaned
 instance gtkContainer GtkPaned
 
@@ -150,7 +158,7 @@ newPaned :: !GtkOrientation !GtkPanedHandleWidth -> GtkM GtkPaned
 packPane1 :: !GtkPaned !GtkResize !GtkShrink !w -> GtkM w | gtkWidget w
 packPane2 :: !GtkPaned !GtkResize !GtkShrink !w -> GtkM w | gtkWidget w
 
-:: GtkScrolledWindow
+:: GtkScrolledWindow =: GtkScrolledWindow Pointer
 instance gtkWidget GtkScrolledWindow
 instance gtkContainer GtkScrolledWindow
 
@@ -158,13 +166,13 @@ newScrolledWindow :: GtkM GtkScrolledWindow
 
 instance tune GtkScrolledWindow (GtkScrollbarPolicy, GtkScrollbarPolicy)
 
-:: GtkSeparator
+:: GtkSeparator =: GtkSeparator Pointer
 instance gtkWidget GtkSeparator
 instance ptr GtkSeparator
 
 newSeparator :: !GtkOrientation -> GtkM GtkSeparator
 
-:: GtkSpinner
+:: GtkSpinner =: GtkSpinner Pointer
 instance gtkWidget GtkSpinner
 instance ptr GtkSpinner
 
@@ -172,14 +180,14 @@ newSpinner :: GtkM GtkSpinner
 startSpinner :: !GtkSpinner -> GtkM GtkSpinner
 stopSpinner :: !GtkSpinner -> GtkM GtkSpinner
 
-:: GtkTextBuffer
+:: GtkTextBuffer =: GtkTextBuffer Pointer
 instance ptr GtkTextBuffer
 
 setText :: !String !GtkTextBuffer -> GtkM GtkTextBuffer
 setMarkup :: !String !GtkTextBuffer -> GtkM GtkTextBuffer
 insertAtCursor :: !String !GtkTextBuffer -> GtkM GtkTextBuffer
 
-:: GtkTextView
+:: GtkTextView =: GtkTextView Pointer
 instance gtkWidget GtkTextView
 instance gtkContainer GtkTextView
 instance ptr GtkTextView
@@ -189,7 +197,7 @@ getTextBuffer :: !GtkTextView -> GtkTextBuffer
 
 instance tune GtkTextView GtkWrapMode
 
-:: GtkTreeView
+:: GtkTreeView =: GtkTreeView Pointer
 instance gtkWidget GtkTreeView
 
 newTreeView :: !GtkListStore -> GtkM GtkTreeView
@@ -199,7 +207,7 @@ addSelectionChangedHandler :: !(GtkM ()) !GtkTreeView -> GtkM GtkTreeView
 getPathToSelection :: !GtkTreeView -> GtkM (Maybe [Int])
 selectPath :: ![Int] !GtkTreeView -> GtkM Bool
 
-:: GtkWidget
+:: GtkWidget =: GtkWidget Pointer
 
 class gtkWidget a :: !a -> GtkWidget
 
@@ -216,8 +224,9 @@ setMargins :: !GtkMargins !w -> GtkM w | gtkWidget w
 
 instance tune w GtkSensitivity | gtkWidget w
 instance tune w (GtkAlign,GtkAlign) | gtkWidget w
+instance tune w (GtkExpand,GtkExpand) | gtkWidget w
 
-:: GtkWindow
+:: GtkWindow =: GtkWindow Pointer
 
 class gtkWindow a :: !a -> GtkWindow
 
diff --git a/src/Gtk/Widgets.icl b/src/Gtk/Widgets.icl
index c63eabf..47dd3fb 100644
--- a/src/Gtk/Widgets.icl
+++ b/src/Gtk/Widgets.icl
@@ -14,112 +14,118 @@ import qualified Text
 import Gtk
 import Gtk.Internal
 
-:: GtkActionBar :== Pointer
-
-instance gtkWidget GtkActionBar where gtkWidget ab = ab
+instance gtkWidget GtkActionBar where gtkWidget (GtkActionBar ab) = GtkWidget ab
 
 newActionBar :: GtkM GtkActionBar
-newActionBar = toStateR gtk_action_bar_new >>= show
+newActionBar =
+	toStateR gtk_action_bar_new >>= \ab ->
+	show (GtkActionBar ab)
 
 packActionBar :: !GtkActionBar !GtkDirection !w -> GtkM w | gtkWidget w
-packActionBar bar dir widget =
+packActionBar (GtkActionBar b) dir widget =
+	let (GtkWidget w) = gtkWidget widget in
 	toState
 		(if dir=:StartToEnd gtk_action_bar_pack_start gtk_action_bar_pack_end
-			bar
-			(gtkWidget widget)) >>|
+			b
+			w) >>|
 	pure widget
 
-:: GtkBox :== Pointer
-
-instance gtkWidget GtkBox where gtkWidget b = b
-instance gtkContainer GtkBox where gtkContainer b = b
-instance gtkOrientable GtkBox where gtkOrientable b = b
+instance gtkWidget GtkBox where gtkWidget (GtkBox b) = GtkWidget b
+instance gtkContainer GtkBox where gtkContainer (GtkBox b) = GtkContainer b
+instance gtkOrientable GtkBox where gtkOrientable (GtkBox b) = GtkOrientable b
 
 newBox :: !GtkOrientation !Int -> GtkM GtkBox
 newBox orientation spacing =
-	toStateR (gtk_box_new orientation=:Vertical spacing) >>=
-	show
+	toStateR (gtk_box_new orientation=:Vertical spacing) >>= \b ->
+	show (GtkBox b)
 
 packBox :: !GtkBox !GtkDirection !GtkExpand !w -> GtkM w | gtkWidget w
-packBox box direction expand widget =
+packBox (GtkBox box) direction expand widget =
+	let (GtkWidget widget_ptr) = gtkWidget widget in
 	toState (if direction=:StartToEnd gtk_box_pack_start gtk_box_pack_end
-		box (gtkWidget widget) expand=:Expand True 0) >>|
+		box widget_ptr expand=:Expand True 0) >>|
 	pure widget
 
 instance tune GtkBox GtkSpacing
 where
-	tune (Spacing s) box = toState (gtk_box_set_spacing box s) >>| pure box
-
-:: GtkButton :== Pointer
+	tune (Spacing s) box=:(GtkBox b) =
+		toState (gtk_box_set_spacing b s) >>|
+		pure box
 
-instance gtkWidget GtkButton where gtkWidget b = b
+instance gtkWidget GtkButton where gtkWidget (GtkButton b) = GtkWidget b
 instance ptr GtkButton
 where
-	toPtr   b = b
-	fromPtr b = b
+	toPtr (GtkButton b) = b
+	fromPtr b = GtkButton b
 
 newButtonFromIconName :: !String -> GtkM GtkButton
 newButtonFromIconName icon =
-	toStateR (gtk_button_new_from_icon_name icon (toInt ButtonIconSize)) >>=
-	show
+	toStateR (gtk_button_new_from_icon_name icon (toInt ButtonIconSize)) >>= \b ->
+	show (GtkButton b)
 
-:: GtkContainer :== Pointer
-
-instance gtkWidget GtkContainer where gtkWidget c = c
+instance gtkWidget GtkContainer where gtkWidget (GtkContainer c) = GtkWidget c
 instance gtkContainer GtkContainer where gtkContainer c = c
 
 instance ptr GtkContainer
 where
-	toPtr   c = c
-	fromPtr c = c
+	toPtr (GtkContainer c) = c
+	fromPtr c = GtkContainer c
 
 addToContainer :: !c !w -> GtkM w | gtkWidget w & gtkContainer c
 addToContainer container widget =
-	toState (gtk_container_add (gtkContainer container) (gtkWidget widget)) >>|
+	let
+		(GtkContainer c) = gtkContainer container
+		(GtkWidget w) = gtkWidget widget
+	in
+	toState (gtk_container_add c w) >>|
 	pure widget
 
-:: GtkDialog :== Pointer
-
-instance gtkWidget GtkDialog where gtkWidget d = d
-instance gtkContainer GtkDialog where gtkContainer d = d
-instance gtkWindow GtkDialog where gtkWindow w = w
+instance gtkWidget GtkDialog where gtkWidget (GtkDialog d) = GtkWidget d
+instance gtkContainer GtkDialog where gtkContainer (GtkDialog d) = GtkContainer d
+instance gtkWindow GtkDialog where gtkWindow (GtkDialog d) = GtkWindow d
 instance gtkDialog GtkDialog where gtkDialog d = d
 
 instance ptr GtkDialog
 where
-	toPtr   d = d
-	fromPtr d = d
+	toPtr (GtkDialog d) = d
+	fromPtr d = GtkDialog d
 
 instance tune d GtkModal | gtkDialog d
 where
 	tune setting dialog =
-		toState (gtk_dialog_set_modal (gtkDialog dialog) setting=:Modal) >>|
+		let (GtkDialog d) = gtkDialog dialog in
+		toState (gtk_dialog_set_modal d setting=:Modal) >>|
 		pure dialog
 
 newDialog :: !GtkWindow -> GtkM GtkDialog
-newDialog window =
+newDialog (GtkWindow w) =
 	toStateR gtk_dialog_new >>= \dialog ->
-	toState (gtk_window_set_transient_for dialog window) >>|
-	pure dialog
+	toState (gtk_window_set_transient_for dialog w) >>|
+	pure (GtkDialog dialog)
 
 runDialog :: !d -> GtkM GtkResponse | gtkDialog d
-runDialog dialog = fromInt <$> toStateR (gtk_dialog_run (gtkDialog dialog))
+runDialog dialog =
+	let (GtkDialog d) = gtkDialog dialog in
+	fromInt <$> toStateR (gtk_dialog_run d)
 
 getContentArea :: !d -> GtkBox | gtkDialog d
-getContentArea dialog = gtk_dialog_get_content_area (gtkDialog dialog)
+getContentArea dialog =
+	let (GtkDialog d) = gtkDialog dialog in
+	GtkBox (gtk_dialog_get_content_area d)
 
 newMessageDialog :: !GtkWindow !GtkMessageType !GtkButtonsType !String -> GtkM GtkDialog
-newMessageDialog window type buttons text =
+newMessageDialog (GtkWindow w) type buttons text =
 	toStateR (gtk_message_dialog_new_with_markup
-		window
+		w
 		1 /* DESTROY_WITH_PARENT */
 		(toInt type)
 		(toInt buttons)
-		text)
+		text) >>= \d ->
+	pure (GtkDialog d)
 
 getFileWithDialog :: !GtkWindow !GtkFileChooserAction !(Maybe String) -> GtkM (Maybe FilePath)
-getFileWithDialog window action title =
-	toStateR (gtk_file_chooser_dialog_new title window (toInt action) buttons) >>= \dialog ->
+getFileWithDialog (GtkWindow w) action title =
+	toStateR (gtk_file_chooser_dialog_new title w (toInt action) buttons) >>= \dialog ->
 	toState (gtk_dialog_set_default_response dialog (toInt ResponseAccept)) >>|
 	run dialog
 where
@@ -129,32 +135,48 @@ where
 		SelectFolderAction -> [("Cancel", ResponseCancel), ("Select", ResponseAccept)]
 		CreateFolderAction -> [("Cancel", ResponseCancel), ("Create", ResponseAccept)]
 
-	run dialog =
+	run d =
+		let dialog = GtkDialog d in
 		runDialog dialog >>= \response -> case response of
 			ResponseAccept ->
-				toStateR (gtk_file_chooser_get_filename dialog) >>= \file_name -> case file_name of
+				toStateR (gtk_file_chooser_get_filename d) >>= \file_name -> case file_name of
 					Just _  -> destroy dialog >>| pure file_name
-					Nothing -> run dialog
+					Nothing -> run d
 			_ ->
 				destroy dialog >>|
 				pure Nothing
 
-:: GtkFrame :== Pointer
+instance gtkWidget GtkEntry where gtkWidget (GtkEntry e) = GtkWidget e
+
+newEntry :: GtkM GtkEntry
+newEntry =
+	toStateR gtk_entry_new >>= \e ->
+	show (GtkEntry e)
+
+getText :: !GtkEntry -> GtkM String
+getText (GtkEntry e) = toStateR (gtk_entry_get_text e)
 
-instance gtkWidget GtkFrame where gtkWidget f = f
-instance gtkContainer GtkFrame where gtkContainer f = f
+instance tune GtkEntry GtkText
+where
+	tune (Text text) entry=:(GtkEntry e) =
+		toState (gtk_entry_set_text e text) >>|
+		pure entry
+
+instance gtkWidget GtkFrame where gtkWidget (GtkFrame f) = GtkWidget f
+instance gtkContainer GtkFrame where gtkContainer (GtkFrame f) = GtkContainer f
 instance ptr GtkFrame
 where
-	toPtr   f = f
-	fromPtr f = f
+	toPtr (GtkFrame f) = f
+	fromPtr f = GtkFrame f
 
 newFrame :: !GtkTitle !w -> GtkM GtkFrame | gtkWidget w
 newFrame (Title title) widget =
-	toStateR (gtk_frame_new (case title of "" -> Nothing; _ -> Just title)) >>= \frame ->
+	toStateR (gtk_frame_new (case title of "" -> Nothing; _ -> Just title)) >>= \f ->
 	(case title of
 		"" -> pure ()
-		_  -> toState (gtk_frame_set_label_align frame 0.02 0.5)) >>|
-	addToContainer frame widget >>|
+		_  -> toState (gtk_frame_set_label_align f 0.02 0.5)) >>|
+	let frame = GtkFrame f in
+	addToContainer frame (gtkWidget widget) >>|
 	show frame
 
 framed :: !GtkTitle !(GtkM w) -> GtkM (w, GtkFrame) | gtkWidget w
@@ -162,84 +184,83 @@ framed title widgetf =
 	widgetf >>= \widget ->
 	tuple widget <$> newFrame title widget
 
-:: GtkGrid :== Pointer
-
-instance gtkWidget GtkGrid where gtkWidget g = g
+instance gtkWidget GtkGrid where gtkWidget (GtkGrid g) = GtkWidget g
 
 newGrid :: GtkM GtkGrid
-newGrid = toStateR gtk_grid_new >>= show
+newGrid =
+	toStateR gtk_grid_new >>= \g ->
+	show (GtkGrid g)
 
 attachGrid :: !GtkGrid !(!Int,!Int) !(!Int,!Int) !w -> GtkM w | gtkWidget w
-attachGrid grid (left,top) (width,height) widget =
-	toState (gtk_grid_attach grid (gtkWidget widget) left top width height) >>|
+attachGrid (GtkGrid g) (left,top) (width,height) widget =
+	let (GtkWidget w) = gtkWidget widget in
+	toState (gtk_grid_attach g w left top width height) >>|
 	pure widget
 
-:: GtkLabel :== Pointer
-
-instance gtkWidget GtkLabel where gtkWidget l = l
+instance gtkWidget GtkLabel where gtkWidget (GtkLabel l) = GtkWidget l
 
 newLabel :: GtkM GtkLabel
-newLabel = toStateR gtk_label_new >>= show
+newLabel =
+	toStateR gtk_label_new >>= \l ->
+	show (GtkLabel l)
 
 instance tune GtkLabel GtkText
 where
-	tune (Text text) label =
-		toState (gtk_label_set_markup label text) >>|
+	tune (Text text) label=:(GtkLabel l) =
+		toState (gtk_label_set_markup l text) >>|
 		pure label
 
-:: GtkListStore :== Pointer
-
 newListStore :: ![GType] -> GtkM GtkListStore
-newListStore types = toStateR (gtk_list_store_newv {toInt t \\ t <- types})
+newListStore types =
+	toStateR (gtk_list_store_newv {toInt t \\ t <- types}) >>= \s ->
+	pure (GtkListStore s)
 
 clearListStore :: !GtkListStore -> GtkM GtkListStore
-clearListStore store =
-	toState (gtk_list_store_clear store) >>|
+clearListStore store=:(GtkListStore s) =
+	toState (gtk_list_store_clear s) >>|
 	pure store
 
 appendToListStore :: ![GValue] !GtkListStore -> GtkM GtkListStore
-appendToListStore values store =
-	set 0 values (gtk_list_store_append store) >>|
+appendToListStore values store=:(GtkListStore s) =
+	set 0 values (gtk_list_store_append s) >>|
 	pure store
 where
 	set :: !Int ![GValue] !.{#Int} -> GtkM ()
 	set col [v:vs] iter = set` >>| set (col+1) vs iter
 	where
 		set` = case v of
-			GValueBool b   -> toState (gtk_list_store_set_bool   store iter col b)
-			GValueChar c   -> toState (gtk_list_store_set_char   store iter col c)
-			GValueInt i    -> toState (gtk_list_store_set_int    store iter col i)
-			GValueReal r   -> toState (gtk_list_store_set_real   store iter col r)
-			GValueString s -> toState (gtk_list_store_set_string store iter col s)
+			GValueBool b   -> toState (gtk_list_store_set_bool   s iter col b)
+			GValueChar c   -> toState (gtk_list_store_set_char   s iter col c)
+			GValueInt i    -> toState (gtk_list_store_set_int    s iter col i)
+			GValueReal r   -> toState (gtk_list_store_set_real   s iter col r)
+			GValueString a -> toState (gtk_list_store_set_string s iter col a)
 	set _ [] _ = pure ()
 
 swapItems :: !Int !Int !GtkListStore -> GtkM Bool
-swapItems a b store =
+swapItems a b (GtkListStore s) =
 	let
-		(ok_a,iter_a) = gtk_tree_model_get_iter_from_string store (toString a)
-		(ok_b,iter_b) = gtk_tree_model_get_iter_from_string store (toString b)
+		(ok_a,iter_a) = gtk_tree_model_get_iter_from_string s (toString a)
+		(ok_b,iter_b) = gtk_tree_model_get_iter_from_string s (toString b)
 	in
 	if (ok_a && ok_b)
-		(toState (gtk_list_store_swap store iter_a iter_b) >>| pure True)
+		(toState (gtk_list_store_swap s iter_a iter_b) >>| pure True)
 		(pure False)
 
-:: GtkMenu :== Pointer
-
-instance gtkWidget GtkMenu where gtkWidget m = m
+instance gtkWidget GtkMenu where gtkWidget (GtkMenu m) = GtkWidget m
 
 newMenu :: GtkM GtkMenu
-newMenu = toStateR gtk_menu_new >>= show
-
-:: GtkMenuBar :== Pointer
+newMenu =
+	toStateR gtk_menu_new >>= \m ->
+	show (GtkMenu m)
 
-instance gtkWidget GtkMenuBar where gtkWidget mb = mb
+instance gtkWidget GtkMenuBar where gtkWidget (GtkMenuBar mb) = GtkWidget mb
 
 newMenuBar :: GtkM GtkMenuBar
-newMenuBar = toStateR gtk_menu_bar_new >>= show
+newMenuBar =
+	toStateR gtk_menu_bar_new >>= \mb ->
+	show (GtkMenuBar mb)
 
-:: GtkMenuItem :== Pointer
-
-instance gtkWidget GtkMenuItem where gtkWidget mi = mi
+instance gtkWidget GtkMenuItem where gtkWidget (GtkMenuItem mi) = GtkWidget mi
 instance gtkMenuItem GtkMenuItem where gtkMenuItem mi = mi
 
 newMenuItem :: !String -> GtkM GtkMenuItem
@@ -247,277 +268,290 @@ newMenuItem label =
 	toStateR gtk_menu_item_new >>= \item ->
 	toState (gtk_menu_item_set_label item label) >>|
 	toState (gtk_menu_item_set_use_underline item True) >>|
-	show item
+	show (GtkMenuItem item)
 
 setSubMenu :: !mi !GtkMenu -> GtkM GtkMenu | gtkMenuItem mi
-setSubMenu item menu =
-	toState (gtk_menu_item_set_submenu (gtkMenuItem item) menu) >>|
+setSubMenu item menu=:(GtkMenu m) =
+	let (GtkMenuItem mi) = gtkMenuItem item in
+	toState (gtk_menu_item_set_submenu mi m) >>|
 	pure menu
 
-:: GtkCheckMenuItem :== Pointer
-
-instance gtkWidget GtkCheckMenuItem where gtkWidget cmi = cmi
-instance gtkMenuItem GtkCheckMenuItem where gtkMenuItem cmi = cmi
+instance gtkWidget GtkCheckMenuItem where gtkWidget (GtkCheckMenuItem cmi) = GtkWidget cmi
+instance gtkMenuItem GtkCheckMenuItem where gtkMenuItem (GtkCheckMenuItem cmi) = GtkMenuItem cmi
 instance ptr GtkCheckMenuItem
 where
-	toPtr   cmi = cmi
-	fromPtr cmi = cmi
+	toPtr (GtkCheckMenuItem cmi) = cmi
+	fromPtr cmi = GtkCheckMenuItem cmi
 
 newCheckMenuItem :: !String -> GtkM GtkCheckMenuItem
 newCheckMenuItem label =
 	toStateR gtk_check_menu_item_new >>= \item ->
 	toState (gtk_menu_item_set_label item label) >>|
 	toState (gtk_menu_item_set_use_underline item True) >>|
-	show item
+	show (GtkCheckMenuItem item)
 
 isActive :: !GtkCheckMenuItem -> GtkM Bool
-isActive item = toStateR (gtk_check_menu_item_get_active item)
+isActive (GtkCheckMenuItem cmi) = toStateR (gtk_check_menu_item_get_active cmi)
 
 setActive :: !Bool !GtkCheckMenuItem -> GtkM GtkCheckMenuItem
-setActive active item =
-	toState (gtk_check_menu_item_set_active item active) >>|
+setActive active item=:(GtkCheckMenuItem cmi) =
+	toState (gtk_check_menu_item_set_active cmi active) >>|
 	pure item
 
-:: GtkMenuShell :== Pointer
+instance gtkWidget GtkMenuShell where gtkWidget (GtkMenuShell ms) = GtkWidget ms
 
-instance gtkWidget GtkMenuShell where gtkWidget ms = ms
-
-instance gtkMenuShell GtkMenu where gtkMenuShell m = m
-instance gtkMenuShell GtkMenuBar where gtkMenuShell mb = mb
+instance gtkMenuShell GtkMenu where gtkMenuShell (GtkMenu m) = GtkMenuShell m
+instance gtkMenuShell GtkMenuBar where gtkMenuShell (GtkMenuBar mb) = GtkMenuShell mb
 instance gtkMenuShell GtkMenuShell where gtkMenuShell ms = ms
 
 appendToMenuShell :: !s !mi -> GtkM mi | gtkMenuShell s & gtkMenuItem mi
 appendToMenuShell shell item =
-	toState (gtk_menu_shell_append (gtkMenuShell shell) (gtkMenuItem item)) >>|
+	let
+		(GtkMenuShell ms) = gtkMenuShell shell
+		(GtkMenuItem mi) = gtkMenuItem item
+	in
+	toState (gtk_menu_shell_append ms mi) >>|
 	pure item
 
-:: GtkOrientable :== Pointer
-
 instance tune o GtkOrientation | gtkOrientable o
 where
 	tune orientation orientable =
-		toState (gtk_orientable_set_orientation (gtkOrientable orientable) orientation=:Vertical) >>|
+		let (GtkOrientable o) = gtkOrientable orientable in
+		toState (gtk_orientable_set_orientation o orientation=:Vertical) >>|
 		pure orientable
 
-:: GtkPaned :== Pointer
-
-instance gtkWidget GtkPaned where gtkWidget p = p
-instance gtkContainer GtkPaned where gtkContainer p = p
+instance gtkWidget GtkPaned where gtkWidget (GtkPaned p) = GtkWidget p
+instance gtkContainer GtkPaned where gtkContainer (GtkPaned p) = GtkContainer p
 
 newPaned :: !GtkOrientation !GtkPanedHandleWidth -> GtkM GtkPaned
 newPaned orientation handle_width =
-	toStateR (gtk_paned_new orientation=:Vertical) >>= \paned ->
-	toState (gtk_paned_set_wide_handle paned handle_width=:WideHandle) >>|
-	show paned
+	toStateR (gtk_paned_new orientation=:Vertical) >>= \p ->
+	toState (gtk_paned_set_wide_handle p handle_width=:WideHandle) >>|
+	show (GtkPaned p)
 
 packPane1 :: !GtkPaned !GtkResize !GtkShrink !w -> GtkM w | gtkWidget w
-packPane1 paned resize shrink widget =
-	toState (gtk_paned_pack1 paned (gtkWidget widget) resize=:Resize shrink=:Shrink) >>|
+packPane1 (GtkPaned p) resize shrink widget =
+	let (GtkWidget w) = gtkWidget widget in
+	toState (gtk_paned_pack1 p w resize=:Resize shrink=:Shrink) >>|
 	pure widget
 
 packPane2 :: !GtkPaned !GtkResize !GtkShrink !w -> GtkM w | gtkWidget w
-packPane2 paned resize shrink widget =
-	toState (gtk_paned_pack2 paned (gtkWidget widget) resize=:Resize shrink=:Shrink) >>|
+packPane2 (GtkPaned p) resize shrink widget =
+	let (GtkWidget w) = gtkWidget widget in
+	toState (gtk_paned_pack2 p w resize=:Resize shrink=:Shrink) >>|
 	pure widget
 
-:: GtkScrolledWindow :== Pointer
-
-instance gtkWidget GtkScrolledWindow where gtkWidget sw = sw
-instance gtkContainer GtkScrolledWindow where gtkContainer sw = sw
+instance gtkWidget GtkScrolledWindow where gtkWidget (GtkScrolledWindow sw) = GtkWidget sw
+instance gtkContainer GtkScrolledWindow where gtkContainer (GtkScrolledWindow sw) = GtkContainer sw
 
 newScrolledWindow :: GtkM GtkScrolledWindow
-newScrolledWindow = toStateR (gtk_scrolled_window_new 0 0) >>= show
+newScrolledWindow =
+	toStateR (gtk_scrolled_window_new 0 0) >>= \sw ->
+	show (GtkScrolledWindow sw)
 
 instance tune GtkScrolledWindow (GtkScrollbarPolicy, GtkScrollbarPolicy)
 where
-	tune (hp,vp) window =
-		toState (gtk_scrolled_window_set_policy window (toInt hp) (toInt vp)) >>|
+	tune (hp,vp) window=:(GtkScrolledWindow sw) =
+		toState (gtk_scrolled_window_set_policy sw (toInt hp) (toInt vp)) >>|
 		pure window
 
-:: GtkSeparator :== Pointer
-
-instance gtkWidget GtkSeparator where gtkWidget s = s
+instance gtkWidget GtkSeparator where gtkWidget (GtkSeparator s) = GtkWidget s
 instance ptr GtkSeparator
 where
-	toPtr   s = s
-	fromPtr s = s
+	toPtr (GtkSeparator s) = s
+	fromPtr s = GtkSeparator s
 
 newSeparator :: !GtkOrientation -> GtkM GtkSeparator
-newSeparator orientation = toStateR (gtk_separator_new orientation=:Vertical) >>= show
+newSeparator orientation =
+	toStateR (gtk_separator_new orientation=:Vertical) >>= \s ->
+	show (GtkSeparator s)
 
-:: GtkSpinner :== Pointer
-
-instance gtkWidget GtkSpinner where gtkWidget s = s
+instance gtkWidget GtkSpinner where gtkWidget (GtkSpinner s) = GtkWidget s
 instance ptr GtkSpinner
 where
-	toPtr   s = s
-	fromPtr s = s
+	toPtr (GtkSpinner s) = s
+	fromPtr s = GtkSpinner s
 
 newSpinner :: GtkM GtkSpinner
-newSpinner = toStateR gtk_spinner_new >>= show
+newSpinner =
+	toStateR gtk_spinner_new >>= \s ->
+	show (GtkSpinner s)
 
 startSpinner :: !GtkSpinner -> GtkM GtkSpinner
-startSpinner spinner = toState (gtk_spinner_start spinner) >>| pure spinner
+startSpinner spinner=:(GtkSpinner s) =
+	toState (gtk_spinner_start s) >>|
+	pure spinner
 
 stopSpinner :: !GtkSpinner -> GtkM GtkSpinner
-stopSpinner spinner = toState (gtk_spinner_stop spinner) >>| pure spinner
-
-:: GtkTextBuffer :== Pointer
+stopSpinner spinner=:(GtkSpinner s) =
+	toState (gtk_spinner_stop s) >>|
+	pure spinner
 
 instance ptr GtkTextBuffer
 where
-	toPtr   b = b
-	fromPtr b = b
+	toPtr (GtkTextBuffer b) = b
+	fromPtr b = GtkTextBuffer b
 
 setText :: !String !GtkTextBuffer -> GtkM GtkTextBuffer
-setText s buffer =
-	toState (gtk_text_buffer_set_text buffer s (size s)) >>|
+setText s buffer=:(GtkTextBuffer b) =
+	toState (gtk_text_buffer_set_text b s (size s)) >>|
 	pure buffer
 
 setMarkup :: !String !GtkTextBuffer -> GtkM GtkTextBuffer
-setMarkup s buffer =
-	toStateR (gtk_text_buffer_get_start_iter buffer) >>= \start ->
-	toStateR (gtk_text_buffer_get_end_iter buffer) >>= \end ->
-	toState (gtk_text_buffer_delete buffer start end) >>|
-	toStateR (gtk_text_buffer_get_start_iter buffer) >>= \start ->
-	toState (gtk_text_buffer_insert_markup buffer start s) >>|
+setMarkup s buffer=:(GtkTextBuffer b) =
+	toStateR (gtk_text_buffer_get_start_iter b) >>= \start ->
+	toStateR (gtk_text_buffer_get_end_iter b) >>= \end ->
+	toState (gtk_text_buffer_delete b start end) >>|
+	toStateR (gtk_text_buffer_get_start_iter b) >>= \start ->
+	toState (gtk_text_buffer_insert_markup b start s) >>|
 	pure buffer
 
 insertAtCursor :: !String !GtkTextBuffer -> GtkM GtkTextBuffer
-insertAtCursor s buffer =
-	toState (gtk_text_buffer_insert_at_cursor buffer s (size s)) >>|
+insertAtCursor s buffer=:(GtkTextBuffer b) =
+	toState (gtk_text_buffer_insert_at_cursor b s (size s)) >>|
 	pure buffer
 
-:: GtkTextView :== Pointer
-
-instance gtkWidget GtkTextView where gtkWidget tv = tv
-instance gtkContainer GtkTextView where gtkContainer tv = tv
+instance gtkWidget GtkTextView where gtkWidget (GtkTextView tv) = GtkWidget tv
+instance gtkContainer GtkTextView where gtkContainer (GtkTextView tv) = GtkContainer tv
 instance ptr GtkTextView
 where
-	toPtr   tv = tv
-	fromPtr tv = tv
+	toPtr (GtkTextView tv) = tv
+	fromPtr tv = GtkTextView tv
 
 newTextView :: GtkM GtkTextView
 newTextView =
-	toStateR gtk_text_view_new >>= \text_view ->
-	toState (gtk_text_view_set_editable text_view False) >>|
-	show text_view
+	toStateR gtk_text_view_new >>= \tv ->
+	toState (gtk_text_view_set_editable tv False) >>|
+	show (GtkTextView tv)
 
 getTextBuffer :: !GtkTextView -> GtkTextBuffer
-getTextBuffer text_view = gtk_text_view_get_buffer text_view
+getTextBuffer (GtkTextView tv) = GtkTextBuffer (gtk_text_view_get_buffer tv)
 
 instance tune GtkTextView GtkWrapMode
 where
-	tune mode text_view =
-		toState (gtk_text_view_set_wrap_mode text_view (toInt mode)) >>|
-		pure text_view
-
-:: GtkTreeView :== Pointer
+	tune mode view=:(GtkTextView tv) =
+		toState (gtk_text_view_set_wrap_mode tv (toInt mode)) >>|
+		pure view
 
-instance gtkWidget GtkTreeView where gtkWidget tv = tv
+instance gtkWidget GtkTreeView where gtkWidget (GtkTreeView tv) = GtkWidget tv
 
 newTreeView :: !GtkListStore -> GtkM GtkTreeView
-newTreeView store =
-	toStateR (gtk_tree_view_new_with_model store) >>= \view ->
-	toState (g_object_unref store) >>|
-	show view
+newTreeView (GtkListStore s) =
+	toStateR (gtk_tree_view_new_with_model s) >>= \view ->
+	toState (g_object_unref s) >>|
+	show (GtkTreeView view)
 
 appendColumnToTreeView :: !String !Int !GtkExpand !GtkTreeView -> GtkM GtkTreeView
-appendColumnToTreeView title col expand tree_view =
+appendColumnToTreeView title col expand tree=:(GtkTreeView tv) =
 	toStateR gtk_cell_renderer_text_new >>= \renderer ->
 	toStateR gtk_tree_view_column_new >>= \column ->
 	toState (gtk_tree_view_column_set_title column title) >>|
 	toState (gtk_tree_view_column_pack_start column renderer expand=:Expand) >>|
 	toState (gtk_tree_view_column_add_attribute column renderer "text" col) >>|
-	toState (gtk_tree_view_append_column tree_view column) >>|
-	pure tree_view
+	toState (gtk_tree_view_append_column tv column) >>|
+	pure tree
 
 addSelectionChangedHandler :: !(GtkM ()) !GtkTreeView -> GtkM GtkTreeView
-addSelectionChangedHandler handler tree =
-	let selection = gtk_tree_view_get_selection tree in
-	tune (ChangedHandler handler) selection >>|
+addSelectionChangedHandler handler tree=:(GtkTreeView tv) =
+	let selection = gtk_tree_view_get_selection tv in
+	tune (ChangedHandler handler) (GtkWidget selection) >>|
 	pure tree
 
 getPathToSelection :: !GtkTreeView -> GtkM (Maybe [Int])
-getPathToSelection tree =
-	let selection = gtk_tree_view_get_selection tree in
+getPathToSelection (GtkTreeView tv) =
+	let selection = gtk_tree_view_get_selection tv in
 	toStateR (gtk_tree_selection_get_selected selection) >>= \(selected,iter)
 		| not selected ->
 			pure Nothing
 		| otherwise ->
 			let
-				model = gtk_tree_view_get_model tree
+				model = gtk_tree_view_get_model tv
 				path = gtk_tree_model_get_string_from_iter model iter
 			in
 			pure (Just [toInt part \\ part <- split ":" path])
 
 selectPath :: ![Int] !GtkTreeView -> GtkM Bool
-selectPath path tree =
+selectPath path (GtkTreeView tv) =
 	let
-		store = gtk_tree_view_get_model tree
-		selection = gtk_tree_view_get_selection tree
+		store = gtk_tree_view_get_model tv
+		selection = gtk_tree_view_get_selection tv
 		(ok,iter) = gtk_tree_model_get_iter_from_string store ('Text'.join ":" [toString i \\ i <- path])
 	in
 	if ok
 		(toState (gtk_tree_selection_select_iter selection iter) >>| pure True)
 		(pure False)
 
-:: GtkWidget :== Pointer
-
 instance gtkWidget GtkWidget where gtkWidget w = w
 
 instance ptr GtkWidget
 where
-	toPtr   w = w
-	fromPtr w = w
+	toPtr (GtkWidget w) = w
+	fromPtr w = GtkWidget w
 
 show :: !w -> GtkM w | gtkWidget w
-show widget = toState (gtk_widget_show (gtkWidget widget)) >>| pure widget
+show widget =
+	let (GtkWidget w) = gtkWidget widget in
+	toState (gtk_widget_show w) >>|
+	pure widget
 
 hide :: !w -> GtkM w | gtkWidget w
-hide widget = toState (gtk_widget_hide (gtkWidget widget)) >>| pure widget
+hide widget =
+	let (GtkWidget w) = gtkWidget widget in
+	toState (gtk_widget_hide w) >>|
+	pure widget
 
 destroy :: !w -> GtkM () | gtkWidget w
-destroy widget = toState (gtk_widget_destroy (gtkWidget widget))
+destroy widget =
+	let (GtkWidget w) = gtkWidget widget in
+	toState (gtk_widget_destroy w)
 
 addCSSClass :: !GtkCSSClass !w -> GtkM w | gtkWidget w
 addCSSClass (Class cls) widget =
-	toStateR (gtk_widget_get_style_context (gtkWidget widget)) >>= \context ->
+	let (GtkWidget w) = gtkWidget widget in
+	toStateR (gtk_widget_get_style_context w) >>= \context ->
 	toState (gtk_style_context_add_class context cls) >>|
 	pure widget
 
 removeCSSClass :: !GtkCSSClass !w -> GtkM () | gtkWidget w
 removeCSSClass (Class cls) widget =
-	toStateR (gtk_widget_get_style_context (gtkWidget widget)) >>= \context ->
+	let (GtkWidget w) = gtkWidget widget in
+	toStateR (gtk_widget_get_style_context w) >>= \context ->
 	toState (gtk_style_context_remove_class context cls)
 
 setMargins :: !GtkMargins !w -> GtkM w | gtkWidget w
-setMargins {left,top,right,bottom} widget` =
-	let widget = gtkWidget widget` in
-	toState (gtk_widget_set_margin_left   widget left)   >>|
-	toState (gtk_widget_set_margin_top    widget top)    >>|
-	toState (gtk_widget_set_margin_right  widget right)  >>|
-	toState (gtk_widget_set_margin_bottom widget bottom) >>|
-	pure widget`
+setMargins {left,top,right,bottom} widget =
+	let (GtkWidget w) = gtkWidget widget in
+	toState (gtk_widget_set_margin_left   w left)   >>|
+	toState (gtk_widget_set_margin_top    w top)    >>|
+	toState (gtk_widget_set_margin_right  w right)  >>|
+	toState (gtk_widget_set_margin_bottom w bottom) >>|
+	pure widget
 
 instance tune w GtkSensitivity | gtkWidget w
 where
 	tune sens widget =
-		toState (gtk_widget_set_sensitive (gtkWidget widget) sens=:Sensitive) >>|
+		let (GtkWidget w) = gtkWidget widget in
+		toState (gtk_widget_set_sensitive w sens=:Sensitive) >>|
 		pure widget
 
 instance tune w (GtkAlign,GtkAlign) | gtkWidget w
 where
 	tune (halign,valign) widget =
-		let ptr = gtkWidget widget in
-		toState (gtk_widget_set_halign ptr (toInt halign)) >>|
-		toState (gtk_widget_set_valign ptr (toInt valign)) >>|
+		let (GtkWidget w) = gtkWidget widget in
+		toState (gtk_widget_set_halign w (toInt halign)) >>|
+		toState (gtk_widget_set_valign w (toInt valign)) >>|
 		pure widget
 
-:: GtkWindow :== Pointer
+instance tune w (GtkExpand,GtkExpand) | gtkWidget w
+where
+	tune (hexpand,vexpand) widget =
+		let (GtkWidget w) = gtkWidget widget in
+		toState (gtk_widget_set_hexpand w hexpand=:Expand) >>|
+		toState (gtk_widget_set_vexpand w vexpand=:Expand) >>|
+		pure widget
 
-instance gtkWidget GtkWindow where gtkWidget w = w
-instance gtkContainer GtkWindow where gtkContainer w = w
+instance gtkWidget GtkWindow where gtkWidget (GtkWindow w) = GtkWidget w
+instance gtkContainer GtkWindow where gtkContainer (GtkWindow w) = GtkContainer w
 instance gtkWindow GtkWindow where gtkWindow w = w
 
 newPopup :: !(Maybe (Int,Int)) -> GtkM GtkWindow
@@ -528,16 +562,17 @@ newWindow size = new_window_or_popup False size
 
 new_window_or_popup :: !Bool !(Maybe (Int,Int)) -> GtkM GtkWindow
 new_window_or_popup is_popup size =
-	toStateR (gtk_window_new is_popup) >>= \window ->
+	toStateR (gtk_window_new is_popup) >>= \w ->
 	(case size of
 		Nothing    -> pure ()
-		Just (h,v) -> toState (gtk_widget_set_size_request window h v)) >>|
-	show window
+		Just (h,v) -> toState (gtk_widget_set_size_request w h v)) >>|
+	show (GtkWindow w)
 
 instance tune w GtkTitle | gtkWindow w
 where
 	tune (Title s) window =
-		toState (gtk_window_set_title (gtkWindow window) s) >>|
+		let (GtkWindow w) = gtkWindow window in
+		toState (gtk_window_set_title w s) >>|
 		pure window
 
 // NB: it is also possible to attach CSS to one widget in particular (excluding
@@ -548,7 +583,7 @@ where
 // style is global, we only allow it on GtkWindow, even though it would work on
 // any GtkWidget.
 addCSSFromFile :: !GtkStylePriority !FilePath !GtkWindow -> GtkM Bool
-addCSSFromFile priority path window =
+addCSSFromFile priority path (GtkWindow window) =
 	toStateR gtk_css_provider_new >>= \provider ->
 	toStateR (gtk_css_provider_load_from_path provider path 0) >>= \ok
 		| not ok -> pure ok