//
// Widget Node header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2026 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file.  If this
// file is missing or damaged, see the license at:
//
//     https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
//     https://www.fltk.org/bugs.php
//

#ifndef FLUID_NODES_WIDGET_NODE_H
#define FLUID_NODES_WIDGET_NODE_H

#include "nodes/Node.h"

#include <FL/fl_string_functions.h>

#define NUM_EXTRA_CODE 4

class Widget_Node;
class Image_Asset;

extern void* const LOAD;
extern Node* current_node; // one of the selected ones
extern Widget_Node* current_widget; // one of the selected ones

extern const char* subclassname(Node* l);
extern int is_name(const char* c);
void selection_changed(Node* new_current);
Node* sort(Node* parent);

/**
 Base class for all widget nodes including menu items.
 */
class Widget_Node : public Node
{
  typedef Node super;

  virtual Fl_Widget* widget(int,int,int,int) = 0;
  virtual Widget_Node* _make() = 0; // virtual constructor
  void setlabel(const char *);

  /// Additional code blocks that can be inserted in the generated code
  char *extra_code_[NUM_EXTRA_CODE];
  /// User can call the ctor for a class that is derived from the node class
  char *subclass_;
  /// Keep a copy the tooltip here, also always updates the widget's tooltip
  char *tooltip_;
  /// Image name or file name.
  char *image_name_;
  /// Name or file name of deactivated image
  char *inactive_name_;
  /// Set's a widget's hotspot, or adds a divider to a menu item
  uchar hotspot_;
  /// On menu items, set the "headline" flag
  int menu_headline_;

protected:

  /// This variable is set for visible windows in batch mode.
  /// We can't open a window in batch mode, even if we want the "visible" flags
  /// set, so we need a second place to store this information while also
  /// disabling the output of the "hide" property by the Widget Type.
  uchar override_visible_;

  void write_static(Code_Writer& f);
  void write_code1(Code_Writer& f);
  void write_widget_code(Code_Writer& f);
  void write_extra_code(Code_Writer& f);
  void write_block_close(Code_Writer& f);
  void write_code2(Code_Writer& f);
  void write_color(Code_Writer& f, const char*, Fl_Color);

  /// Pointer to widget representing this node in live mode.
  Fl_Widget* live_widget;

public:

  /// Pointer to widget for interactive editing.
  Fl_Widget* o;
  /// Widget access mode, 0=private, 1=public, 2=protected
  int public_;

  // ---- Image stuff

  /// Set the bind image flag for the active image
  int bind_image_;
  /// Compress the active image when inlining into source code
  int compress_image_;
  /// Scale the active image, great for hires screens
  int scale_image_w_, scale_image_h_;
  /// Pointer to the shared image data of the active image
  Image_Asset* image;

  /// Set the bind image flag for the inactive image
  int bind_deimage_;
  /// Compress the inactive image when inlining into source code
  int compress_deimage_;
  /// Scale the inactive image
  int scale_deimage_w_, scale_deimage_h_;
  /// Pointer to the shared image data of the inactive image
  Image_Asset* inactive;

  void setimage(Image_Asset *);
  const char* image_name() const { return image_name_ ? image_name_ : ""; }
  void image_name(const char *name);

  void setinactive(Image_Asset *);
  const char* inactive_name() const { return inactive_name_ ? inactive_name_ : ""; }
  void inactive_name(const char *name);

  Widget_Node();
  ~Widget_Node();

  Node* make(Strategy strategy);
  void open();

  const char* extra_code(int n) const { return extra_code_[n] ? extra_code_[n] : ""; }
  void extra_code(int n, const char *code);
  const char* subclass() const { return subclass_ ? subclass_ : ""; }
  void subclass(const char *name);
  const char* tooltip() const { return tooltip_ ? tooltip_ : ""; }
  void tooltip(const char *text);
  // Note: hotspot is misused by menu items to indicate a divider
  uchar hotspot() const { return hotspot_; }
  void hotspot(uchar v) { hotspot_ = v; }
  uchar resizable() const;
  void resizable(uchar v);

  int menu_headline() const { return menu_headline_; }
  void menu_headline(int v) { menu_headline_ = v; }

  virtual int textstuff(int what, Fl_Font &, int &, Fl_Color &);
  virtual Fl_Menu_Item* subtypes();

  Type type() const { return FLD_NODE_TYPE_Widget_; }
  bool is_a(Type inType) const { return (inType==FLD_NODE_TYPE_Widget_) ? true : super::is_a(inType); }
  int is_widget() const;
  int is_true_widget() const { return 1; }
  int is_public() const;

  void write_properties(Project_Writer &f);
  void read_property(Project_Reader &f, const char *);
  int read_fdesign(const char*, const char*);

  Fl_Widget* enter_live_mode(int top=0);
  Fl_Widget* propagate_live_mode(Fl_Group* grp);
  void leave_live_mode();
  void copy_properties();

  virtual void ideal_size(int &w, int &h);

  void redraw();
};

extern Fl_Window* the_panel;

#endif // FLUID_NODES_WIDGET_NODE_H