/* Haiku window system support.  Hey Emacs, this is -*- C++ -*-
   Copyright (C) 2021 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */

#ifndef _HAIKU_SUPPORT_H
#define _HAIKU_SUPPORT_H

#include <stdint.h>

#ifdef HAVE_FREETYPE
#include <ft2build.h>
#include <fontconfig/fontconfig.h>
#include FT_FREETYPE_H
#include FT_SIZES_H
#endif

enum haiku_cursor
  {
    CURSOR_ID_NO_CURSOR = 12,
    CURSOR_ID_RESIZE_NORTH = 15,
    CURSOR_ID_RESIZE_EAST = 16,
    CURSOR_ID_RESIZE_SOUTH = 17,
    CURSOR_ID_RESIZE_WEST = 18,
    CURSOR_ID_RESIZE_NORTH_EAST = 19,
    CURSOR_ID_RESIZE_NORTH_WEST = 20,
    CURSOR_ID_RESIZE_SOUTH_EAST = 21,
    CURSOR_ID_RESIZE_SOUTH_WEST = 22,
    CURSOR_ID_RESIZE_NORTH_SOUTH = 23,
    CURSOR_ID_RESIZE_EAST_WEST = 24,
    CURSOR_ID_RESIZE_NORTH_EAST_SOUTH_WEST = 25,
    CURSOR_ID_RESIZE_NORTH_WEST_SOUTH_EAST = 26
  };

enum haiku_alert_type
  {
    HAIKU_EMPTY_ALERT = 0,
    HAIKU_INFO_ALERT,
    HAIKU_IDEA_ALERT,
    HAIKU_WARNING_ALERT,
    HAIKU_STOP_ALERT
  };

enum haiku_event_type
  {
    QUIT_REQUESTED,
    FRAME_RESIZED,
    FRAME_EXPOSED,
    KEY_DOWN,
    KEY_UP,
    ACTIVATION,
    MOUSE_MOTION,
    BUTTON_DOWN,
    BUTTON_UP,
    ICONIFICATION,
    MOVE_EVENT,
    SCROLL_BAR_VALUE_EVENT,
    SCROLL_BAR_DRAG_EVENT,
    WHEEL_MOVE_EVENT,
    MENU_BAR_RESIZE,
    MENU_BAR_OPEN,
    MENU_BAR_SELECT_EVENT,
    MENU_BAR_CLOSE
  };

struct haiku_quit_requested_event
{
  void *window;
};

struct haiku_resize_event
{
  void *window;
  float px_heightf;
  float px_widthf;
};

struct haiku_expose_event
{
  void *window;
  int x;
  int y;
  int width;
  int height;
};

#define HAIKU_MODIFIER_ALT (1)
#define HAIKU_MODIFIER_CTRL (1 << 1)
#define HAIKU_MODIFIER_SHIFT (1 << 2)

struct haiku_key_event
{
  void *window;
  int modifiers;
  uint32_t mb_char;
  uint32_t unraw_mb_char;
  short kc;
};

struct haiku_activation_event
{
  void *window;
  int activated_p;
};

struct haiku_mouse_motion_event
{
  void *window;
  bool just_exited_p;
  int x;
  int y;
  uint32_t be_code;
};

struct haiku_button_event
{
  void *window;
  int btn_no;
  int modifiers;
  int x;
  int y;
};

struct haiku_iconification_event
{
  void *window;
  int iconified_p;
};

struct haiku_move_event
{
  void *window;
  int x;
  int y;
};

struct haiku_wheel_move_event
{
  void *window;
  int modifiers;
  float delta_x;
  float delta_y;
};

struct haiku_menu_bar_select_event
{
  void *window;
  void *ptr;
};

#define FSPEC_FAMILY 1
#define FSPEC_STYLE (1 << 1)
#define FSPEC_SLANT (1 << 2)
#define FSPEC_WEIGHT (1 << 3)
#define FSPEC_SPACING (1 << 4)

typedef char haiku_font_family_or_style[64];

enum haiku_font_slant
  {
    SLANT_OBLIQUE,
    SLANT_REGULAR,
    SLANT_ITALIC
  };

struct haiku_font_pattern
{
  int specified;
  struct haiku_font_pattern *next;
  haiku_font_family_or_style family;
  haiku_font_family_or_style style;
  enum haiku_font_slant slant;
  int weight;
  int mono_spacing_p;
};

struct haiku_scroll_bar_value_event
{
  void *scroll_bar;
  int position;
};

struct haiku_scroll_bar_drag_event
{
  void *scroll_bar;
  int dragging_p;
};

struct haiku_menu_bar_resize_event
{
  void *window;
  int width;
  int height;
};

struct haiku_menu_bar_state_event
{
  void *window;
};

#define HAIKU_THIN 0
#define HAIKU_ULTRALIGHT 20
#define HAIKU_EXTRALIGHT 40
#define HAIKU_LIGHT 50
#define HAIKU_SEMI_LIGHT 75
#define HAIKU_REGULAR 100
#define HAIKU_SEMI_BOLD 180
#define HAIKU_BOLD 200
#define HAIKU_EXTRA_BOLD 205
#define HAIKU_ULTRA_BOLD 210

#ifdef __cplusplus
extern "C"
{
#endif
#include <pthread.h>
#include <OS.h>

  /* The port used to send messages from Emacs to the application
     thread. */
  extern port_id port_emacs_to_application;
  /* The port used to send messages from the application thread to
     Emacs. */
  extern port_id port_application_to_emacs;

  extern void haiku_io_init (void);
  extern void haiku_io_init_in_app_thread (void);

  /* Read the size of the next message into len, returning -1 if the
     query fails or there is no next message */
  extern void
  haiku_read_size (ssize_t *len);

  /* Read the next message into buf, putting its type into type,
     assuming the message is len long.  Return 0 if successful and
     -1 if the read fails. */
  extern int
  haiku_read (enum haiku_event_type *type, void *buf, ssize_t len);

  /* Write a message with type type into buf. */
  extern int
  haiku_write (enum haiku_event_type type, void *buf);

  /* Convert RGB32 color color from RGB color space to its
     HSL components pointed to by h, s and l. */
  extern void
  rgb_color_hsl (uint32_t rgb, double *h, double *s, double *l);

  /* Ditto, but the other way round */
  extern void
  hsl_color_rgb (double h, double s, double l, uint32_t *rgb);

  /* Create new bitmap in RGB32 format */
  extern void *
  BBitmap_new (int width, int height, int mono_p);

  /* Take bitmap, a reference to a BBitmap, and return a pointer to
     its data, in RGB32 format */
  extern void *
  BBitmap_data (void *bitmap);

  /* Convert bitmap if required, placing the new bitmap in new_bitmap,
     and return non-null if bitmap was successfully converted.
     Bitmaps should be freed with `BBitmap_free' */
  extern int
  BBitmap_convert (void *bitmap, void **new_bitmap);

  /* Delete bitmap */
  extern void
  BBitmap_free (void *bitmap);

  /* Retrieve the dimensions of bitmap */
  extern void
  BBitmap_dimensions (void *bitmap, int *left, int *top,
		      int *right, int *bottom, int32_t *bytes_per_row,
		      int *mono_p);

  /* Set up an application and return it.  If starting the application
     thread fails, abort Emacs */
  extern void *
  BApplication_setup (void);

  /* Set up and return a window with its view put in VIEW */
  extern void *
  BWindow_new (void *view);

  /* Delete a window */
  extern void
  BWindow_quit (void *window);

  /* Set window offset to X, Y */
  extern void
  BWindow_set_offset (void *window, int x, int y);

  /* Iconify window */
  extern void
  BWindow_iconify (void *window);

  /* Show or hide window */
  extern void
  BWindow_set_visible (void *window, int visible_p);

  /* Open the default monospace font */
  extern void *
  BFont_open_default (double size, int plain_or_bold_or_fixed);

  /* Close a font */
  extern void
  BFont_close (void *font);

  /* Compute font data */
  extern void
  BFont_dat (void *font, int *px_size, int *min_width, int *max_width,
	     int *avg_width, int *height, int *space_width, int *ascent,
	     int *descent, int *underline_position, int *underline_thickness);

  /* Return non-null if font contains chr, a Unicode code-point */
  extern int
  BFont_have_char_p (void *font, int32_t chr);

  /* Compute bounds for mb_str, a character in multibyte encoding,
     used with font.  The width (in pixels) is returned in advance,
     the left bearing in lb, and the right bearing in rb */
  extern void
  BFont_char_bounds (void *font, const char *mb_str, int *advance,
		     int *lb, int *rb);

  /* Change the title of window to the multibyte string title */
  extern void
  BWindow_retitle (void *window, const char *title);

  /* Resize window to width by height */
  extern void
  BWindow_resize (void *window, int width, int height);

  /* Activate window */
  extern void
  BWindow_activate (void *window);

  /* Drawing functions */
  extern void
  BView_StartClip (void *view);

  extern void
  BView_EndClip (void *view);

  extern void
  BView_SetHighColor (void *view, uint32_t color);

  extern void
  BView_SetPenSize (void *view, int u);

  extern void
  BView_SetFont (void *view, void *font);

  extern void
  BView_MovePenTo (void *view, int x, int y);

  extern void
  BView_DrawString (void *view, const char *chr, ptrdiff_t len);

  extern void
  BView_DrawChar (void *view, char chr);

  extern void
  BView_Draw (void *view, int x, int y, int width, int height);

  extern void
  BView_FillRectangle (void *view, int x, int y, int width, int height);

  extern void
  BView_FillRectangleAbs (void *view, int x, int y, int x1, int y1);

  extern void
  BView_StrokeRectangle (void *view, int x, int y, int width, int height);

  extern void
  BView_SetViewColor (void *view, uint32_t color);

  extern void
  BView_ClipToRect (void *view, int x, int y, int width, int height);

  extern void
  BView_ClipToInverseRect (void *view, int x, int y, int width, int height);

  extern void
  BView_StrokeLine (void *view, int sx, int sy, int tx, int ty);

  extern void
  BView_CopyBits (void *view, int x, int y, int width, int height,
		  int tox, int toy, int towidth, int toheight);

  extern void
  BView_DrawBitmap (void *view, void *bitmap, int x, int y,
		    int width, int height, int vx, int vy, int vwidth,
		    int vheight);
  extern void
  BView_DrawBitmapWithEraseOp (void *view, void *bitmap, int x, int y,
			       int width, int height, int vx, int vy, int vwidth,
			       int vheight);

  extern void
  BView_DrawBitmapWithOverOp (void *view, void *bitmap,
			      int x, int y, int width, int height);

  extern void
  BView_BeginLayer (void *view, float opacity);

  extern void
  BView_EndLayer (void *view);

  /* Return the pixel dimensions of the main screen in width and height */
  extern void
  BScreen_px_dim (int *width, int *height);

  /* Resize view to width, height */
  extern void
  BView_resize_to (void *view, int width, int height);

  /* Functions for creating and freeing cursors */
  extern void *
  BCursor_create_default (void);

  extern void *
  BCursor_from_id (enum haiku_cursor cursor);

  extern void *
  BCursor_create_i_beam (void);

  extern void *
  BCursor_create_progress_cursor (void);

  extern void *
  BCursor_create_grab (void);

  /* Delete cursor */
  extern void
  BCursor_delete (void *cursor);

  /* Set view's cursor to cursor */
  extern void
  BView_set_view_cursor (void *view, void *cursor);

  /* Flush window's connection to the App Server */
  extern void
  BWindow_Flush (void *window);

  /* Map the keycode kc, storing the result in code and 1 in
     non_ascii_p if it should be used */
  extern void
  BMapKey (uint32_t kc, int *non_ascii_p, unsigned *code);

  /* Make a scrollbar, attach it to view's window, and return it */
  extern void *
  BScrollBar_make_for_view (void *view, int horizontal_p,
			    int x, int y, int x1, int y1,
			    void *scroll_bar_ptr);

  /* Delete sb, a scrollbar */
  extern void
  BScrollBar_delete (void *sb);

  /* Move view's frame to x, y, x1, y1 */
  extern void
  BView_move_frame (void *view, int x, int y, int x1, int y1);

  /* Update sb with portion, whole and position */
  extern void
  BView_scroll_bar_update (void *sb, int portion, int whole, int position);

  /* Return the default scrollbar size  */
  extern int
  BScrollBar_default_size (int horizontal_p);

  /* Make view invisible */
  extern void
  BView_hide (void *view);

  /* Make view visible */
  extern void
  BView_show (void *view);

  /* Invalidate view */
  extern void
  BView_invalidate (void *view);

  /* Lock view.  This is usually faster than calling LockLooper
     directly. */
  extern void
  BView_draw_lock (void *view);

  /* Ditto, but unlock instead. */
  extern void
  BView_draw_unlock (void *view);

  /* Center window on its screen */
  extern void
  BWindow_center_on_screen (void *window);

  /* Tell view that the mouse has moved to x by y */
  extern void
  BView_mouse_moved (void *view, int x, int y, uint32_t transit);

  /* Tell view it has been clicked at x by y */
  extern void
  BView_mouse_down (void *view, int x, int y);

  /* Tell view it has been released at x by y */
  extern void
  BView_mouse_up (void *view, int x, int y);

  /* Import bits into bitmap using the B_GRAY1 colorspace */
  extern void
  BBitmap_import_mono_bits (void *bitmap, void *bits, int wd, int h);

  /* Return the amount of font families */
  extern int
  BFont_family_count (void);

  /* Query the font family at IDX, returning non-0 on failure */
  extern int
  BFont_family (int idx, char *f, int *fixed_p);

  /* Return non-0 if the family contains style */
  extern int
  BFont_family_has_style_p (haiku_font_family_or_style family,
			    haiku_font_family_or_style style);

  /* Create a font */
  extern void *
  BFont_new (void);

  /* Set font's family and style to FAMILY and STYLE respectively,
     returning non-0 on failure.  */
  extern int
  BFont_set_family_and_style (void *font, haiku_font_family_or_style family,
			      haiku_font_family_or_style style);

  /* Set FONT's family along with its ITALIC and BOLD faces */
  extern int
  BFont_set_family_face (void *font, haiku_font_family_or_style family,
			 int italic_p, int bold_p);

  /* Delete every element of the font pattern PT */
  extern void
  haiku_font_pattern_free (struct haiku_font_pattern *pt);

  /* Find all fonts matching the font pattern PT */
  extern struct haiku_font_pattern *
  BFont_find (struct haiku_font_pattern *pt);

  /* Find and open a font matching the pattern PAT, which must have
     its family set */
  extern int
  BFont_open_pattern (struct haiku_font_pattern *pat, void **font, float size);

  /* Query the family of the default fixed font */
  extern void
  BFont_populate_fixed_family (struct haiku_font_pattern *ptn);

  /* Ditto, but with the plain family */
  extern void
  BFont_populate_plain_family (struct haiku_font_pattern *ptn);

  /* Make a scrollbar at x, y known to the view */
  extern void
  BView_publish_scroll_bar (void *view, int x, int y, int width, int height);

  /* Forget the scrollbar at x, y by width, height */
  extern void
  BView_forget_scroll_bar (void *view, int x, int y, int width, int height);

  /* Place the current coordinates of the mouse, relative to view, at x and y */
  extern void
  BView_get_mouse (void *view, int *x, int *y);

  /* Perform an in-place conversion of x and y from view's coordinate
     system to its screen's coordinate system */
  extern void
  BView_convert_to_screen (void *view, int *x, int *y);

  /* Decorate or undecorate window depending on decorate_p */
  extern void
  BWindow_change_decoration (void *window, int decorate_p);

  /* Decorate window appropriately for use as a tooltip */
  extern void
  BWindow_set_tooltip_decoration (void *window);

  /* Set B_AVOID_FOCUS on window if avoid_focus_p is non-nil, or clear
     it otherwise */
  extern void
  BWindow_set_avoid_focus (void *window, int avoid_focus_p);

  /* Delete the frame view view */
  extern void
  BView_emacs_delete (void *view);

  /* Begin a view transaction, during which drawing operations will
     not be displayed */
  extern void
  BView_BeginTransaction (void *view);

  /* End a view transaction and flush the view */
  extern void
  BView_EndTransaction (void *view);

  /* Return the current workspace */
  extern uint32_t
  haiku_current_workspace (void);

  /* Return a bitmask consisting of workspaces window is on */
  extern uint32_t
  BWindow_workspaces (void *window);

  /* Create a popup menu */
  extern void *
  BPopUpMenu_new (const char *name);

  /* Add an item to the menu */
  extern void
  BMenu_add_item (void *menu, const char *label, void *ptr, bool enabled_p,
		  bool marked_p);

  /* Add a separator to the menu */
  extern void
  BMenu_add_separator (void *menu);

  /* Create a submenu and attach it to menu */
  extern void *
  BMenu_new_submenu (void *menu, const char *label, bool enabled_p);

  /* Create a submenu that notifies Emacs upon opening */
  extern void *
  BMenu_new_menu_bar_submenu (void *menu, const char *label);

  /* Count items in menu */
  extern int
  BMenu_count_items (void *menu);

  /* Find the menu item at idx */
  extern void *
  BMenu_item_at (void *menu, int idx);

  /* Run menu, waiting for it to close, and returning a pointer to the
     data of the selected item (if one exists), or nil.  X, Y should
     be in the screen coordinate system */
  extern void *
  BMenu_run (void *menu, int x, int y);

  /* Delete the entire menu hierarchy of menu, and then delete menu
     itself */
  extern void
  BPopUpMenu_delete (void *menu);

  /* Create a menubar, attach it to view, and return it */
  extern void *
  BMenuBar_new (void *view);

  /* Delete all items from menu */
  extern void
  BMenu_delete_all (void *menu);

  /* Delete menubar along with all subitems */
  extern void
  BMenuBar_delete (void *menubar);

  /* Set item's label to label */
  extern void
  BMenu_item_set_label (void *item, const char *label);

  /* Get item's menu */
  extern void *
  BMenu_item_get_menu (void *item);

  /* Delete count items from menu starting from start */
  extern void
  BMenu_delete_from (void *menu, int start, int count);

  /* Emit a beep noise */
  extern void
  haiku_ring_bell (void);

  /* Create a BAlert with text */
  extern void *
  BAlert_new (const char *text, enum haiku_alert_type type);

  /* Add a button to alert and return the button */
  extern void *
  BAlert_add_button (void *alert, const char *text);

  /* Run the alert, returning the number of the button that was
     selected, or -1 if no button was selected before the alert was
     closed */
  extern int32_t
  BAlert_go (void *alert);

  /* Enable or disable button depending on enabled_p */
  extern void
  BButton_set_enabled (void *button, int enabled_p);

  /* Set view's tooltip to tooltip */
  extern void
  BView_set_tooltip (void *view, const char *tooltip);

  /* Delete alert */
  extern void
  BAlert_delete (void *alert);

#ifdef HAVE_FREETYPE
  /* Render GLYPHS in FACE */
  extern void
  BView_FT_render_glyphs (FT_Face face, unsigned int *codes,
			  int len, uint32_t color, int x, int y,
			  void *view, int width, int height,
			  int sx, int sy);
#endif
#ifdef __cplusplus
}
#endif /* _cplusplus */

/* Borrowed from X.Org keysymdef.h */
#define XK_BackSpace                     0xff08  /* Back space, back char */
#define XK_Tab                           0xff09
#define XK_Linefeed                      0xff0a  /* Linefeed, LF */
#define XK_Clear                         0xff0b
#define XK_Return                        0xff0d  /* Return, enter */
#define XK_Pause                         0xff13  /* Pause, hold */
#define XK_Scroll_Lock                   0xff14
#define XK_Sys_Req                       0xff15
#define XK_Escape                        0xff1b
#define XK_Delete                        0xffff  /* Delete, rubout */
#define XK_Home                          0xff50
#define XK_Left                          0xff51  /* Move left, left arrow */
#define XK_Up                            0xff52  /* Move up, up arrow */
#define XK_Right                         0xff53  /* Move right, right arrow */
#define XK_Down                          0xff54  /* Move down, down arrow */
#define XK_Prior                         0xff55  /* Prior, previous */
#define XK_Page_Up                       0xff55
#define XK_Next                          0xff56  /* Next */
#define XK_Page_Down                     0xff56
#define XK_End                           0xff57  /* EOL */
#define XK_Begin                         0xff58  /* BOL */
#define XK_Select                        0xff60  /* Select, mark */
#define XK_Print                         0xff61
#define XK_Execute                       0xff62  /* Execute, run, do */
#define XK_Insert                        0xff63  /* Insert, insert here */
#define XK_Undo                          0xff65
#define XK_Redo                          0xff66  /* Redo, again */
#define XK_Menu                          0xff67
#define XK_Find                          0xff68  /* Find, search */
#define XK_Cancel                        0xff69  /* Cancel, stop, abort, exit */
#define XK_Help                          0xff6a  /* Help */
#define XK_Break                         0xff6b
#define XK_Mode_switch                   0xff7e  /* Character set switch */
#define XK_script_switch                 0xff7e  /* Alias for mode_switch */
#define XK_Num_Lock                      0xff7f
#define XK_F1                            0xffbe

#endif /* _HAIKU_SUPPORT_H_ */