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.
30 Commits
1 Branch
8.9MB
Tree: dd451702ae
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dd451702ae'
${ noResults }
ntk/fluid/Fl_Type.cxx

1030 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/flClock.xpm"

  95. #include "pixmaps/flHelp.xpm"

  96. #include "pixmaps/flProgress.xpm"

  97. #include "pixmaps/flSlider.xpm"

  98. #include "pixmaps/flScrollBar.xpm"

  99. #include "pixmaps/flValueSlider.xpm"

  100. #include "pixmaps/flAdjuster.xpm"

  101. #include "pixmaps/flCounter.xpm"

  102. #include "pixmaps/flDial.xpm"

  103. #include "pixmaps/flRoller.xpm"

  104. #include "pixmaps/flValueInput.xpm"

  105. #include "pixmaps/flValueOutput.xpm"

  106. #include "pixmaps/flSpinner.xpm"

  107. #include "pixmaps/flWidgetClass.xpm"

  108. #include "pixmaps/flTree.xpm"

  109. #include "pixmaps/flTable.xpm"

  110. 

  111. static Fl_Pixmap	window_pixmap(flWindow_xpm);

  112. static Fl_Pixmap	button_pixmap(flButton_xpm);

  113. static Fl_Pixmap	checkbutton_pixmap(flCheckButton_xpm);

  114. static Fl_Pixmap	roundbutton_pixmap(flRoundButton_xpm);

  115. static Fl_Pixmap	box_pixmap(flBox_xpm);

  116. static Fl_Pixmap	group_pixmap(flGroup_xpm);

  117. static Fl_Pixmap	function_pixmap(flFunction_xpm);

  118. static Fl_Pixmap	code_pixmap(flCode_xpm);

  119. static Fl_Pixmap	codeblock_pixmap(flCodeBlock_xpm);

  120. static Fl_Pixmap	comment_pixmap(flComment_xpm);

  121. static Fl_Pixmap	declaration_pixmap(flDeclaration_xpm);

  122. static Fl_Pixmap	declarationblock_pixmap(flDeclarationBlock_xpm);

  123. static Fl_Pixmap	class_pixmap(flClass_xpm);

  124. static Fl_Pixmap	tabs_pixmap(flTabs_xpm);

  125. static Fl_Pixmap	input_pixmap(flInput_xpm);

  126. static Fl_Pixmap	choice_pixmap(flChoice_xpm);

  127. static Fl_Pixmap	menuitem_pixmap(flMenuitem_xpm);

  128. static Fl_Pixmap	menubar_pixmap(flMenubar_xpm);

  129. static Fl_Pixmap	submenu_pixmap(flSubmenu_xpm);

  130. static Fl_Pixmap	scroll_pixmap(flScroll_xpm);

  131. static Fl_Pixmap	tile_pixmap(flTile_xpm);

  132. static Fl_Pixmap	wizard_pixmap(flWizard_xpm);

  133. static Fl_Pixmap	pack_pixmap(flPack_xpm);

  134. static Fl_Pixmap	returnbutton_pixmap(flReturnButton_xpm);

  135. static Fl_Pixmap	lightbutton_pixmap(flLightButton_xpm);

  136. static Fl_Pixmap	repeatbutton_pixmap(flRepeatButton_xpm);

  137. static Fl_Pixmap	menubutton_pixmap(flMenuButton_xpm);

  138. static Fl_Pixmap	output_pixmap(flOutput_xpm);

  139. static Fl_Pixmap	textdisplay_pixmap(flTextDisplay_xpm);

  140. static Fl_Pixmap	textedit_pixmap(flTextEdit_xpm);

  141. static Fl_Pixmap	fileinput_pixmap(flFileInput_xpm);

  142. static Fl_Pixmap	browser_pixmap(flBrowser_xpm);

  143. static Fl_Pixmap	checkbrowser_pixmap(flCheckBrowser_xpm);

  144. static Fl_Pixmap	filebrowser_pixmap(flFileBrowser_xpm);

  145. static Fl_Pixmap	clock_pixmap(flClock_xpm);

  146. static Fl_Pixmap	help_pixmap(flHelp_xpm);

  147. static Fl_Pixmap	progress_pixmap(flProgress_xpm);

  148. static Fl_Pixmap	slider_pixmap(flSlider_xpm);

  149. static Fl_Pixmap	scrollbar_pixmap(flScrollBar_xpm);

  150. static Fl_Pixmap	valueslider_pixmap(flValueSlider_xpm);

  151. static Fl_Pixmap	adjuster_pixmap(flAdjuster_xpm);

  152. static Fl_Pixmap	counter_pixmap(flCounter_xpm);

  153. static Fl_Pixmap	dial_pixmap(flDial_xpm);

  154. static Fl_Pixmap	roller_pixmap(flRoller_xpm);

  155. static Fl_Pixmap	valueinput_pixmap(flValueInput_xpm);

  156. static Fl_Pixmap	valueoutput_pixmap(flValueOutput_xpm);

  157. static Fl_Pixmap	spinner_pixmap(flSpinner_xpm);

  158. static Fl_Pixmap	widgetclass_pixmap(flWidgetClass_xpm);

  159. static Fl_Pixmap	data_pixmap(flData_xpm);

  160. static Fl_Pixmap	tree_pixmap(flTree_xpm);

  161. static Fl_Pixmap	table_pixmap(flTable_xpm);

  162. 

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

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

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

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

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

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

  169.  &checkbrowser_pixmap, &filebrowser_pixmap, &clock_pixmap, &help_pixmap, &progress_pixmap,	     /* 33..36 */

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

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

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

  173. 

  174. extern int show_comments;

  175. 

  176. ////////////////////////////////////////////////////////////////

  177. 

  178. class Widget_Browser : public Fl_Browser_ {

  179.   friend class Fl_Type;

  180. 

  181.   // required routines for Fl_Browser_ subclass:

  182.   void *item_first() const ;

  183.   void *item_next(void *) const ;

  184.   void *item_prev(void *) const ;

  185.   int item_selected(void *) const ;

  186.   void item_select(void *,int);

  187.   int item_width(void *) const ;

  188.   int item_height(void *) const ;

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

  190.   int incr_height() const ;

  191. 

  192. public:	

  193. 

  194.   int handle(int);

  195.   void callback();

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

  197. };

  198. 

  199. static Widget_Browser *widget_browser;

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

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

  202. }

  203. 

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

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

  206.   //  Fl_Type::current = o;

  207. }

  208. 

  209. void select_only(Fl_Type *o) {

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

  211. }

  212. 

  213. void deselect() {

  214.   widget_browser->deselect();

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

  216. }

  217. 

  218. Fl_Type *Fl_Type::first;

  219. Fl_Type *Fl_Type::last;

  220. 

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

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

  223. }

  224. 

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

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

  227.   type(FL_MULTI_BROWSER);

  228.   Fl_Widget::callback(Widget_Browser_callback);

  229.   when(FL_WHEN_RELEASE);

  230. }

  231. 

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

  233. 

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

  235. 

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

  237. 

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

  239. 

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

  241. 

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

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

  244.   if (t->visible) {

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

  246.       return textsize()*2+1;

  247.     else

  248.       return textsize()+2;

  249.   } else {

  250.     return 0;

  251.   }

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

  253. }

  254. 

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

  256. 

  257. static Fl_Type* pushedtitle;

  258. 

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

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

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

  262.   return type_name();

  263. }

  264. 

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

  266. 

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

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

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

  270.   int comment_incr = 0;

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

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

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

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

  275.       char c = *s++;

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

  277.       *d++ = c;

  278.     }

  279.     *d = 0;

  280.     comment_incr = textsize()-1;

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

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

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

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

  285.     Y += comment_incr/2;

  286.     comment_incr -= comment_incr/2;

  287.   }

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

  289.   else fl_color(FL_FOREGROUND_COLOR);

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

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

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

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

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

  295.   }

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

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

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

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

  300.       } else {

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

  302.       }

  303.     } else {

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

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

  306.       } else {

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

  308.       }

  309.     }

  310.     X += 10;

  311.   }

  312.   Y += comment_incr;

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

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

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

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

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

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

  319.     c = l->name();

  320.     if (c) {

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

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

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

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

  325.       *p++ = '"';

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

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

  328.         *p++ = *c++;

  329.       }

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

  331.       *p++ = '"';

  332.       *p = 0;

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

  334.     }

  335.   } else {

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

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

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

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

  340.       *p++ = *c++;

  341.     }

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

  343.     *p = 0;

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

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

  346.   }

  347. }

  348. 

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

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

  351. 

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

  353. 

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

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

  356. 

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

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

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

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

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

  362.     c = l->name();

  363.     if (c) {

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

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

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

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

  368.       *p++ = '"';

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

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

  371. 	*p++ = *c++;

  372.       }

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

  374.       *p++ = '"';

  375.       *p = 0;

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

  377.     }

  378.   } else {

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

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

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

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

  383.       *p++ = *c++;

  384.     }

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

  386.     *p = 0;

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

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

  389.   }

  390. 

  391.   return W;

  392. }

  393. 

  394. void redraw_browser() {

  395.   widget_browser->redraw();

  396. }

  397. 

  398. void Widget_Browser::callback() {

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

  400. }

  401. 

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

  403.   static Fl_Type *title;

  404.   Fl_Type *l;

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

  406.   switch (e) {

  407.   case FL_PUSH:

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

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

  410.     if (l) {

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

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

  413. 	title = pushedtitle = l;

  414. 	redraw_line(l);

  415. 	return 1;

  416.       }

  417.     }

  418.     break;

  419.   case FL_DRAG:

  420.     if (!title) break;

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

  422.     if (l) {

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

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

  425.       else l = 0;

  426.     }

  427.     if (l != pushedtitle) {

  428.       if (pushedtitle) redraw_line(pushedtitle);

  429.       if (l) redraw_line(l);

  430.       pushedtitle = l;

  431.     }

  432.     return 1;

  433.   case FL_RELEASE:

  434.     if (!title) {

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

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

  437. 	l->open();

  438.       break;

  439.     }

  440.     l = pushedtitle;

  441.     title = pushedtitle = 0;

  442.     if (l) {

  443.       if (l->open_) {

  444. 	l->open_ = 0;

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

  446. 	  k->visible = 0;

  447.       } else {

  448. 	l->open_ = 1;

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

  450. 	  k->visible = 1;

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

  452. 	    Fl_Type *j;

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

  454. 	    k = j;

  455. 	  } else

  456. 	    k = k->next;

  457. 	}

  458.       }

  459.       redraw();

  460.     }

  461.     return 1;

  462.   }

  463.   return Fl_Browser_::handle(e);

  464. }

  465. 

  466. Fl_Type::Fl_Type() {

  467.   factory = 0;

  468.   parent = 0;

  469.   next = prev = 0;

  470.   selected = new_selected = 0;

  471.   visible = 0;

  472.   name_ = 0;

  473.   label_ = 0;

  474.   user_data_ = 0;

  475.   user_data_type_ = 0;

  476.   callback_ = 0;

  477.   comment_ = 0;

  478.   rtti = 0;

  479.   level = 0;

  480.   code_position = header_position = -1;

  481.   code_position_end = header_position_end = -1;

  482. }

  483. 

  484. static void fixvisible(Fl_Type *p) {

  485.   Fl_Type *t = p;

  486.   for (;;) {

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

  488.     else t->visible = 1;

  489.     t = t->next;

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

  491.   }

  492. }

  493. 

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

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

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

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

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

  499. 

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

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

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

  503.   undo_checkpoint();

  504.   parent = p;

  505.   Fl_Type *end = this;

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

  507.   Fl_Type *q;

  508.   int newlevel;

  509.   if (p) {

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

  511.     newlevel = p->level+1;

  512.   } else {

  513.     q = 0;

  514.     newlevel = 0;

  515.   }

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

  517.   level = newlevel;

  518.   if (q) {

  519.     prev = q->prev;

  520.     prev->next = this;

  521.     q->prev = end;

  522.     end->next = q;

  523.   } else if (first) {

  524.     prev = last;

  525.     prev->next = this;

  526.     end->next = 0;

  527.     last = end;

  528.   } else {

  529.     first = this;

  530.     last = end;

  531.     prev = end->next = 0;

  532.   }

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

  534.   open_ = 1;

  535.   fixvisible(this);

  536.   set_modflag(1);

  537.   widget_browser->redraw();

  538. }

  539. 

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

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

  542.   Fl_Type *end = this;

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

  544.   parent = g->parent;

  545.   int newlevel = g->level;

  546.   visible = g->visible;

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

  548.   level = newlevel;

  549.   prev = g->prev;

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

  551.   end->next = g;

  552.   g->prev = end;

  553.   fixvisible(this);

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

  555.   widget_browser->redraw();

  556. }

  557. 

  558. // Return message number for I18N...

  559. int

  560. Fl_Type::msgnum() {

  561.   int		count;

  562.   Fl_Type	*p;

  563. 

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

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

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

  567. 

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

  569.     else p = p->parent;

  570.   }

  571. 

  572.   return count;

  573. }

  574. 

  575. 

  576. // delete from parent:

  577. Fl_Type *Fl_Type::remove() {

  578.   Fl_Type *end = this;

  579.   for (;;) {

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

  581.     end = end->next;

  582.   }

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

  584.   else first = end->next;

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

  586.   else last = prev;

  587.   Fl_Type *r = end->next;

  588.   prev = end->next = 0;

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

  590.   parent = 0;

  591.   widget_browser->redraw();

  592.   selection_changed(0);

  593.   return r;

  594. }

  595. 

  596. // update a string member:

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

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

  599.   undo_checkpoint();

  600.   int length = 0;

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

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

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

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

  605.     length = e-n;

  606.     if (!length) n = 0;

  607.   }    

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

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

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

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

  612.     p = 0;

  613.   } else {

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

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

  616.     p = q;

  617.   }

  618.   set_modflag(1);

  619.   return 1;

  620. }

  621. 

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

  623.   int nostrip = is_comment();

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

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

  626.   }

  627. }

  628. 

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

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

  631.     setlabel(label_);

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

  633.   }

  634. }

  635. 

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

  637.   storestring(n,callback_);

  638. }

  639. 

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

  641.   storestring(n,user_data_);

  642. }

  643. 

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

  645.   storestring(n,user_data_type_);

  646. }

  647. 

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

  649.   storestring(n, comment_, 1);

  650. }

  651. 

  652. void Fl_Type::open() {

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

  654. }

  655. 

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

  657. 

  658. Fl_Type::~Fl_Type() {

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

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

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

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

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

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

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

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

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

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

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

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

  671. }

  672. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  690. 

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

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

  693. 

  694. 

  695. ////////////////////////////////////////////////////////////////

  696. 

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

  698. 

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

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

  701.   if (in_this_only) {

  702.     Fl_Type *t = p;

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

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

  705.   }

  706.   for (;;) {

  707.     if (p) {

  708.       int foundany = 0;

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

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

  711.       }

  712.       if (foundany) break;

  713.       p = p->parent;

  714.     } else {

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

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

  717.       break;

  718.     }

  719.   }

  720.   selection_changed(p);

  721. }

  722. 

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

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

  725.   if (in_this_only) {

  726.     Fl_Type *t = p;

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

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

  729.   }

  730.   for (;;) {

  731.     if (p) {

  732.       int foundany = 0;

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

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

  735.       }

  736.       if (foundany) break;

  737.       p = p->parent;

  738.     } else {

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

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

  741.       break;

  742.     }

  743.   }

  744.   selection_changed(p);

  745. }

  746. 

  747. static void delete_children(Fl_Type *p) {

  748.   Fl_Type *f;

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

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

  751.     Fl_Type *g = f->prev;

  752.     delete f;

  753.     f = g;

  754.   }

  755. }

  756. 

  757. void delete_all(int selected_only) {

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

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

  760.       delete_children(f);

  761.       Fl_Type *g = f->next;

  762.       delete f;

  763.       f = g;

  764.     } else f = f->next;

  765.   }

  766.   if(!selected_only) {

  767. 		include_H_from_C=1;

  768. 		use_FL_COMMAND=0;

  769. 	}

  770. 

  771.   selection_changed(0);

  772. }

  773. 

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

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

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

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

  778. 				level, g->level);

  779.   Fl_Type* n;

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

  781.   if (n == g) return;

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

  783.   prev->next = n;

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

  785.   prev = g->prev;

  786.   l->next = g;

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

  788.   g->prev = l;

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

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

  791.   widget_browser->display(this);

  792.   widget_browser->redraw();

  793. }

  794. 

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

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

  797.   Fl_Type *f;

  798.   int mod = 0;

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

  800.     Fl_Type* nxt = f->next;

  801.     if (f->selected) {

  802.       Fl_Type* g;

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

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

  805.         f->move_before(g);

  806.         mod = 1;

  807.       }

  808.     }

  809.     f = nxt;

  810.   }

  811.   if (mod) set_modflag(1);

  812. }

  813. 

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

  815.   Fl_Type *f;

  816.   int mod = 0;

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

  818.     Fl_Type* prv = f->prev;

  819.     if (f->selected) {

  820.       Fl_Type* g;

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

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

  823.         g->move_before(f);

  824.         mod = 1;

  825.       }

  826.     }

  827.     f = prv;

  828.   }

  829.   if (mod) set_modflag(1);

  830. }

  831. 

  832. ////////////////////////////////////////////////////////////////

  833. 

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

  835. void Fl_Type::write() {

  836.     write_indent(level);

  837.     write_word(type_name());

  838.     

  839.     if (is_class()) {

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

  841.       if (p &&	strlen(p))

  842.         write_word(p);

  843.     }

  844. 

  845.     write_word(name());

  846.     write_open(level);

  847.     write_properties();

  848.     write_close(level);

  849.     if (!is_parent()) return;

  850.     // now do children:

  851.     write_open(level);

  852.     Fl_Type *child;

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

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

  855.     write_close(level);

  856. }

  857. 

  858. void Fl_Type::write_properties() {

  859.   // repeat this for each attribute:

  860.   if (label()) {

  861.     write_indent(level+1);

  862.     write_word("label");

  863.     write_word(label());

  864.   }

  865.   if (user_data()) {

  866.     write_indent(level+1);

  867.     write_word("user_data");

  868.     write_word(user_data());

  869.   }

  870.   if (user_data_type()) {

  871.     write_word("user_data_type");

  872.     write_word(user_data_type());

  873.   }

  874.   if (callback()) {

  875.     write_indent(level+1);

  876.     write_word("callback");

  877.     write_word(callback());

  878.   }

  879.   if (comment()) {

  880.     write_indent(level+1);

  881.     write_word("comment");

  882.     write_word(comment());

  883.   }

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

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

  886. }

  887. 

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

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

  890.     label(read_word());

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

  892.     user_data(read_word());

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

  894.     user_data_type(read_word());

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

  896.     callback(read_word());

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

  898.     comment(read_word());

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

  900.     open_ = 1;

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

  902.     select(this,1);

  903.   else

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

  905. }

  906. 

  907. /**

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

  909.  */

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

  911.   Fl_Type *child;

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

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

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

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

  916.         return 1;

  917.     }

  918.   }

  919.   return 0;

  920. }

  921. 

  922. /**

  923.  * Write a comment inot the header file.

  924.  */

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

  926. {

  927.   if (comment()) {

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

  929.     const char *s = comment();

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

  931.     while(*s) {

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

  933.         if (s[1]) {

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

  935.         }

  936.       } else {

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

  938.       }

  939.       s++;

  940.     }

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

  942.   }

  943. }

  944. 

  945. /**

  946.  * Write a comment inot the header file.

  947.  */

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

  949. {

  950.   if (comment()) {

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

  952.     const char *s = comment();

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

  954.     while(*s) {

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

  956.         if (s[1]) {

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

  958.         }

  959.       } else {

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

  961.       }

  962.       s++;

  963.     }

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

  965.   }

  966. }

  967. 

  968. /**

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

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

  971.  */

  972. void reveal_in_browser(Fl_Type *t) {

  973.   Fl_Type *p = t->parent;

  974.   if (p) {

  975.     for (;;) {

  976.       if (!p->open_)

  977.         p->open_ = 1;

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

  979.       p = p->parent;

  980.     }

  981.     fixvisible(p);

  982.   }

  983.   widget_browser->display(t);

  984.   redraw_browser();

  985. }

  986. 

  987. /**

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

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

  990.  * \see leave_live_mode()

  991.  */

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

  993.   return 0L;

  994. }

  995. 

  996. /**

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

  998.  * \see enter_live_mode()

  999.  */

  1000. void Fl_Type::leave_live_mode() {

  1001. }

  1002. 

  1003. /**

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

  1005.  */

  1006. void Fl_Type::copy_properties() {

  1007. }

  1008. 

  1009. /**

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

  1011.  *

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

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

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

  1015.  * the parameter types match.

  1016.  */

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

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

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

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

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

  1022.           return 1;

  1023.   return 0;

  1024. }

  1025. 

  1026. 

  1027. //

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

  1029. //