MODULE test_containers ;

(*
   m2-GTK4 test - the layout containers.

   Exercises GtkGrid (attach + lookup), GtkStack + GtkStackSwitcher
   (named pages, visible child, transition), GtkNotebook (append,
   paging) and GtkScrolledWindow (child + policy round-trip).
   Requires a display.
*)

FROM Gio IMPORT g_application_run, g_application_quit;
FROM GtkApplication IMPORT gtk_application_new;
FROM GtkWindow IMPORT gtk_application_window_new, gtk_window_set_child;
FROM GtkLabel IMPORT gtk_label_new;
FROM GtkGrid IMPORT gtk_grid_new, gtk_grid_attach, gtk_grid_get_child_at,
   gtk_grid_set_row_spacing, gtk_grid_get_row_spacing,
   gtk_grid_set_column_spacing, gtk_grid_get_column_spacing;
FROM GtkStack IMPORT gtk_stack_new, gtk_stack_add_named,
   gtk_stack_set_visible_child_name, gtk_stack_get_visible_child_name,
   gtk_stack_set_transition_type, gtk_stack_get_transition_type,
   GtkStackTransitionCrossfade;
FROM GtkStackSwitcher IMPORT gtk_stack_switcher_new,
   gtk_stack_switcher_set_stack, gtk_stack_switcher_get_stack;
FROM GtkNotebook IMPORT gtk_notebook_new, gtk_notebook_append_page,
   gtk_notebook_get_n_pages, gtk_notebook_set_current_page,
   gtk_notebook_get_current_page, gtk_notebook_next_page,
   gtk_notebook_prev_page;
FROM GtkScrolledWindow IMPORT gtk_scrolled_window_new,
   gtk_scrolled_window_set_child, gtk_scrolled_window_set_policy,
   gtk_scrolled_window_get_policy, GtkPolicyAutomatic, GtkPolicyNever,
   GtkPolicyType;
FROM GtkUtils IMPORT Connect, CStrToM2;
FROM SYSTEM IMPORT ADDRESS, ADR;
FROM libc IMPORT printf;

CONST
   AppId = "org.example.m2gtk4.TestContainers";

VAR
   app: ADDRESS;
   passed: BOOLEAN;

PROCEDURE OnActivate (application: ADDRESS; data: ADDRESS);
VAR
   window, grid, stack, switcher, notebook, sw, pages: ADDRESS;
   got: ARRAY [0..63] OF CHAR;
   hpol, vpol: GtkPolicyType;
   ok: BOOLEAN;
   i: INTEGER;
BEGIN
   ok := TRUE;

   (* --- GtkGrid --- *)
   grid := gtk_grid_new();
   gtk_grid_set_row_spacing(grid, 4);
   gtk_grid_set_column_spacing(grid, 6);
   IF (gtk_grid_get_row_spacing(grid) # 4) OR
      (gtk_grid_get_column_spacing(grid) # 6) THEN
      printf("grid spacing wrong\n");
      ok := FALSE
   END;
   FOR i := 0 TO 3 DO
      gtk_grid_attach(grid, gtk_label_new("cell"),
                      i MOD 2, i DIV 2, 1, 1)
   END;
   IF (gtk_grid_get_child_at(grid, 0, 0) = NIL) OR
      (gtk_grid_get_child_at(grid, 1, 1) = NIL) THEN
      printf("grid child missing\n");
      ok := FALSE
   END;

   (* --- GtkStack + GtkStackSwitcher --- *)
   stack := gtk_stack_new();
   gtk_stack_add_named(stack, gtk_label_new("one"), "one");
   gtk_stack_add_named(stack, gtk_label_new("two"), "two");
   gtk_stack_add_named(stack, gtk_label_new("three"), "three");
   gtk_stack_set_transition_type(stack, GtkStackTransitionCrossfade);
   IF gtk_stack_get_transition_type(stack) # GtkStackTransitionCrossfade THEN
      printf("stack transition wrong\n");
      ok := FALSE
   END;
   gtk_stack_set_visible_child_name(stack, "two");
   CStrToM2(gtk_stack_get_visible_child_name(stack), got);
   IF (got[0] # 't') OR (got[1] # 'w') OR (got[2] # 'o') OR (got[3] # 0C) THEN
      printf("stack visible name wrong: [%s]\n", got);
      ok := FALSE
   END;
   switcher := gtk_stack_switcher_new();
   gtk_stack_switcher_set_stack(switcher, stack);
   IF gtk_stack_switcher_get_stack(switcher) # stack THEN
      printf("switcher stack wrong\n");
      ok := FALSE
   END;

   (* --- GtkNotebook --- *)
   notebook := gtk_notebook_new();
   gtk_notebook_append_page(notebook, gtk_label_new("page0"),
                            gtk_label_new("Tab 0"));
   gtk_notebook_append_page(notebook, gtk_label_new("page1"),
                            gtk_label_new("Tab 1"));
   gtk_notebook_append_page(notebook, gtk_label_new("page2"),
                            gtk_label_new("Tab 2"));
   IF gtk_notebook_get_n_pages(notebook) # 3 THEN
      printf("notebook page count wrong\n");
      ok := FALSE
   END;
   gtk_notebook_set_current_page(notebook, 1);
   IF gtk_notebook_get_current_page(notebook) # 1 THEN
      printf("notebook current page wrong\n");
      ok := FALSE
   END;
   gtk_notebook_next_page(notebook);
   IF gtk_notebook_get_current_page(notebook) # 2 THEN
      printf("notebook next page wrong\n");
      ok := FALSE
   END;
   gtk_notebook_prev_page(notebook);
   IF gtk_notebook_get_current_page(notebook) # 1 THEN
      printf("notebook prev page wrong\n");
      ok := FALSE
   END;

   (* --- GtkScrolledWindow --- *)
   sw := gtk_scrolled_window_new();
   gtk_scrolled_window_set_child(sw, gtk_label_new("scrollable"));
   gtk_scrolled_window_set_policy(sw, GtkPolicyAutomatic, GtkPolicyNever);
   gtk_scrolled_window_get_policy(sw, hpol, vpol);
   IF (hpol # GtkPolicyAutomatic) OR (vpol # GtkPolicyNever) THEN
      printf("scrolled window policy wrong\n");
      ok := FALSE
   END;

   (* nest grids/notebooks in a real window to exercise the container path *)
   window := gtk_application_window_new(application);
   pages := gtk_notebook_new();
   gtk_notebook_append_page(pages, grid, gtk_label_new("Grid"));
   gtk_notebook_append_page(pages, stack, gtk_label_new("Stack"));
   gtk_notebook_append_page(pages, sw, gtk_label_new("Scroll"));
   gtk_window_set_child(window, pages);

   passed := ok;
   g_application_quit(application)
END OnActivate;

VAR
   rc: INTEGER;
BEGIN
   passed := FALSE;
   app := gtk_application_new(AppId, 0);
   IF app = NIL THEN
      printf("test_containers: FAIL (no app)\n");
      HALT(1)
   END;
   Connect(app, "activate", ADR(OnActivate), NIL);
   rc := g_application_run(app, 0, NIL);

   IF passed THEN
      printf("test_containers: PASS\n");
      HALT(0)
   ELSE
      printf("test_containers: FAIL\n");
      HALT(1)
   END
END test_containers.