51a55bc736
* Add classes for application and project * Removed all globals from Fluid.h * Extracting args and project history into their own classes * Moving globals into Application class * Initialize values inside headers for some classes. * Undo functionality wrapped in a class inside Project. * File reader and writer are now linked to a project. * Avoid global project access * Nodes (former Types) will be managed by a new Tree class. * Removed static members (hidden globals) form Node/Fl_Type. * Adding Tree iterator. * Use nullptr instead of 0, NULL, or 0L * Renamed Fl_..._Type to ..._Node, FL_OVERRIDE -> override * Renaming ..._type to ...::prototype * Splitting Widget Panel into multiple files. * Moved callback code into widget panel file. * Cleaning up Fluid_Image -> Image_asset * Moving Fd_Snap_Action into new namespace fld::app::Snap_Action etc. * Moved mergeback into proj folder. * `enum ID` is now `enum class Type`.
776 lines
25 KiB
C++
776 lines
25 KiB
C++
//
|
|
// Grid Node code for the Fast Light Tool Kit (FLTK).
|
|
//
|
|
// Copyright 2023-2025 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
|
|
//
|
|
|
|
#include "nodes/Grid_Node.h"
|
|
|
|
#include "Fluid.h"
|
|
#include "app/Snap_Action.h"
|
|
#include "proj/undo.h"
|
|
#include "io/Project_Reader.h"
|
|
#include "io/Project_Writer.h"
|
|
#include "io/Code_Writer.h"
|
|
#include "widgets/Node_Browser.h"
|
|
#include "widgets/Formula_Input.h"
|
|
|
|
#include <FL/Fl_Grid.H>
|
|
#include <FL/Fl_Value_Input.H>
|
|
#include <FL/Fl_Button.H>
|
|
#include <FL/Fl_Choice.H>
|
|
#include "../src/flstring.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
|
|
// TODO: better grid overlay?
|
|
// TODO: grid_child_cb should move all selected cells, not just the current_selected.
|
|
// TODO: buttons to add and delete rows and columns in the widget dialog
|
|
// TODO: ways to resize rows and columns, add and delete them in the project window, pulldown menu?
|
|
// TODO: alignment can be FL_GRID_LEFT|FL_GRID_VERTICAL?
|
|
|
|
// ---- Fl_Grid_Proxy --------------------------------------------------- MARK: -
|
|
|
|
/**
|
|
An implementation of the Fl_Grid widget with additional functionality.
|
|
|
|
Fl_Grid_Proxy add a list of transient children, i.e. children that are
|
|
temporarily assigned to a cell that is already taken by another child.
|
|
*/
|
|
Fl_Grid_Proxy::Fl_Grid_Proxy(int X,int Y,int W,int H)
|
|
: Fl_Grid(X,Y,W,H),
|
|
transient_(nullptr),
|
|
num_transient_(0),
|
|
cap_transient_(0)
|
|
{
|
|
}
|
|
|
|
Fl_Grid_Proxy::~Fl_Grid_Proxy() {
|
|
int i;
|
|
if (transient_) {
|
|
for (i=0; i<num_transient_; i++) {
|
|
if (transient_[i].cell) ::free(transient_[i].cell);
|
|
}
|
|
::free(transient_);
|
|
}
|
|
}
|
|
|
|
// Override group's resize behavior to do nothing to children:
|
|
void Fl_Grid_Proxy::resize(int X, int Y, int W, int H) {
|
|
if (Fluid.proj.tree.allow_layout > 0) {
|
|
Fl_Grid::resize(X, Y, W, H);
|
|
} else {
|
|
Fl_Widget::resize(X, Y, W, H);
|
|
}
|
|
redraw();
|
|
}
|
|
|
|
/**
|
|
Override draw() to make groups with no box or flat box background visible.
|
|
*/
|
|
void Fl_Grid_Proxy::draw() {
|
|
if (Fluid.show_ghosted_outline && (box() == FL_NO_BOX)) {
|
|
fl_rect(x(), y(), w(), h(), Fl::box_color(fl_color_average(FL_FOREGROUND_COLOR, color(), .1f)));
|
|
}
|
|
Fl_Grid::draw();
|
|
}
|
|
|
|
/**
|
|
Draw additional markings in the overlay plane when a grid is selected.
|
|
*/
|
|
void Fl_Grid_Proxy::draw_overlay() {
|
|
fl_line_style(FL_DOT);
|
|
grid_color = fl_color();
|
|
draw_grid();
|
|
fl_color(grid_color);
|
|
}
|
|
|
|
/**
|
|
Move a cell into the grid or within the grid.
|
|
|
|
If the target cell is already taken, \p how will determine what to do:
|
|
|
|
If \p how is 0, the existing cell at \p to_row, \p to_col will be deleted,
|
|
unlinking the occupant from the grid. \p in_child will the be inserted at the
|
|
given location.
|
|
|
|
If \p how is 1, the old cell will remain intact, however \p in_child will be
|
|
unlinked from the grid.
|
|
|
|
If \p how is 2, the old cell will remain intact, and \p in_child will be
|
|
removed from the grid, but it will be stored in the transient list and
|
|
resized to the target cell position and size. If \p in_child is later
|
|
moved to an unoccupied cell, it will be removed from the transient list and
|
|
relinked to the grid. Rowspan and colspan are ignored here.
|
|
|
|
\param[in] in_child must already be a child of grid
|
|
\param[in] to_row, to_col move the child into this cell
|
|
\param[in] how 0: replace occupant, 1: don't replace, 2: make transient
|
|
if occupied
|
|
*/
|
|
void Fl_Grid_Proxy::move_cell(Fl_Widget *in_child, int to_row, int to_col, int how) {
|
|
// the child must already be a true child of grid
|
|
assert(find(in_child)<children());
|
|
|
|
short rowspan = 1, colspan = 1;
|
|
Fl_Grid_Align align = FL_GRID_FILL;
|
|
int w = 20, h = 20;
|
|
const Fl_Grid::Cell *old_cell = cell(in_child);
|
|
if (old_cell) {
|
|
if (old_cell->row() == to_row && old_cell->col() == to_col) return;
|
|
rowspan = old_cell->rowspan();
|
|
colspan = old_cell->colspan();
|
|
align = old_cell->align();
|
|
old_cell->minimum_size(&w, &h);
|
|
}
|
|
if ((to_row < 0) || (to_row+rowspan > rows())) return;
|
|
if ((to_col < 0) || (to_col+colspan > cols())) return;
|
|
Fl_Grid::Cell *new_cell = nullptr;
|
|
if (how == 0) { // replace old occupant in cell, making that one homeless
|
|
new_cell = widget(in_child, to_row, to_col, rowspan, colspan, align);
|
|
} else if (how == 1) { // don't replace an old occupant, making ourselves homeless
|
|
// todo: colspan, rowspan?
|
|
if (cell(to_row, to_col) == nullptr) {
|
|
new_cell = widget(in_child, to_row, to_col, rowspan, colspan, align);
|
|
} else {
|
|
if (old_cell) remove_cell(old_cell->row(), old_cell->col());
|
|
}
|
|
} else if (how == 2) {
|
|
Cell *current = cell(to_row, to_col);
|
|
if (current == nullptr) {
|
|
new_cell = widget(in_child, to_row, to_col, rowspan, colspan, align);
|
|
} else {
|
|
if (old_cell) remove_cell(old_cell->row(), old_cell->col());
|
|
new_cell = transient_widget(in_child, to_row, to_col, rowspan, colspan, align);
|
|
Fl_Widget *w = current->widget();
|
|
Fluid.proj.tree.allow_layout++;
|
|
in_child->resize(w->x(), w->y(), w->w(), w->h());
|
|
Fluid.proj.tree.allow_layout--;
|
|
}
|
|
}
|
|
if (new_cell) new_cell->minimum_size(w, h);
|
|
}
|
|
|
|
/**
|
|
Generate or replace a transient widget entry.
|
|
|
|
If the widget is in the cell list, it will be removed there.
|
|
If the widget is already transient, the cell will be replaced.
|
|
|
|
\param[in] wi a child of this Fl_Grid_Proxy, that may be linked to a cell or transient cell
|
|
\param[in] row, col, row_span, col_span, align cell parameters
|
|
*/
|
|
Fl_Grid::Cell* Fl_Grid_Proxy::transient_widget(Fl_Widget *wi, int row, int col, int row_span, int col_span, Fl_Grid_Align align) {
|
|
int i = 0;
|
|
bool remove_old_cell = false;
|
|
Cell *old_cell = cell(wi);
|
|
if (old_cell) {
|
|
remove_old_cell = true;
|
|
} else {
|
|
for (i=0; i<num_transient_; i++) {
|
|
if (transient_[i].widget == wi) {
|
|
old_cell = transient_[i].cell;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Cell *new_cell = new Cell(wi, row, col);
|
|
new_cell->rowspan(row_span);
|
|
new_cell->colspan(col_span);
|
|
new_cell->align(align);
|
|
if (old_cell) {
|
|
int mw, mh;
|
|
old_cell->minimum_size(&mw, &mh);
|
|
new_cell->minimum_size(mw, mh);
|
|
if (remove_old_cell) {
|
|
remove_cell(old_cell->row(), old_cell->col());
|
|
} else {
|
|
delete old_cell;
|
|
}
|
|
}
|
|
if (i == num_transient_) {
|
|
transient_make_room_(num_transient_ + 1);
|
|
transient_[i].widget = wi;
|
|
num_transient_++;
|
|
}
|
|
transient_[i].cell = new_cell;
|
|
return new_cell;
|
|
}
|
|
|
|
/**
|
|
Make room for at least n transient widgets in the array.
|
|
\param[in] n minimum number of entries
|
|
*/
|
|
void Fl_Grid_Proxy::transient_make_room_(int n) {
|
|
if (n > cap_transient_) {
|
|
cap_transient_ = n + 10;
|
|
transient_ = (Cell_Widget_Pair*)::realloc(transient_, cap_transient_ * sizeof(Cell_Widget_Pair));
|
|
}
|
|
}
|
|
|
|
/**
|
|
Remove a widget form the list and deallocate the transient cell.
|
|
\param[in] w remove the transient cell for this widget
|
|
*/
|
|
void Fl_Grid_Proxy::transient_remove_(Fl_Widget *w) {
|
|
for (int i=0; i<num_transient_; i++) {
|
|
if (transient_[i].widget==w) {
|
|
if (transient_[i].cell) {
|
|
::free(transient_[i].cell);
|
|
::memmove(transient_+i, transient_+i+1, sizeof(Cell_Widget_Pair)*(num_transient_-i-1));
|
|
num_transient_--;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
Find a cell in the grid or in the transient cell list.
|
|
\param[in] widget must be a child of the grid.
|
|
\return the cell, the transient cell, or nullptr if neither was found.
|
|
*/
|
|
Fl_Grid_Proxy::Cell *Fl_Grid_Proxy::any_cell(Fl_Widget *widget) const {
|
|
Cell *c = cell(widget);
|
|
if (c) return c;
|
|
return transient_cell(widget);
|
|
}
|
|
|
|
/**
|
|
Find a cell in the transient cell list.
|
|
\param[in] widget must be a child of the grid.
|
|
\return the transient cell, or nullptr if it was not found.
|
|
*/
|
|
Fl_Grid_Proxy::Cell *Fl_Grid_Proxy::transient_cell(Fl_Widget *widget) const {
|
|
for (int i=0; i<num_transient_; i++) {
|
|
if (transient_[i].widget == widget)
|
|
return transient_[i].cell;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
/**
|
|
Forwarding the call.
|
|
\param[in] wi generate a cell for this widget
|
|
\param[in] row, col, align cell parameters
|
|
*/
|
|
Fl_Grid::Cell *Fl_Grid_Proxy::widget(Fl_Widget *wi, int row, int col, Fl_Grid_Align align) {
|
|
return widget(wi, row, col, 1, 1, align);
|
|
}
|
|
|
|
/**
|
|
Just like the Fl_Grid original, but removes potential transient cell.
|
|
\param[in] wi generate a cell for this widget
|
|
\param[in] row, col, rowspan, colspan, align cell parameters
|
|
*/
|
|
Fl_Grid::Cell *Fl_Grid_Proxy::widget(Fl_Widget *wi, int row, int col, int rowspan, int colspan, Fl_Grid_Align align) {
|
|
transient_remove_(wi);
|
|
return Fl_Grid::widget(wi, row, col, rowspan, colspan, align);
|
|
}
|
|
|
|
|
|
|
|
// ---- Grid_Node --------------------------------------------------- MARK: -
|
|
|
|
Grid_Node Grid_Node::prototype; // the "factory"
|
|
|
|
Grid_Node::Grid_Node() {
|
|
}
|
|
|
|
Fl_Widget *Grid_Node::widget(int X,int Y,int W,int H) {
|
|
Fl_Grid *g = new Fl_Grid_Proxy(X,Y,W,H);
|
|
g->layout(3, 3);
|
|
Fl_Group::current(nullptr);
|
|
return g;
|
|
}
|
|
|
|
Fl_Widget *Grid_Node::enter_live_mode(int top) {
|
|
Fl_Grid *grid = new Fl_Grid(o->x(), o->y(), o->w(), o->h());
|
|
return propagate_live_mode(grid);
|
|
}
|
|
|
|
void Grid_Node::leave_live_mode() {
|
|
}
|
|
|
|
void Grid_Node::copy_properties()
|
|
{
|
|
super::copy_properties();
|
|
Fl_Grid *d = (Fl_Grid*)live_widget, *s =(Fl_Grid*)o;
|
|
d->layout(s->rows(), s->cols());
|
|
int lm, tm, rm, bm;
|
|
s->margin(&lm, &tm, &rm, &bm);
|
|
d->margin(lm, tm, rm, bm);
|
|
int rg, cg;
|
|
s->gap(&rg, &cg);
|
|
d->gap(rg, cg);
|
|
// copy col widths, heights, and gaps
|
|
for (int c=0; c<s->cols(); c++) {
|
|
d->col_width(c, s->col_width(c));
|
|
d->col_gap(c, s->col_gap(c));
|
|
d->col_weight(c, s->col_weight(c));
|
|
}
|
|
// copy row widths, heights, and gaps
|
|
for (int r=0; r<s->rows(); r++) {
|
|
d->row_height(r, s->row_height(r));
|
|
d->row_gap(r, s->row_gap(r));
|
|
d->row_weight(r, s->row_weight(r));
|
|
}
|
|
}
|
|
|
|
void Grid_Node::copy_properties_for_children() {
|
|
Fl_Grid *d = (Fl_Grid*)live_widget, *s =(Fl_Grid*)o;
|
|
for (int i=0; i<s->children(); i++) {
|
|
Fl_Grid::Cell *cell = s->cell(s->child(i));
|
|
if (cell && i<d->children()) {
|
|
d->widget(d->child(i),
|
|
cell->row(), cell->col(),
|
|
cell->rowspan(), cell->colspan(),
|
|
cell->align());
|
|
}
|
|
}
|
|
d->layout();
|
|
}
|
|
|
|
void Grid_Node::write_properties(fld::io::Project_Writer &f)
|
|
{
|
|
super::write_properties(f);
|
|
Fl_Grid* grid = (Fl_Grid*)o;
|
|
int i, rows = grid->rows(), cols = grid->cols();
|
|
f.write_indent(level+1);
|
|
f.write_string("dimensions {%d %d}", rows, cols);
|
|
int lm, tm, rm, bm;
|
|
grid->margin(&lm, &tm, &rm, &bm);
|
|
if (lm!=0 || tm!=0 || rm!=0 || bm!=0)
|
|
f.write_string("margin {%d %d %d %d}", lm, tm, rm, bm);
|
|
int rg, cg;
|
|
grid->gap(&rg, &cg);
|
|
if (rg!=0 || cg!=0)
|
|
f.write_string("gap {%d %d}", rg, cg);
|
|
// -- write all row heights if one of them is not the default 0
|
|
for (i=0; i<rows; i++) if (grid->row_height(i)!=0) break;
|
|
if (i<rows) {
|
|
f.write_indent(level+1);
|
|
f.write_string("rowheights {");
|
|
for (i=0; i<rows; i++) f.write_string("%d", grid->row_height(i));
|
|
f.write_string("}");
|
|
}
|
|
// -- write all row weights if one of them is not the default 50
|
|
for (i=0; i<rows; i++) if (grid->row_weight(i)!=50) break;
|
|
if (i<rows) {
|
|
f.write_indent(level+1);
|
|
f.write_string("rowweights {");
|
|
for (i=0; i<rows; i++) f.write_string("%d", grid->row_weight(i));
|
|
f.write_string("}");
|
|
}
|
|
// -- write all row gaps if one of them is not the default -1
|
|
for (i=0; i<rows; i++) if (grid->row_gap(i)!=-1) break;
|
|
if (i<rows) {
|
|
f.write_indent(level+1);
|
|
f.write_string("rowgaps {");
|
|
for (i=0; i<rows; i++) f.write_string("%d", grid->row_gap(i));
|
|
f.write_string("}");
|
|
}
|
|
// -- write all col widths if one of them is not the default 0
|
|
for (i=0; i<cols; i++) if (grid->col_width(i)!=0) break;
|
|
if (i<cols) {
|
|
f.write_indent(level+1);
|
|
f.write_string("colwidths {");
|
|
for (i=0; i<cols; i++) f.write_string("%d", grid->col_width(i));
|
|
f.write_string("}");
|
|
}
|
|
// -- write all col weights if one of them is not the default 50
|
|
for (i=0; i<cols; i++) if (grid->col_weight(i)!=50) break;
|
|
if (i<cols) {
|
|
f.write_indent(level+1);
|
|
f.write_string("colweights {");
|
|
for (i=0; i<cols; i++) f.write_string("%d", grid->col_weight(i));
|
|
f.write_string("}");
|
|
}
|
|
// -- write all col gaps if one of them is not the default -1
|
|
for (i=0; i<cols; i++) if (grid->col_gap(i)!=-1) break;
|
|
if (i<cols) {
|
|
f.write_indent(level+1);
|
|
f.write_string("colgaps {");
|
|
for (i=0; i<cols; i++) f.write_string("%d", grid->col_gap(i));
|
|
f.write_string("}");
|
|
}
|
|
}
|
|
|
|
void Grid_Node::read_property(fld::io::Project_Reader &f, const char *c)
|
|
{
|
|
Fl_Grid* grid = (Fl_Grid*)o;
|
|
if (!strcmp(c,"dimensions")) {
|
|
int rows = 3, cols = 3;
|
|
if (sscanf(f.read_word(),"%d %d", &rows, &cols) == 2)
|
|
grid->layout(rows, cols);
|
|
} else if (!strcmp(c,"margin")) {
|
|
int lm, tm, rm, bm;
|
|
if (sscanf(f.read_word(),"%d %d %d %d", &lm, &tm, &rm, &bm) == 4)
|
|
grid->margin(lm, tm, rm, bm);
|
|
} else if (!strcmp(c,"gap")) {
|
|
int rg, cg;
|
|
if (sscanf(f.read_word(),"%d %d", &rg, &cg) == 2)
|
|
grid->gap(rg, cg);
|
|
} else if (!strcmp(c,"rowheights")) {
|
|
int rows = grid->rows();
|
|
f.read_word(1); // "{"
|
|
for (int i=0; i<rows; i++) grid->row_height(i, f.read_int());
|
|
f.read_word(1); // "}"
|
|
} else if (!strcmp(c,"rowweights")) {
|
|
int rows = grid->rows();
|
|
f.read_word(1); // "{"
|
|
for (int i=0; i<rows; i++) grid->row_weight(i, f.read_int());
|
|
f.read_word(1); // "}"
|
|
} else if (!strcmp(c,"rowgaps")) {
|
|
int rows = grid->rows();
|
|
f.read_word(1); // "{"
|
|
for (int i=0; i<rows; i++) grid->row_gap(i, f.read_int());
|
|
f.read_word(1); // "}"
|
|
} else if (!strcmp(c,"colwidths")) {
|
|
int cols = grid->cols();
|
|
f.read_word(1); // "{"
|
|
for (int i=0; i<cols; i++) grid->col_width(i, f.read_int());
|
|
f.read_word(1); // "}"
|
|
} else if (!strcmp(c,"colweights")) {
|
|
int cols = grid->cols();
|
|
f.read_word(1); // "{"
|
|
for (int i=0; i<cols; i++) grid->col_weight(i, f.read_int());
|
|
f.read_word(1); // "}"
|
|
} else if (!strcmp(c,"colgaps")) {
|
|
int cols = grid->cols();
|
|
f.read_word(1); // "{"
|
|
for (int i=0; i<cols; i++) grid->col_gap(i, f.read_int());
|
|
f.read_word(1); // "}"
|
|
} else {
|
|
super::read_property(f, c);
|
|
}
|
|
}
|
|
|
|
void Grid_Node::write_parent_properties(fld::io::Project_Writer &f, Node *child, bool encapsulate) {
|
|
Fl_Grid *grid;
|
|
Fl_Widget *child_widget;
|
|
Fl_Grid::Cell *cell;
|
|
if (!child->is_true_widget()) return super::write_parent_properties(f, child, true);
|
|
grid = (Fl_Grid*)o;
|
|
child_widget = ((Widget_Node*)child)->o;
|
|
cell = grid->cell(child_widget);
|
|
if (!cell) return super::write_parent_properties(f, child, true);
|
|
if (encapsulate) {
|
|
f.write_indent(level+2);
|
|
f.write_string("parent_properties {");
|
|
}
|
|
f.write_indent(level+3);
|
|
f.write_string("location {%d %d}", cell->row(), cell->col());
|
|
int v = cell->colspan();
|
|
if (v>1) {
|
|
f.write_indent(level+3);
|
|
f.write_string("colspan %d", v);
|
|
}
|
|
v = cell->rowspan();
|
|
if (v>1) {
|
|
f.write_indent(level+3);
|
|
f.write_string("rowspan %d", v);
|
|
}
|
|
v = (int)cell->align();
|
|
if (v!=FL_GRID_FILL) {
|
|
f.write_indent(level+3);
|
|
f.write_string("align %d", v);
|
|
}
|
|
int min_w = 0, min_h = 0;
|
|
cell->minimum_size(&min_w, &min_h);
|
|
if (min_w!=20 || min_h!=20) {
|
|
f.write_indent(level+3);
|
|
f.write_string("minsize {%d %d}", min_w, min_h);
|
|
}
|
|
super::write_parent_properties(f, child, false);
|
|
if (encapsulate) {
|
|
f.write_indent(level+2);
|
|
f.write_string("}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
// NOTE: we have to do this in a loop just as ::read_property() in case a new
|
|
// property is added. In the current setup, all the remaining properties
|
|
// will be skipped
|
|
void Grid_Node::read_parent_property(fld::io::Project_Reader &f, Node *child, const char *property) {
|
|
if (!child->is_true_widget()) {
|
|
super::read_parent_property(f, child, property);
|
|
return;
|
|
}
|
|
Fl_Grid *grid = (Fl_Grid*)o;
|
|
Fl_Widget *child_widget = ((Widget_Node*)child)->o;
|
|
if (!strcmp(property, "location")) {
|
|
int row = -1, col = -1;
|
|
const char *value = f.read_word();
|
|
sscanf(value, "%d %d", &row, &col);
|
|
Fl_Grid::Cell *cell = grid->widget(child_widget, row, col);
|
|
if (cell) {
|
|
int min_w = 20, min_h = 20;
|
|
cell->minimum_size(min_w, min_h);
|
|
}
|
|
} else if (!strcmp(property, "colspan")) {
|
|
int colspan = atoi(f.read_word());
|
|
Fl_Grid::Cell *cell = grid->cell(child_widget);
|
|
if (cell) cell->colspan(colspan);
|
|
} else if (!strcmp(property, "rowspan")) {
|
|
int rowspan = atoi(f.read_word());
|
|
Fl_Grid::Cell *cell = grid->cell(child_widget);
|
|
if (cell) cell->rowspan(rowspan);
|
|
} else if (!strcmp(property, "align")) {
|
|
int align = atoi(f.read_word());
|
|
Fl_Grid::Cell *cell = grid->cell(child_widget);
|
|
if (cell) cell->align((Fl_Grid_Align)align);
|
|
} if (!strcmp(property, "minsize")) {
|
|
int min_w = 20, min_h = 20;
|
|
const char *value = f.read_word();
|
|
sscanf(value, "%d %d", &min_w, &min_h);
|
|
Fl_Grid::Cell *cell = grid->cell(child_widget);
|
|
if (cell) cell->minimum_size(min_w, min_h);
|
|
} else {
|
|
super::read_parent_property(f, child, property);
|
|
}
|
|
}
|
|
|
|
void Grid_Node::write_code1(fld::io::Code_Writer& f) {
|
|
const char *var = name() ? name() : "o";
|
|
Fl_Grid* grid = (Fl_Grid*)o;
|
|
Widget_Node::write_code1(f);
|
|
int i, rows = grid->rows(), cols = grid->cols();
|
|
f.write_c("%s%s->layout(%d, %d);\n", f.indent(), var, rows, cols);
|
|
int lm, tm, rm, bm;
|
|
grid->margin(&lm, &tm, &rm, &bm);
|
|
if (lm!=0 || tm!=0 || rm!=0 || bm!=0)
|
|
f.write_c("%s%s->margin(%d, %d, %d, %d);\n", f.indent(), var, lm, tm, rm, bm);
|
|
int rg, cg;
|
|
grid->gap(&rg, &cg);
|
|
if (rg!=0 || cg!=0)
|
|
f.write_c("%s%s->gap(%d, %d);\n", f.indent(), var, rg, cg);
|
|
// -- write all row heights if one of them is not the default 0
|
|
for (i=0; i<rows; i++) if (grid->row_height(i)!=0) break;
|
|
if (i<rows) {
|
|
f.write_c("%sstatic const int rowheights[] = { %d", f.indent(), grid->row_height(0));
|
|
for (i=1; i<rows; i++) f.write_c(", %d", grid->row_height(i));
|
|
f.write_c(" };\n");
|
|
f.write_c("%s%s->row_height(rowheights, %d);\n", f.indent(), var, rows);
|
|
}
|
|
// -- write all row weights if one of them is not the default 50
|
|
for (i=0; i<rows; i++) if (grid->row_weight(i)!=50) break;
|
|
if (i<rows) {
|
|
f.write_c("%sstatic const int rowweights[] = { %d", f.indent(), grid->row_weight(0));
|
|
for (i=1; i<rows; i++) f.write_c(", %d", grid->row_weight(i));
|
|
f.write_c(" };\n");
|
|
f.write_c("%s%s->row_weight(rowweights, %d);\n", f.indent(), var, rows);
|
|
}
|
|
// -- write all row gaps if one of them is not the default -1
|
|
for (i=0; i<rows; i++) if (grid->row_gap(i)!=-1) break;
|
|
if (i<rows) {
|
|
f.write_c("%sstatic const int rowgaps[] = { %d", f.indent(), grid->row_gap(0));
|
|
for (i=1; i<rows; i++) f.write_c(", %d", grid->row_gap(i));
|
|
f.write_c(" };\n");
|
|
f.write_c("%s%s->row_gap(rowgaps, %d);\n", f.indent(), var, rows);
|
|
}
|
|
// -- write all col widths if one of them is not the default 0
|
|
for (i=0; i<cols; i++) if (grid->col_width(i)!=0) break;
|
|
if (i<cols) {
|
|
f.write_c("%sstatic const int colwidths[] = { %d", f.indent(), grid->col_width(0));
|
|
for (i=1; i<cols; i++) f.write_c(", %d", grid->col_width(i));
|
|
f.write_c(" };\n");
|
|
f.write_c("%s%s->col_width(colwidths, %d);\n", f.indent(), var, cols);
|
|
}
|
|
// -- write all col weights if one of them is not the default 50
|
|
for (i=0; i<cols; i++) if (grid->col_weight(i)!=50) break;
|
|
if (i<cols) {
|
|
f.write_c("%sstatic const int colweights[] = { %d", f.indent(), grid->col_weight(0));
|
|
for (i=1; i<cols; i++) f.write_c(", %d", grid->col_weight(i));
|
|
f.write_c(" };\n");
|
|
f.write_c("%s%s->col_weight(colweights, %d);\n", f.indent(), var, cols);
|
|
}
|
|
// -- write all col gaps if one of them is not the default -1
|
|
for (i=0; i<cols; i++) if (grid->col_gap(i)!=-1) break;
|
|
if (i<cols) {
|
|
f.write_c("%sstatic const int colgaps[] = { %d", f.indent(), grid->col_gap(0));
|
|
for (i=1; i<cols; i++) f.write_c(", %d", grid->col_gap(i));
|
|
f.write_c(" };\n");
|
|
f.write_c("%s%s->col_gap(colgaps, %d);\n", f.indent(), var, cols);
|
|
}
|
|
}
|
|
|
|
void Grid_Node::write_code2(fld::io::Code_Writer& f) {
|
|
const char *var = name() ? name() : "o";
|
|
Fl_Grid* grid = (Fl_Grid*)o;
|
|
bool first_cell = true;
|
|
for (int i=0; i<grid->children(); i++) {
|
|
Fl_Widget *c = grid->child(i);
|
|
Fl_Grid::Cell *cell = grid->cell(c);
|
|
if (cell) {
|
|
if (first_cell) {
|
|
f.write_c("%sFl_Grid::Cell *cell = 0L;\n", f.indent());
|
|
first_cell = false;
|
|
}
|
|
f.write_c("%scell = %s->widget(%s->child(%d), %d, %d, %d, %d, %d);\n",
|
|
f.indent(), var, var, i, cell->row(), cell->col(),
|
|
cell->rowspan(), cell->colspan(), cell->align());
|
|
int min_w = 20, min_h = 20;
|
|
cell->minimum_size(&min_w, &min_h);
|
|
f.write_c("%sif (cell) cell->minimum_size(%d, %d);\n", f.indent(), min_w, min_h);
|
|
}
|
|
}
|
|
super::write_code2(f);
|
|
}
|
|
|
|
void Grid_Node::add_child(Node* a, Node* b) {
|
|
super::add_child(a, b);
|
|
Fl_Grid* grid = (Fl_Grid*)o;
|
|
grid->need_layout(1);
|
|
grid->redraw();
|
|
}
|
|
|
|
void Grid_Node::move_child(Node* a, Node* b) {
|
|
super::move_child(a, b);
|
|
Fl_Grid* grid = (Fl_Grid*)o;
|
|
grid->need_layout(1);
|
|
grid->redraw();
|
|
}
|
|
|
|
void Grid_Node::remove_child(Node* a) {
|
|
super::remove_child(a);
|
|
Fl_Grid* grid = (Fl_Grid*)o;
|
|
grid->need_layout(1);
|
|
grid->redraw();
|
|
}
|
|
|
|
/** Update the initial size of a child widget.
|
|
Fl_Grid keeps track of the size of children when they are first added. In
|
|
FLUID, users will want to resize children. So we need to trick Fl_Grid into
|
|
taking the new size as the initial size.
|
|
*/
|
|
void Grid_Node::child_resized(Widget_Node *child_type) {
|
|
Fl_Grid *grid = (Fl_Grid*)o;
|
|
Fl_Widget *child = child_type->o;
|
|
Fl_Grid::Cell *cell = grid->cell(child);
|
|
if (cell && ((cell->align()&FL_GRID_VERTICAL)==0)) {
|
|
int min_w = 0, min_h = 0;
|
|
cell->minimum_size(&min_w, &min_h);
|
|
cell->minimum_size(min_w, child->h());
|
|
}
|
|
if (cell && ((cell->align()&FL_GRID_HORIZONTAL)==0)) {
|
|
int min_w = 0, min_h = 0;
|
|
cell->minimum_size(&min_w, &min_h);
|
|
cell->minimum_size(child->w(), min_h);
|
|
}
|
|
// TODO: if the user resizes an FL_GRID_FILL widget, should we change the alignment?
|
|
}
|
|
|
|
/** Return the currently selected Grid widget if is a Grid Type. */
|
|
Fl_Grid *Grid_Node::selected() {
|
|
if (current_widget && current_widget->is_a(Type::Grid))
|
|
return ((Fl_Grid*)((Grid_Node*)current_widget)->o);
|
|
return nullptr;
|
|
}
|
|
|
|
/**
|
|
Insert a child widget into the cell at the x, y position inside the window.
|
|
/param[in] child
|
|
/param[in] x, y pixels from the top left of the window
|
|
*/
|
|
void Grid_Node::insert_child_at(Fl_Widget *child, int x, int y) {
|
|
Fl_Grid_Proxy *grid = (Fl_Grid_Proxy*)o;
|
|
int row = -1, col = -1, ml, mt, grg, gcg;
|
|
grid->margin(&ml, &mt, nullptr, nullptr);
|
|
grid->gap(&grg, &gcg);
|
|
int x0 = grid->x() + Fl::box_dx(grid->box()) + ml;
|
|
int y0 = grid->y() + Fl::box_dy(grid->box()) + mt;
|
|
|
|
for (int r = 0; r < grid->rows(); r++) {
|
|
if (y>y0) row = r;
|
|
int gap = grid->row_gap(r)>=0 ? grid->row_gap(r) : grg;
|
|
y0 += grid->computed_row_height(r);
|
|
y0 += gap;
|
|
}
|
|
|
|
for (int c = 0; c < grid->cols(); c++) {
|
|
if (x>x0) col = c;
|
|
int gap = grid->col_gap(c)>=0 ? grid->col_gap(c) : gcg;
|
|
x0 += grid->computed_col_width(c);
|
|
x0 += gap;
|
|
}
|
|
|
|
grid->move_cell(child, row, col, 2);
|
|
}
|
|
|
|
/**
|
|
Insert a child widget into the first new cell we can find .
|
|
|
|
There are many other possible strategies. How about inserting to the right
|
|
of the last added child. Also, what happens if the grid is full? Should
|
|
we add a new row at the bottom?
|
|
|
|
/param[in] child
|
|
*/
|
|
void Grid_Node::insert_child_at_next_free_cell(Fl_Widget *child) {
|
|
Fl_Grid_Proxy *grid = (Fl_Grid_Proxy*)o;
|
|
if (grid->cell(child)) return;
|
|
// The code below would insert the new widget after the last selected one, but
|
|
// unfortunately the current_widget is already invalid.
|
|
// if (current_widget && (current_widget->parent == this)) {
|
|
// Fl_Grid::Cell *current_cell = grid->any_cell(current_widget->o);
|
|
// if (current_cell) {
|
|
// r = current_cell->row();
|
|
// c = current_cell->col();
|
|
// }
|
|
// }
|
|
for (int r = 0; r < grid->rows(); r++) {
|
|
for (int c = 0; c < grid->cols(); c++) {
|
|
if (!grid->cell(r, c)) {
|
|
grid->move_cell(child, r, c);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
grid->layout(grid->rows() + 1, grid->cols());
|
|
grid->move_cell(child, grid->rows() - 1, 0);
|
|
}
|
|
|
|
/** Move cells around using the keyboard.
|
|
\note this fails if we have two children selected side by side and press 'right',
|
|
which will move the left child first, removing the right child from the
|
|
cell system. When trying to move the second child, it has no longer an
|
|
assigned row or column.
|
|
\param[in] child pointer to the child type
|
|
\param[in] key code of the last keypress when handling a FL_KEYBOARD event.
|
|
*/
|
|
void Grid_Node::keyboard_move_child(Widget_Node *child, int key) {
|
|
Fl_Grid_Proxy *grid = ((Fl_Grid_Proxy*)o);
|
|
Fl_Grid::Cell *cell = grid->any_cell(child->o);
|
|
if (!cell) return;
|
|
if (key == FL_Right) {
|
|
grid->move_cell(child->o, cell->row(), cell->col()+1, 2);
|
|
} else if (key == FL_Left) {
|
|
grid->move_cell(child->o, cell->row(), cell->col()-1, 2);
|
|
} else if (key == FL_Up) {
|
|
grid->move_cell(child->o, cell->row()-1, cell->col(), 2);
|
|
} else if (key == FL_Down) {
|
|
grid->move_cell(child->o, cell->row()+1, cell->col(), 2);
|
|
}
|
|
}
|
|
|
|
void Grid_Node::layout_widget() {
|
|
Fluid.proj.tree.allow_layout++;
|
|
((Fl_Grid*)o)->layout();
|
|
Fluid.proj.tree.allow_layout--;
|
|
}
|
|
|