non
/
ntk
mirror of https://github.com/original-male/ntk
1
0
Fork 0
Code Releases 2 Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
33 Commits
1 Branch
8.9MB
Tree: fb1bfecebf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fb1bfecebf'
${ noResults }
ntk/fluid/Fl_Type.cxx

1028 lines
28KB
Raw Blame History 

  1. //

  2. // "$Id: Fl_Type.cxx 8172 2011-01-03 08:28:38Z matt $"

  3. //

  4. // Widget type code for the Fast Light Tool Kit (FLTK).

  5. //

  6. // Each object described by Fluid is one of these objects.  They

  7. // are all stored in a double-linked list.

  8. //

  9. // They "type" of the object is covered by the virtual functions.

  10. // There will probably be a lot of these virtual functions.

  11. //

  12. // The type browser is also a list of these objects, but they

  13. // are "factory" instances, not "real" ones.  These objects exist

  14. // only so the "make" method can be called on them.  They are

  15. // not in the linked list and are not written to files or

  16. // copied or otherwise examined.

  17. //

  18. // Copyright 1998-2010 by Bill Spitzak and others.

  19. //

  20. // This library is free software; you can redistribute it and/or

  21. // modify it under the terms of the GNU Library General Public

  22. // License as published by the Free Software Foundation; either

  23. // version 2 of the License, or (at your option) any later version.

  24. //

  25. // This library is distributed in the hope that it will be useful,

  26. // but WITHOUT ANY WARRANTY; without even the implied warranty of

  27. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  28. // Library General Public License for more details.

  29. //

  30. // You should have received a copy of the GNU Library General Public

  31. // License along with this library; if not, write to the Free Software

  32. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

  33. // USA.

  34. //

  35. // Please report all bugs and problems on the following page:

  36. //

  37. //     http://www.fltk.org/str.php

  38. //

  39. 

  40. #include <FL/Fl.H>

  41. #include <FL/Fl_Browser_.H>

  42. #include <FL/fl_draw.H>

  43. #include <stdlib.h>

  44. #include "../src/flstring.h"

  45. #include <stdio.h>

  46. 

  47. #include "Fl_Type.h"

  48. #include "undo.h"

  49. 

  50. #include <FL/Fl_Pixmap.H>

  51. #include "pixmaps/lock.xpm"

  52. #include "pixmaps/protected.xpm"

  53. //#include "pixmaps/unlock.xpm"

  54. 

  55. static Fl_Pixmap	lock_pixmap(lock_xpm);

  56. static Fl_Pixmap	protected_pixmap(protected_xpm);

  57. //static Fl_Pixmap	unlock_pixmap(unlock_xpm);

  58. 

  59. #include "pixmaps/flWindow.xpm"

  60. #include "pixmaps/flButton.xpm"

  61. #include "pixmaps/flCheckButton.xpm"

  62. #include "pixmaps/flRoundButton.xpm"

  63. #include "pixmaps/flBox.xpm"

  64. #include "pixmaps/flGroup.xpm"

  65. #include "pixmaps/flFunction.xpm"

  66. #include "pixmaps/flCode.xpm"

  67. #include "pixmaps/flCodeBlock.xpm"

  68. #include "pixmaps/flComment.xpm"

  69. #include "pixmaps/flData.xpm"

  70. #include "pixmaps/flDeclaration.xpm"

  71. #include "pixmaps/flDeclarationBlock.xpm"

  72. #include "pixmaps/flClass.xpm"

  73. #include "pixmaps/flTabs.xpm"

  74. #include "pixmaps/flInput.xpm"

  75. #include "pixmaps/flChoice.xpm"

  76. #include "pixmaps/flMenuitem.xpm"

  77. #include "pixmaps/flMenubar.xpm"

  78. #include "pixmaps/flSubmenu.xpm"

  79. #include "pixmaps/flScroll.xpm"

  80. #include "pixmaps/flTile.xpm"

  81. #include "pixmaps/flWizard.xpm"

  82. #include "pixmaps/flPack.xpm"

  83. #include "pixmaps/flReturnButton.xpm"

  84. #include "pixmaps/flLightButton.xpm"

  85. #include "pixmaps/flRepeatButton.xpm"

  86. #include "pixmaps/flMenuButton.xpm"

  87. #include "pixmaps/flOutput.xpm"

  88. #include "pixmaps/flTextDisplay.xpm"

  89. #include "pixmaps/flTextEdit.xpm"

  90. #include "pixmaps/flFileInput.xpm"

  91. #include "pixmaps/flBrowser.xpm"

  92. #include "pixmaps/flCheckBrowser.xpm"

  93. #include "pixmaps/flFileBrowser.xpm"

  94. #include "pixmaps/flHelp.xpm"

  95. #include "pixmaps/flProgress.xpm"

  96. #include "pixmaps/flSlider.xpm"

  97. #include "pixmaps/flScrollBar.xpm"

  98. #include "pixmaps/flValueSlider.xpm"

  99. #include "pixmaps/flAdjuster.xpm"

  100. #include "pixmaps/flCounter.xpm"

  101. #include "pixmaps/flDial.xpm"

  102. #include "pixmaps/flRoller.xpm"

  103. #include "pixmaps/flValueInput.xpm"

  104. #include "pixmaps/flValueOutput.xpm"

  105. #include "pixmaps/flSpinner.xpm"

  106. #include "pixmaps/flWidgetClass.xpm"

  107. #include "pixmaps/flTree.xpm"

  108. #include "pixmaps/flTable.xpm"

  109. 

  110. static Fl_Pixmap	window_pixmap(flWindow_xpm);

  111. static Fl_Pixmap	button_pixmap(flButton_xpm);

  112. static Fl_Pixmap	checkbutton_pixmap(flCheckButton_xpm);

  113. static Fl_Pixmap	roundbutton_pixmap(flRoundButton_xpm);

  114. static Fl_Pixmap	box_pixmap(flBox_xpm);

  115. static Fl_Pixmap	group_pixmap(flGroup_xpm);

  116. static Fl_Pixmap	function_pixmap(flFunction_xpm);

  117. static Fl_Pixmap	code_pixmap(flCode_xpm);

  118. static Fl_Pixmap	codeblock_pixmap(flCodeBlock_xpm);

  119. static Fl_Pixmap	comment_pixmap(flComment_xpm);

  120. static Fl_Pixmap	declaration_pixmap(flDeclaration_xpm);

  121. static Fl_Pixmap	declarationblock_pixmap(flDeclarationBlock_xpm);

  122. static Fl_Pixmap	class_pixmap(flClass_xpm);

  123. static Fl_Pixmap	tabs_pixmap(flTabs_xpm);

  124. static Fl_Pixmap	input_pixmap(flInput_xpm);

  125. static Fl_Pixmap	choice_pixmap(flChoice_xpm);

  126. static Fl_Pixmap	menuitem_pixmap(flMenuitem_xpm);

  127. static Fl_Pixmap	menubar_pixmap(flMenubar_xpm);

  128. static Fl_Pixmap	submenu_pixmap(flSubmenu_xpm);

  129. static Fl_Pixmap	scroll_pixmap(flScroll_xpm);

  130. static Fl_Pixmap	tile_pixmap(flTile_xpm);

  131. static Fl_Pixmap	wizard_pixmap(flWizard_xpm);

  132. static Fl_Pixmap	pack_pixmap(flPack_xpm);

  133. static Fl_Pixmap	returnbutton_pixmap(flReturnButton_xpm);

  134. static Fl_Pixmap	lightbutton_pixmap(flLightButton_xpm);

  135. static Fl_Pixmap	repeatbutton_pixmap(flRepeatButton_xpm);

  136. static Fl_Pixmap	menubutton_pixmap(flMenuButton_xpm);

  137. static Fl_Pixmap	output_pixmap(flOutput_xpm);

  138. static Fl_Pixmap	textdisplay_pixmap(flTextDisplay_xpm);

  139. static Fl_Pixmap	textedit_pixmap(flTextEdit_xpm);

  140. static Fl_Pixmap	fileinput_pixmap(flFileInput_xpm);

  141. static Fl_Pixmap	browser_pixmap(flBrowser_xpm);

  142. static Fl_Pixmap	checkbrowser_pixmap(flCheckBrowser_xpm);

  143. static Fl_Pixmap	filebrowser_pixmap(flFileBrowser_xpm);

  144. static Fl_Pixmap	help_pixmap(flHelp_xpm);

  145. static Fl_Pixmap	progress_pixmap(flProgress_xpm);

  146. static Fl_Pixmap	slider_pixmap(flSlider_xpm);

  147. static Fl_Pixmap	scrollbar_pixmap(flScrollBar_xpm);

  148. static Fl_Pixmap	valueslider_pixmap(flValueSlider_xpm);

  149. static Fl_Pixmap	adjuster_pixmap(flAdjuster_xpm);

  150. static Fl_Pixmap	counter_pixmap(flCounter_xpm);

  151. static Fl_Pixmap	dial_pixmap(flDial_xpm);

  152. static Fl_Pixmap	roller_pixmap(flRoller_xpm);

  153. static Fl_Pixmap	valueinput_pixmap(flValueInput_xpm);

  154. static Fl_Pixmap	valueoutput_pixmap(flValueOutput_xpm);

  155. static Fl_Pixmap	spinner_pixmap(flSpinner_xpm);

  156. static Fl_Pixmap	widgetclass_pixmap(flWidgetClass_xpm);

  157. static Fl_Pixmap	data_pixmap(flData_xpm);

  158. static Fl_Pixmap	tree_pixmap(flTree_xpm);

  159. static Fl_Pixmap	table_pixmap(flTable_xpm);

  160. 

  161. Fl_Pixmap *pixmap[] = { 0, &window_pixmap, &button_pixmap, &checkbutton_pixmap, &roundbutton_pixmap, /* 0..4 */

  162.  &box_pixmap, &group_pixmap, &function_pixmap, &code_pixmap, &codeblock_pixmap, &declaration_pixmap, /* 5..10 */ 

  163.  &declarationblock_pixmap, &class_pixmap, &tabs_pixmap, &input_pixmap, &choice_pixmap,               /* 11..15 */

  164.  &menuitem_pixmap, &menubar_pixmap, &submenu_pixmap, &scroll_pixmap, &tile_pixmap, &wizard_pixmap,   /* 16..21 */

  165.  &pack_pixmap, &returnbutton_pixmap, &lightbutton_pixmap, &repeatbutton_pixmap, &menubutton_pixmap,  /* 22..26 */

  166.  &output_pixmap, &textdisplay_pixmap, &textedit_pixmap, &fileinput_pixmap, &browser_pixmap,          /* 27..32 */

  167.  &checkbrowser_pixmap, &filebrowser_pixmap, NULL, &help_pixmap, &progress_pixmap,	     /* 33..36 */

  168.  &slider_pixmap, &scrollbar_pixmap, &valueslider_pixmap, &adjuster_pixmap, &counter_pixmap,          /* 37..41 */

  169.  &dial_pixmap, &roller_pixmap, &valueinput_pixmap, &valueoutput_pixmap, &comment_pixmap,             /* 42..46 */

  170.  &spinner_pixmap, &widgetclass_pixmap, &data_pixmap, &tree_pixmap, &table_pixmap };                  /* 47..51 */

  171. 

  172. extern int show_comments;

  173. 

  174. ////////////////////////////////////////////////////////////////

  175. 

  176. class Widget_Browser : public Fl_Browser_ {

  177.   friend class Fl_Type;

  178. 

  179.   // required routines for Fl_Browser_ subclass:

  180.   void *item_first() const ;

  181.   void *item_next(void *) const ;

  182.   void *item_prev(void *) const ;

  183.   int item_selected(void *) const ;

  184.   void item_select(void *,int);

  185.   int item_width(void *) const ;

  186.   int item_height(void *) const ;

  187.   void item_draw(void *,int,int,int,int) const ;

  188.   int incr_height() const ;

  189. 

  190. public:	

  191. 

  192.   int handle(int);

  193.   void callback();

  194.   Widget_Browser(int,int,int,int,const char * =0);

  195. };

  196. 

  197. static Widget_Browser *widget_browser;

  198. Fl_Widget *make_widget_browser(int x,int y,int w,int h) {

  199.   return (widget_browser = new Widget_Browser(x,y,w,h));

  200. }

  201. 

  202. void select(Fl_Type *o, int v) {

  203.   widget_browser->select(o,v,1);

  204.   //  Fl_Type::current = o;

  205. }

  206. 

  207. void select_only(Fl_Type *o) {

  208.   widget_browser->select_only(o,1);

  209. }

  210. 

  211. void deselect() {

  212.   widget_browser->deselect();

  213.   //Fl_Type::current = 0; // this breaks the paste & merge functions

  214. }

  215. 

  216. Fl_Type *Fl_Type::first;

  217. Fl_Type *Fl_Type::last;

  218. 

  219. static void Widget_Browser_callback(Fl_Widget *o,void *) {

  220.   ((Widget_Browser *)o)->callback();

  221. }

  222. 

  223. Widget_Browser::Widget_Browser(int X,int Y,int W,int H,const char*l)

  224. : Fl_Browser_(X,Y,W,H,l) {

  225.   type(FL_MULTI_BROWSER);

  226.   Fl_Widget::callback(Widget_Browser_callback);

  227.   when(FL_WHEN_RELEASE);

  228. }

  229. 

  230. void *Widget_Browser::item_first() const {return Fl_Type::first;}

  231. 

  232. void *Widget_Browser::item_next(void *l) const {return ((Fl_Type*)l)->next;}

  233. 

  234. void *Widget_Browser::item_prev(void *l) const {return ((Fl_Type*)l)->prev;}

  235. 

  236. int Widget_Browser::item_selected(void *l) const {return ((Fl_Type*)l)->new_selected;}

  237. 

  238. void Widget_Browser::item_select(void *l,int v) {((Fl_Type*)l)->new_selected = v;}

  239. 

  240. int Widget_Browser::item_height(void *l) const {

  241.   Fl_Type *t = (Fl_Type*)l;

  242.   if (t->visible) {

  243.     if (show_comments && t->comment())

  244.       return textsize()*2+1;

  245.     else

  246.       return textsize()+2;

  247.   } else {

  248.     return 0;

  249.   }

  250.   return ((Fl_Type *)l)->visible ? textsize()+2 : 0;

  251. }

  252. 

  253. int Widget_Browser::incr_height() const {return textsize()+2;}

  254. 

  255. static Fl_Type* pushedtitle;

  256. 

  257. // Generate a descriptive text for this item, to put in browser & window titles

  258. const char* Fl_Type::title() {

  259.   const char* c = name(); if (c) return c;

  260.   return type_name();

  261. }

  262. 

  263. extern const char* subclassname(Fl_Type*);

  264. 

  265. void Widget_Browser::item_draw(void *v, int X, int Y, int, int) const {

  266.   Fl_Type *l = (Fl_Type *)v;

  267.   X += 3 + 18 + l->level * 12;

  268.   int comment_incr = 0;

  269.   if (show_comments && l->comment()) {

  270.     char buf[82], *d = buf;

  271.     const char *s = l->comment();

  272.     for (int i=0; i<80; i++) {

  273.       char c = *s++;

  274.       if (c==0 || c=='\n') break;

  275.       *d++ = c;

  276.     }

  277.     *d = 0;

  278.     comment_incr = textsize()-1;

  279.     if (l->new_selected) fl_color(fl_contrast(FL_DARK_GREEN,FL_SELECTION_COLOR));

  280.     else fl_color(fl_contrast(FL_DARK_GREEN,color()));

  281.     fl_font(textfont()+FL_ITALIC, textsize()-2);

  282.     fl_draw(buf, (l->is_parent())?X+12:X, Y+12);

  283.     Y += comment_incr/2;

  284.     comment_incr -= comment_incr/2;

  285.   }

  286.   if (l->new_selected) fl_color(fl_contrast(FL_FOREGROUND_COLOR,FL_SELECTION_COLOR));

  287.   else fl_color(FL_FOREGROUND_COLOR);

  288.   Fl_Pixmap *pm = pixmap[l->pixmapID()];

  289.   if (pm) pm->draw(X-18, Y);

  290.   switch (l->is_public()) {

  291.     case 0: lock_pixmap.draw(X - 17, Y); break;

  292.     case 2: protected_pixmap.draw(X - 17, Y); break;

  293.   }

  294.   if (l->is_parent()) {

  295.     if (!l->next || l->next->level <= l->level) {

  296.       if (l->open_!=(l==pushedtitle)) {

  297.         fl_loop(X,Y+7,X+5,Y+12,X+10,Y+7);

  298.       } else {

  299.         fl_loop(X+2,Y+2,X+7,Y+7,X+2,Y+12);

  300.       }

  301.     } else {

  302.       if (l->open_!=(l==pushedtitle)) {

  303.         fl_polygon(X,Y+7,X+5,Y+12,X+10,Y+7);

  304.       } else {

  305.         fl_polygon(X+2,Y+2,X+7,Y+7,X+2,Y+12);

  306.       }

  307.     }

  308.     X += 10;

  309.   }

  310.   Y += comment_incr;

  311.   if (l->is_widget() || l->is_class()) {

  312.     const char* c = subclassname(l);

  313.     if (!strncmp(c,"Fl_",3)) c += 3;

  314.     fl_font(textfont(), textsize());

  315.     fl_draw(c, X, Y+13);

  316.     X += int(fl_width(c)+fl_width('n'));

  317.     c = l->name();

  318.     if (c) {

  319.       fl_font(textfont()|FL_BOLD, textsize());

  320.       fl_draw(c, X, Y+13);

  321.     } else if ((c=l->label())) {

  322.       char buf[50]; char* p = buf;

  323.       *p++ = '"';

  324.       for (int i = 20; i--;) {

  325.         if (! (*c & -32)) break;

  326.         *p++ = *c++;

  327.       }

  328.       if (*c) {strcpy(p,"..."); p+=3;}

  329.       *p++ = '"';

  330.       *p = 0;

  331.       fl_draw(buf, X, Y+13);

  332.     }

  333.   } else {

  334.     const char* c = l->title();

  335.     char buf[60]; char* p = buf;

  336.     for (int i = 55; i--;) {

  337.       if (! (*c & -32)) break;

  338.       *p++ = *c++;

  339.     }

  340.     if (*c) {strcpy(p,"..."); p+=3;}

  341.     *p = 0;

  342.     fl_font(textfont() | (l->is_code_block() && (l->level==0 || l->parent->is_class())?0:FL_BOLD), textsize());

  343.     fl_draw(buf, X, Y+13);

  344.   }

  345. }

  346. 

  347. int Widget_Browser::item_width(void *v) const {

  348.   Fl_Type *l = (Fl_Type *)v;

  349. 

  350.   if (!l->visible) return 0;

  351. 

  352.   int W = 3 + 16 + 18 + l->level*10;

  353.   if (l->is_parent()) W += 10;

  354. 

  355.   if (l->is_widget() || l->is_class()) {

  356.     const char* c = l->type_name();

  357.     if (!strncmp(c,"Fl_",3)) c += 3;

  358.     fl_font(textfont(), textsize());

  359.     W += int(fl_width(c) + fl_width('n'));

  360.     c = l->name();

  361.     if (c) {

  362.       fl_font(textfont()|FL_BOLD, textsize());

  363.       W += int(fl_width(c));

  364.     } else if ((c=l->label())) {

  365.       char buf[50]; char* p = buf;

  366.       *p++ = '"';

  367.       for (int i = 20; i--;) {

  368. 	if (! (*c & -32)) break;

  369. 	*p++ = *c++;

  370.       }

  371.       if (*c) {strcpy(p,"..."); p+=3;}

  372.       *p++ = '"';

  373.       *p = 0;

  374.       W += int(fl_width(buf));

  375.     }

  376.   } else {

  377.     const char* c = l->title();

  378.     char buf[60]; char* p = buf;

  379.     for (int i = 55; i--;) {

  380.       if (! (*c & -32)) break;

  381.       *p++ = *c++;

  382.     }

  383.     if (*c) {strcpy(p,"..."); p+=3;}

  384.     *p = 0;

  385.     fl_font(textfont() | (l->is_code_block() && (l->level==0 || l->parent->is_class())?0:FL_BOLD), textsize());

  386.     W += int(fl_width(buf));

  387.   }

  388. 

  389.   return W;

  390. }

  391. 

  392. void redraw_browser() {

  393.   widget_browser->redraw();

  394. }

  395. 

  396. void Widget_Browser::callback() {

  397.   selection_changed((Fl_Type*)selection());

  398. }

  399. 

  400. int Widget_Browser::handle(int e) {

  401.   static Fl_Type *title;

  402.   Fl_Type *l;

  403.   int X,Y,W,H; bbox(X,Y,W,H);

  404.   switch (e) {

  405.   case FL_PUSH:

  406.     if (!Fl::event_inside(X,Y,W,H)) break;

  407.     l = (Fl_Type*)find_item(Fl::event_y());

  408.     if (l) {

  409.       X += 12*l->level + 18 - hposition();

  410.       if (l->is_parent() && Fl::event_x()>X && Fl::event_x()<X+13) {

  411. 	title = pushedtitle = l;

  412. 	redraw_line(l);

  413. 	return 1;

  414.       }

  415.     }

  416.     break;

  417.   case FL_DRAG:

  418.     if (!title) break;

  419.     l = (Fl_Type*)find_item(Fl::event_y());

  420.     if (l) {

  421.       X += 12*l->level + 18 - hposition();

  422.       if (l->is_parent() && Fl::event_x()>X && Fl::event_x()<X+13) ;

  423.       else l = 0;

  424.     }

  425.     if (l != pushedtitle) {

  426.       if (pushedtitle) redraw_line(pushedtitle);

  427.       if (l) redraw_line(l);

  428.       pushedtitle = l;

  429.     }

  430.     return 1;

  431.   case FL_RELEASE:

  432.     if (!title) {

  433.       l = (Fl_Type*)find_item(Fl::event_y());

  434.       if (l && l->new_selected && (Fl::event_clicks() || Fl::event_state(FL_CTRL)))

  435. 	l->open();

  436.       break;

  437.     }

  438.     l = pushedtitle;

  439.     title = pushedtitle = 0;

  440.     if (l) {

  441.       if (l->open_) {

  442. 	l->open_ = 0;

  443. 	for (Fl_Type*k = l->next; k&&k->level>l->level; k = k->next)

  444. 	  k->visible = 0;

  445.       } else {

  446. 	l->open_ = 1;

  447. 	for (Fl_Type*k=l->next; k&&k->level>l->level;) {

  448. 	  k->visible = 1;

  449. 	  if (k->is_parent() && !k->open_) {

  450. 	    Fl_Type *j;

  451. 	    for (j = k->next; j && j->level>k->level; j = j->next);

  452. 	    k = j;

  453. 	  } else

  454. 	    k = k->next;

  455. 	}

  456.       }

  457.       redraw();

  458.     }

  459.     return 1;

  460.   }

  461.   return Fl_Browser_::handle(e);

  462. }

  463. 

  464. Fl_Type::Fl_Type() {

  465.   factory = 0;

  466.   parent = 0;

  467.   next = prev = 0;

  468.   selected = new_selected = 0;

  469.   visible = 0;

  470.   name_ = 0;

  471.   label_ = 0;

  472.   user_data_ = 0;

  473.   user_data_type_ = 0;

  474.   callback_ = 0;

  475.   comment_ = 0;

  476.   rtti = 0;

  477.   level = 0;

  478.   code_position = header_position = -1;

  479.   code_position_end = header_position_end = -1;

  480. }

  481. 

  482. static void fixvisible(Fl_Type *p) {

  483.   Fl_Type *t = p;

  484.   for (;;) {

  485.     if (t->parent) t->visible = t->parent->visible && t->parent->open_;

  486.     else t->visible = 1;

  487.     t = t->next;

  488.     if (!t || t->level <= p->level) break;

  489.   }

  490. }

  491. 

  492. // turn a click at x,y on this into the actual picked object:

  493. Fl_Type* Fl_Type::click_test(int,int) {return 0;}

  494. void Fl_Type::add_child(Fl_Type*, Fl_Type*) {}

  495. void Fl_Type::move_child(Fl_Type*, Fl_Type*) {}

  496. void Fl_Type::remove_child(Fl_Type*) {}

  497. 

  498. // add a list of widgets as a new child of p:

  499. void Fl_Type::add(Fl_Type *p) {

  500.   if (p && parent == p) return;

  501.   undo_checkpoint();

  502.   parent = p;

  503.   Fl_Type *end = this;

  504.   while (end->next) end = end->next;

  505.   Fl_Type *q;

  506.   int newlevel;

  507.   if (p) {

  508.     for (q = p->next; q && q->level > p->level; q = q->next);

  509.     newlevel = p->level+1;

  510.   } else {

  511.     q = 0;

  512.     newlevel = 0;

  513.   }

  514.   for (Fl_Type *t = this->next; t; t = t->next) t->level += (newlevel-level);

  515.   level = newlevel;

  516.   if (q) {

  517.     prev = q->prev;

  518.     prev->next = this;

  519.     q->prev = end;

  520.     end->next = q;

  521.   } else if (first) {

  522.     prev = last;

  523.     prev->next = this;

  524.     end->next = 0;

  525.     last = end;

  526.   } else {

  527.     first = this;

  528.     last = end;

  529.     prev = end->next = 0;

  530.   }

  531.   if (p) p->add_child(this,0);

  532.   open_ = 1;

  533.   fixvisible(this);

  534.   set_modflag(1);

  535.   widget_browser->redraw();

  536. }

  537. 

  538. // add to a parent before another widget:

  539. void Fl_Type::insert(Fl_Type *g) {

  540.   Fl_Type *end = this;

  541.   while (end->next) end = end->next;

  542.   parent = g->parent;

  543.   int newlevel = g->level;

  544.   visible = g->visible;

  545.   for (Fl_Type *t = this->next; t; t = t->next) t->level += newlevel-level;

  546.   level = newlevel;

  547.   prev = g->prev;

  548.   if (prev) prev->next = this; else first = this;

  549.   end->next = g;

  550.   g->prev = end;

  551.   fixvisible(this);

  552.   if (parent) parent->add_child(this, g);

  553.   widget_browser->redraw();

  554. }

  555. 

  556. // Return message number for I18N...

  557. int

  558. Fl_Type::msgnum() {

  559.   int		count;

  560.   Fl_Type	*p;

  561. 

  562.   for (count = 0, p = this; p;) {

  563.     if (p->label()) count ++;

  564.     if (p != this && p->is_widget() && ((Fl_Widget_Type *)p)->tooltip()) count ++;

  565. 

  566.     if (p->prev) p = p->prev;

  567.     else p = p->parent;

  568.   }

  569. 

  570.   return count;

  571. }

  572. 

  573. 

  574. // delete from parent:

  575. Fl_Type *Fl_Type::remove() {

  576.   Fl_Type *end = this;

  577.   for (;;) {

  578.     if (!end->next || end->next->level <= level) break;

  579.     end = end->next;

  580.   }

  581.   if (prev) prev->next = end->next;

  582.   else first = end->next;

  583.   if (end->next) end->next->prev = prev;

  584.   else last = prev;

  585.   Fl_Type *r = end->next;

  586.   prev = end->next = 0;

  587.   if (parent) parent->remove_child(this);

  588.   parent = 0;

  589.   widget_browser->redraw();

  590.   selection_changed(0);

  591.   return r;

  592. }

  593. 

  594. // update a string member:

  595. int storestring(const char *n, const char * & p, int nostrip) {

  596.   if (n == p) return 0;

  597.   undo_checkpoint();

  598.   int length = 0;

  599.   if (n) { // see if blank, strip leading & trailing blanks

  600.     if (!nostrip) while (isspace(*n)) n++;

  601.     const char *e = n + strlen(n);

  602.     if (!nostrip) while (e > n && isspace(*(e-1))) e--;

  603.     length = e-n;

  604.     if (!length) n = 0;

  605.   }    

  606.   if (n == p) return 0;

  607.   if (n && p && !strncmp(n,p,length) && !p[length]) return 0;

  608.   if (p) free((void *)p);

  609.   if (!n || !*n) {

  610.     p = 0;

  611.   } else {

  612.     char *q = (char *)malloc(length+1);

  613.     strlcpy(q,n,length+1);

  614.     p = q;

  615.   }

  616.   set_modflag(1);

  617.   return 1;

  618. }

  619. 

  620. void Fl_Type::name(const char *n) {

  621.   int nostrip = is_comment();

  622.   if (storestring(n,name_,nostrip)) {

  623.     if (visible) widget_browser->redraw();

  624.   }

  625. }

  626. 

  627. void Fl_Type::label(const char *n) {

  628.   if (storestring(n,label_,1)) {

  629.     setlabel(label_);

  630.     if (visible && !name_) widget_browser->redraw();

  631.   }

  632. }

  633. 

  634. void Fl_Type::callback(const char *n) {

  635.   storestring(n,callback_);

  636. }

  637. 

  638. void Fl_Type::user_data(const char *n) {

  639.   storestring(n,user_data_);

  640. }

  641. 

  642. void Fl_Type::user_data_type(const char *n) {

  643.   storestring(n,user_data_type_);

  644. }

  645. 

  646. void Fl_Type::comment(const char *n) {

  647.   storestring(n, comment_, 1);

  648. }

  649. 

  650. void Fl_Type::open() {

  651.   printf("Open of '%s' is not yet implemented\n",type_name());

  652. }

  653. 

  654. void Fl_Type::setlabel(const char *) {}

  655. 

  656. Fl_Type::~Fl_Type() {

  657.   // warning: destructor only works for widgets that have been add()ed.

  658.   if (widget_browser) widget_browser->deleting(this);

  659.   if (prev) prev->next = next; else first = next;

  660.   if (next) next->prev = prev; else last = prev;

  661.   if (current == this) current = 0;

  662.   if (parent) parent->remove_child(this);

  663.   if (name_) free((void*)name_);

  664.   if (label_) free((void*)label_);

  665.   if (callback_) free((void*)callback_);

  666.   if (user_data_) free((void*)user_data_);

  667.   if (user_data_type_) free((void*)user_data_type_);

  668.   if (comment_) free((void*)comment_);

  669. }

  670. 

  671. int Fl_Type::is_parent() const {return 0;}

  672. int Fl_Type::is_widget() const {return 0;}

  673. int Fl_Type::is_valuator() const {return 0;}

  674. int Fl_Type::is_spinner() const {return 0;}

  675. int Fl_Type::is_button() const {return 0;}

  676. int Fl_Type::is_input() const {return 0;}

  677. int Fl_Type::is_value_input() const {return 0;}

  678. int Fl_Type::is_text_display() const {return 0;}

  679. int Fl_Type::is_menu_item() const {return 0;}

  680. int Fl_Type::is_menu_button() const {return 0;}

  681. int Fl_Type::is_group() const {return 0;}

  682. int Fl_Type::is_window() const {return 0;}

  683. int Fl_Type::is_code_block() const {return 0;}

  684. int Fl_Type::is_decl_block() const {return 0;}

  685. int Fl_Type::is_comment() const {return 0;}

  686. int Fl_Type::is_class() const {return 0;}

  687. int Fl_Type::is_public() const {return 1;}

  688. 

  689. int Fl_Code_Type::is_public()const { return -1; }

  690. int Fl_CodeBlock_Type::is_public()const { return -1; }

  691. 

  692. 

  693. ////////////////////////////////////////////////////////////////

  694. 

  695. Fl_Type *in_this_only; // set if menu popped-up in window

  696. 

  697. void select_all_cb(Fl_Widget *,void *) {

  698.   Fl_Type *p = Fl_Type::current ? Fl_Type::current->parent : 0;

  699.   if (in_this_only) {

  700.     Fl_Type *t = p;

  701.     for (; t && t != in_this_only; t = t->parent);

  702.     if (t != in_this_only) p = in_this_only;

  703.   }

  704.   for (;;) {

  705.     if (p) {

  706.       int foundany = 0;

  707.       for (Fl_Type *t = p->next; t && t->level>p->level; t = t->next) {

  708. 	if (!t->new_selected) {widget_browser->select(t,1,0); foundany = 1;}

  709.       }

  710.       if (foundany) break;

  711.       p = p->parent;

  712.     } else {

  713.       for (Fl_Type *t = Fl_Type::first; t; t = t->next)

  714. 	widget_browser->select(t,1,0);

  715.       break;

  716.     }

  717.   }

  718.   selection_changed(p);

  719. }

  720. 

  721. void select_none_cb(Fl_Widget *,void *) {

  722.   Fl_Type *p = Fl_Type::current ? Fl_Type::current->parent : 0;

  723.   if (in_this_only) {

  724.     Fl_Type *t = p;

  725.     for (; t && t != in_this_only; t = t->parent);

  726.     if (t != in_this_only) p = in_this_only;

  727.   }

  728.   for (;;) {

  729.     if (p) {

  730.       int foundany = 0;

  731.       for (Fl_Type *t = p->next; t && t->level>p->level; t = t->next) {

  732. 	if (t->new_selected) {widget_browser->select(t,0,0); foundany = 1;}

  733.       }

  734.       if (foundany) break;

  735.       p = p->parent;

  736.     } else {

  737.       for (Fl_Type *t = Fl_Type::first; t; t = t->next)

  738. 	widget_browser->select(t,0,0);

  739.       break;

  740.     }

  741.   }

  742.   selection_changed(p);

  743. }

  744. 

  745. static void delete_children(Fl_Type *p) {

  746.   Fl_Type *f;

  747.   for (f = p; f && f->next && f->next->level > p->level; f = f->next);

  748.   for (; f != p; ) {

  749.     Fl_Type *g = f->prev;

  750.     delete f;

  751.     f = g;

  752.   }

  753. }

  754. 

  755. void delete_all(int selected_only) {

  756.   for (Fl_Type *f = Fl_Type::first; f;) {

  757.     if (f->selected || !selected_only) {

  758.       delete_children(f);

  759.       Fl_Type *g = f->next;

  760.       delete f;

  761.       f = g;

  762.     } else f = f->next;

  763.   }

  764.   if(!selected_only) {

  765. 		include_H_from_C=1;

  766. 		use_FL_COMMAND=0;

  767. 	}

  768. 

  769.   selection_changed(0);

  770. }

  771. 

  772. // move f (and it's children) into list before g:

  773. // returns pointer to whatever is after f & children

  774. void Fl_Type::move_before(Fl_Type* g) {

  775.   if (level != g->level) printf("move_before levels don't match! %d %d\n",

  776. 				level, g->level);

  777.   Fl_Type* n;

  778.   for (n = next; n && n->level > level; n = n->next);

  779.   if (n == g) return;

  780.   Fl_Type *l = n ? n->prev : Fl_Type::last;

  781.   prev->next = n;

  782.   if (n) n->prev = prev; else Fl_Type::last = prev;

  783.   prev = g->prev;

  784.   l->next = g;

  785.   if (prev) prev->next = this; else Fl_Type::first = this;

  786.   g->prev = l;

  787.   if (parent && is_widget()) parent->move_child(this,g);

  788.   widget_browser->inserting(g, this);

  789.   widget_browser->display(this);

  790.   widget_browser->redraw();

  791. }

  792. 

  793. // move selected widgets in their parent's list:

  794. void earlier_cb(Fl_Widget*,void*) {

  795.   Fl_Type *f;

  796.   int mod = 0;

  797.   for (f = Fl_Type::first; f; ) {

  798.     Fl_Type* nxt = f->next;

  799.     if (f->selected) {

  800.       Fl_Type* g;

  801.       for (g = f->prev; g && g->level > f->level; g = g->prev);

  802.       if (g && g->level == f->level && !g->selected) {

  803.         f->move_before(g);

  804.         mod = 1;

  805.       }

  806.     }

  807.     f = nxt;

  808.   }

  809.   if (mod) set_modflag(1);

  810. }

  811. 

  812. void later_cb(Fl_Widget*,void*) {

  813.   Fl_Type *f;

  814.   int mod = 0;

  815.   for (f = Fl_Type::last; f; ) {

  816.     Fl_Type* prv = f->prev;

  817.     if (f->selected) {

  818.       Fl_Type* g;

  819.       for (g = f->next; g && g->level > f->level; g = g->next);

  820.       if (g && g->level == f->level && !g->selected) {

  821.         g->move_before(f);

  822.         mod = 1;

  823.       }

  824.     }

  825.     f = prv;

  826.   }

  827.   if (mod) set_modflag(1);

  828. }

  829. 

  830. ////////////////////////////////////////////////////////////////

  831. 

  832. // write a widget and all it's children:

  833. void Fl_Type::write() {

  834.     write_indent(level);

  835.     write_word(type_name());

  836.     

  837.     if (is_class()) {

  838.       const char * p = 	((Fl_Class_Type*)this)->prefix();

  839.       if (p &&	strlen(p))

  840.         write_word(p);

  841.     }

  842. 

  843.     write_word(name());

  844.     write_open(level);

  845.     write_properties();

  846.     write_close(level);

  847.     if (!is_parent()) return;

  848.     // now do children:

  849.     write_open(level);

  850.     Fl_Type *child;

  851.     for (child = next; child && child->level > level; child = child->next)

  852. 	if (child->level == level+1) child->write();

  853.     write_close(level);

  854. }

  855. 

  856. void Fl_Type::write_properties() {

  857.   // repeat this for each attribute:

  858.   if (label()) {

  859.     write_indent(level+1);

  860.     write_word("label");

  861.     write_word(label());

  862.   }

  863.   if (user_data()) {

  864.     write_indent(level+1);

  865.     write_word("user_data");

  866.     write_word(user_data());

  867.   }

  868.   if (user_data_type()) {

  869.     write_word("user_data_type");

  870.     write_word(user_data_type());

  871.   }

  872.   if (callback()) {

  873.     write_indent(level+1);

  874.     write_word("callback");

  875.     write_word(callback());

  876.   }

  877.   if (comment()) {

  878.     write_indent(level+1);

  879.     write_word("comment");

  880.     write_word(comment());

  881.   }

  882.   if (is_parent() && open_) write_word("open");

  883.   if (selected) write_word("selected");

  884. }

  885. 

  886. void Fl_Type::read_property(const char *c) {

  887.   if (!strcmp(c,"label"))

  888.     label(read_word());

  889.   else if (!strcmp(c,"user_data"))

  890.     user_data(read_word());

  891.   else if (!strcmp(c,"user_data_type"))

  892.     user_data_type(read_word());

  893.   else if (!strcmp(c,"callback"))

  894.     callback(read_word());

  895.   else if (!strcmp(c,"comment"))

  896.     comment(read_word());

  897.   else if (!strcmp(c,"open"))

  898.     open_ = 1;

  899.   else if (!strcmp(c,"selected"))

  900.     select(this,1);

  901.   else

  902.     read_error("Unknown property \"%s\"", c);

  903. }

  904. 

  905. /**

  906.  * Return 1 if the list contains a function with the given signature at the top level

  907.  */

  908. int has_toplevel_function(const char *rtype, const char *sig) {

  909.   Fl_Type *child;

  910.   for (child = Fl_Type::first; child; child = child->next) {

  911.     if (!child->is_in_class() && strcmp(child->type_name(), "Function")==0) {

  912.       const Fl_Function_Type *fn = (const Fl_Function_Type*)child;

  913.       if (fn->has_signature(rtype, sig))

  914.         return 1;

  915.     }

  916.   }

  917.   return 0;

  918. }

  919. 

  920. /**

  921.  * Write a comment inot the header file.

  922.  */

  923. void Fl_Type::write_comment_h(const char *pre)

  924. {

  925.   if (comment()) {

  926.     write_h("%s/**\n", pre);

  927.     const char *s = comment();

  928.     write_h("%s   ", pre);

  929.     while(*s) {

  930.       if (*s=='\n') {

  931.         if (s[1]) {

  932.           write_h("\n%s   ", pre);

  933.         }

  934.       } else {

  935.         write_h("%c", *s); // FIXME this is much too slow!

  936.       }

  937.       s++;

  938.     }

  939.     write_h("\n%s*/\n", pre);

  940.   }

  941. }

  942. 

  943. /**

  944.  * Write a comment inot the header file.

  945.  */

  946. void Fl_Type::write_comment_c(const char *pre)

  947. {

  948.   if (comment()) {

  949.     write_c("%s/**\n", pre);

  950.     const char *s = comment();

  951.     write_c("%s   ", pre);

  952.     while(*s) {

  953.       if (*s=='\n') {

  954.         if (s[1]) {

  955.           write_c("\n%s   ", pre);

  956.         }

  957.       } else {

  958.         write_c("%c", *s); // FIXME this is much too slow!

  959.       }

  960.       s++;

  961.     }

  962.     write_c("\n%s*/\n", pre);

  963.   }

  964. }

  965. 

  966. /**

  967.  * Make sure that the given item is visible in the browser by opening

  968.  * all parent groups and moving the item into the visible space.

  969.  */

  970. void reveal_in_browser(Fl_Type *t) {

  971.   Fl_Type *p = t->parent;

  972.   if (p) {

  973.     for (;;) {

  974.       if (!p->open_)

  975.         p->open_ = 1;

  976.       if (!p->parent) break;

  977.       p = p->parent;

  978.     }

  979.     fixvisible(p);

  980.   }

  981.   widget_browser->display(t);

  982.   redraw_browser();

  983. }

  984. 

  985. /**

  986.  * Build widgets and dataset needed in live mode.

  987.  * \return a widget pointer that the live mode initiator can 'show()'

  988.  * \see leave_live_mode()

  989.  */

  990. Fl_Widget *Fl_Type::enter_live_mode(int) {

  991.   return 0L;

  992. }

  993. 

  994. /**

  995.  * Release all resources created when enetring live mode.

  996.  * \see enter_live_mode()

  997.  */

  998. void Fl_Type::leave_live_mode() {

  999. }

  1000. 

  1001. /**

  1002.  * Copy all needed properties for this tye into the live object.

  1003.  */

  1004. void Fl_Type::copy_properties() {

  1005. }

  1006. 

  1007. /**

  1008.  * Check whether callback name is declared anywhere else by the user

  1009.  *

  1010.  * \b Warning: this just checks that the name is declared somewhere,

  1011.  * but it should probably also check that the name corresponds to a

  1012.  * plain function or a member function within the same class and that

  1013.  * the parameter types match.

  1014.  */

  1015. int Fl_Type::user_defined(const char* cbname) const {

  1016.   for (Fl_Type* p = Fl_Type::first; p ; p = p->next)

  1017.     if (strcmp(p->type_name(), "Function") == 0 && p->name() != 0)

  1018.       if (strncmp(p->name(), cbname, strlen(cbname)) == 0)

  1019.         if (p->name()[strlen(cbname)] == '(')

  1020.           return 1;

  1021.   return 0;

  1022. }

  1023. 

  1024. 

  1025. //

  1026. // End of "$Id: Fl_Type.cxx 8172 2011-01-03 08:28:38Z matt $".

  1027. //