PageRenderTime 27ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 0ms

/R-2.10.1-patched/src/gnuwin32/preferences.c

http://r4jvm.googlecode.com/
C | 889 lines | 744 code | 102 blank | 43 comment | 179 complexity | 723854292db37efb9fd06f79c8435323 MD5 | raw file
Possible License(s): GPL-3.0, LGPL-2.0, LGPL-3.0, BSD-3-Clause, AGPL-3.0, GPL-2.0, LGPL-2.1 
    

  1. /*
    2. 

  2.  *  R : A Computer Language for Statistical Data Analysis
    3. 

  3.  *  file preferences.c
    4. 

  4.  *  Copyright (C) 2000    Guido Masarotto and Brian Ripley
    5. 

  5.  *                2004-8  R Core Development Team
    6. 

  6.  *
    7. 

  7.  *  This program is free software; you can redistribute it and/or modify
    8. 

  8.  *  it under the terms of the GNU General Public License as published by
    9. 

  9.  *  the Free Software Foundation; either version 2 of the License, or
    10. 

  10.  *  (at your option) any later version.
    11. 

  11.  *
    12. 

  12.  *  This program is distributed in the hope that it will be useful,
    13. 

  13.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    14. 

  14.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15. 

  15.  *  GNU General Public License for more details.
    16. 

  16.  *
    17. 

  17.  *  You should have received a copy of the GNU General Public License
    18. 

  18.  *  along with this program; if not, a copy is available at
    19. 

  19.  *  http://www.r-project.org/Licenses/
    20. 

  20.  */
    21. 

  21. 

  22. #ifdef HAVE_CONFIG_H
    23. 

  23. #include <config.h>
    24. 

  24. #endif
    25. 

  25. 

  26. #include "win-nls.h"
    27. 

  27. 

  28. #ifdef Win32
    29. 

  29. #define USE_MDI 1
    30. 

  30. #endif
    31. 

  31. 

  32. #define WIN32_LEAN_AND_MEAN 1
    33. 

  33. #include <windows.h>
    34. 

  34. #include <ctype.h>  /* isspace */
    35. 

  35. #include "graphapp/ga.h"
    36. 

  36. #include "graphapp/graphapp.h"
    37. 

  37. #include "opt.h"
    38. 

  38. #include "console.h"
    39. 

  39. #include "consolestructs.h"
    40. 

  40. #include "rui.h"
    41. 

  41. #include "preferences.h"
    42. 

  42. #include <Fileio.h>
    43. 

  43. void R_fixbackslash(char *s);
    44. 

  44. 

  45. #define gettext GA_gettext
    46. 

  46. 

  47. extern char fontname[LF_FACESIZE+4]; /* from console.c */
    48. 

  48. extern int consolex, consoley; /* from console.c */
    49. 

  49. extern int pagerMultiple, haveusedapager; /* from pager.c */
    50. 

  50. void editorsetfont(font f);
    51. 

  51. 

  52. static void showDialog(Gui gui);
    53. 

  53. 

  54. extern __declspec(dllimport) const char *ColorName[]; /* from graphapp/rgb.c */
    55. 

  55. 

  56. static int cmatch(const char *col, const char **list)
    57. 

  57. {
    58. 

  58.     int i=0;
    59. 

  59.     const char **pos = list;
    60. 

  60.     while(*pos != NULL) {
    61. 

  61. 	if(strcmpi(*pos, col) == 0) return(i);
    62. 

  62. 	i++; pos++;
    63. 

  63.     }
    64. 

  64.     return(-1);
    65. 

  65. }
    66. 

  66. 

  67. 

  68. static const char *StyleList[] = {"normal", "bold", "italic", NULL};
    69. 

  69. static const char *PointsList[] = {"6", "7", "8", "9", "10", "11", "12", "14", "16", "18", "20", "22", "24", "26", "28", "32", "36", NULL};
    70. 

  70. static const char *FontsList[] = {"Courier", "Courier New", "FixedSys", "FixedFont", "Lucida Console", "Consolas", "Terminal", "BatangChe", "DotumChe", "GulimChe", "MingLiU", "MS Gothic", "MS Mincho", "NSimSun", NULL};
    71. 

  71. static const char *GuiElementNames[numGuiColors+1] = {"background", "normaltext", "usertext",
    72. 

  72. 						"pagerbg", "pagertext", "highlight",
    73. 

  73. 						"dataeditbg", "dataedittext", "dataedituser",
    74. 

  74. 						"editorbg", "editortext", NULL};
    75. 

  75. static window wconfig;
    76. 

  76. static button bApply, bSave, bLoad, bOK, bCancel;
    77. 

  77. static label l_mdi, l_mwin, l_font, l_point, l_style, l_lang, l_crows, l_ccols,
    78. 

  78.     l_cx, l_cy, l_prows, l_pcols, l_grx, l_gry,
    79. 

  79.     l_cols, l_cbb, l_cbl;
    80. 

  80. static radiogroup g_mwin;
    81. 

  81. static radiobutton rb_mdi, rb_sdi, rb_mwin, rb_swin;
    82. 

  82. static listbox f_font, f_style, d_point, guielement, guicolor;
    83. 

  83. static checkbox toolbar, statusbar, tt_font, c_resize, c_buff;
    84. 

  84. static field f_crows, f_ccols, f_prows, f_pcols, f_cx, f_cy, f_cbb,f_cbl,
    85. 

  85.     f_grx, f_gry, f_lang;
    86. 

  86. static textbox guisample;
    87. 

  87. static font samplefont = NULL;
    88. 

  88. static int samplePointsize = 10;
    89. 

  89. static int sampleStyle = Plain;
    90. 

  90. static int sampleFontNum;
    91. 

  91. 

  92. static rgb dialogColors[numGuiColors];
    93. 

  93. 

  94. static void getChoices(Gui p)
    95. 

  95. {
    96. 

  96.     p->MDI = ischecked(rb_mdi);
    97. 

  97.     p->toolbar = ischecked(toolbar);
    98. 

  98.     p->statusbar = ischecked(statusbar);
    99. 

  99.     p->pagerMultiple = ischecked(rb_mwin);
    100. 

  100.     strcpy(p->language, gettext(f_lang));
    101. 

  101.     strcpy(p->font, gettext(f_font));
    102. 

  102.     p->tt_font = ischecked(tt_font);
    103. 

  103.     p->pointsize = atoi(gettext(d_point));
    104. 

  104.     strcpy(p->style, gettext(f_style));
    105. 

  105.     p->crows = atoi(gettext(f_crows));
    106. 

  106.     p->ccols = atoi(gettext(f_ccols));
    107. 

  107.     p->cx = atoi(gettext(f_cx));
    108. 

  108.     p->cy = atoi(gettext(f_cy));
    109. 

  109.     p->setWidthOnResize = ischecked(c_resize);
    110. 

  110.     p->buffered = ischecked(c_buff);
    111. 

  111.     p->cbb = atoi(gettext(f_cbb));
    112. 

  112.     p->cbl = atoi(gettext(f_cbl));
    113. 

  113.     p->prows = atoi(gettext(f_prows));
    114. 

  114.     p->pcols = atoi(gettext(f_pcols));
    115. 

  115.     p->grx = atoi(gettext(f_grx));
    116. 

  116.     p->gry = atoi(gettext(f_gry));
    117. 

  117.     dialogColors[cmatch(gettext(guielement),GuiElementNames)] = nametorgb(gettext(guicolor));
    118. 

  118.     for (int i=0; i<numGuiColors; i++)
    119. 

  119. 	p->guiColors[i] = dialogColors[i];    
    120. 

  120.     /* MDIsize is not currently a choice in the dialog, only in the Rconsole file */
    121. 

  121. }
    122. 

  122. 

  123. void getDefaults(Gui gui)
    124. 

  124. {
    125. 

  125.     gui->crows = 25;
    126. 

  126.     gui->ccols = 80;
    127. 

  127.     gui->cx = gui->cy = 0;
    128. 

  128.     gui->grx = Rwin_graphicsx;
    129. 

  129.     gui->gry = Rwin_graphicsy;
    130. 

  130.     gui->guiColors[consolebg] = White;
    131. 

  131.     gui->guiColors[consolefg] = DarkBlue;
    132. 

  132.     gui->guiColors[consoleuser] = gaRed;
    133. 

  133.     gui->guiColors[pagerbg] = White;
    134. 

  134.     gui->guiColors[pagerfg] = DarkBlue;   
    135. 

  135.     gui->guiColors[pagerhighlight] = DarkRed;
    136. 

  136.     gui->guiColors[dataeditbg] = White;
    137. 

  137.     gui->guiColors[dataeditfg] = DarkBlue;
    138. 

  138.     gui->guiColors[dataedituser] = gaRed;    
    139. 

  139.     gui->guiColors[editorbg] = White;
    140. 

  140.     gui->guiColors[editorfg] = Black;    
    141. 

  141.     gui->prows = 25;
    142. 

  142.     gui->pcols = 80;
    143. 

  143.     gui->pagerMultiple = 0;
    144. 

  144.     gui->cbb = 65000;
    145. 

  145.     gui->cbl = 8000;
    146. 

  146.     gui->setWidthOnResize = 1;
    147. 

  147.     strcpy(gui->font, "Courier New");
    148. 

  148.     strcpy(gui->style, "normal");
    149. 

  149.     gui->tt_font = 1;
    150. 

  150.     gui->pointsize = 10;
    151. 

  151.     strcpy(gui->language, "");
    152. 

  152.     gui->buffered = 1;
    153. 

  153. 

  154. #ifdef USE_MDI
    155. 

  155.     gui->toolbar = ((RguiMDI & RW_TOOLBAR) != 0);
    156. 

  156.     gui->statusbar = ((RguiMDI & RW_STATUSBAR) != 0);
    157. 

  157.     gui->MDI = ((RguiMDI & RW_MDI) != 0);
    158. 

  158. 

  159.     gui->MDIsize = rect(0, 0, 0, 0);
    160. 

  160. #endif
    161. 

  161. }
    162. 

  162. 

  163. void getActive(Gui gui)
    164. 

  164. {
    165. 

  165.     rect r;
    166. 

  166.     ConsoleData p;
    167. 

  167.     if (RConsole && (p = (ConsoleData) getdata(RConsole))) {
    168. 

  168. 

  169. 	gui->toolbar = ((RguiMDI & RW_TOOLBAR) != 0);
    170. 

  170. 	gui->statusbar = ((RguiMDI & RW_STATUSBAR) != 0);
    171. 

  171. 	gui->MDI = ((RguiMDI & RW_MDI) != 0);
    172. 

  172. 	gui->pagerMultiple = pagerMultiple;
    173. 

  173. 	{
    174. 

  174. 	    const char *p = getenv("LANGUAGE");
    175. 

  175. 	    strcpy(gui->language, p ? p : "");
    176. 

  176. 	}
    177. 

  177. 

  178. 	/* Font, pointsize, style */
    179. 

  179. 

  180. 	gui->tt_font = FALSE;
    181. 

  181. 	{
    182. 

  182. 	    const char *pf;
    183. 

  183. 	    if ((strlen(fontname) > 1) &&
    184. 

  184. 		(fontname[0] == 'T') && (fontname[1] == 'T')) {
    185. 

  185. 		gui->tt_font = TRUE;
    186. 

  186. 		for (pf = fontname+2; isspace(*pf) ; pf++);
    187. 

  187. 	    } else pf = fontname;
    188. 

  188. 	    strcpy(gui->font, pf);
    189. 

  189. 	}
    190. 

  190. 

  191. 	gui->pointsize = pointsize;
    192. 

  192. 

  193. 	if (fontsty & Italic) strcpy(gui->style, "italic");
    194. 

  194. 	else if (fontsty & Bold) strcpy(gui->style, "Bold");
    195. 

  195. 	else strcpy(gui->style, "normal");
    196. 

  196. 

  197. 	/* Console size, set widthonresize */
    198. 

  198. 	gui->crows = ROWS;
    199. 

  199. 	gui->ccols = COLS;
    200. 

  200. 	r = GetCurrentWinPos(RConsole);
    201. 

  201. 	gui->cx = r.x;
    202. 

  202. 	gui->cy = r.y;
    203. 

  203. 	gui->setWidthOnResize = setWidthOnResize;
    204. 

  204. 	gui->cbb = p->lbuf->dim;
    205. 

  205. 	gui->cbl = p->lbuf->ms;
    206. 

  206. 	gui->buffered = consolebuffered;
    207. 

  207. 

  208. 	/* Pager size */
    209. 

  209. 	gui->prows = pagerrow;
    210. 

  210. 	gui->pcols = pagercol;
    211. 

  211. 

  212. 	/* Graphics window */
    213. 

  213. 	gui->grx = Rwin_graphicsx;
    214. 

  214. 	gui->gry = Rwin_graphicsy;
    215. 

  215. 

  216. 	/* Font colours */
    217. 

  217. 	for (int i=0; i<numGuiColors; i++)
    218. 

  218. 	    gui->guiColors[i] = guiColors[i];
    219. 

  219. 

  220. 	/* MDIsize is not currently a choice in the dialog, only in the Rconsole file, so is not set here */
    221. 

  221.     } else
    222. 

  222. 	getDefaults(gui);
    223. 

  223. }
    224. 

  224. 

  225. static int has_changed(Gui a, Gui b)
    226. 

  226. {
    227. 

  227.     Rboolean colorchange = FALSE;
    228. 

  228.     if (a)
    229. 

  229. 	for (int i=0; i<numGuiColors; i++)
    230. 

  230.     	    colorchange |= a->guiColors[i] != b->guiColors[i];
    231. 

  231.     	
    232. 

  232.     return !a || colorchange ||
    233. 

  233. 	a->MDI != b->MDI ||
    234. 

  234. 	a->toolbar != b->toolbar ||
    235. 

  235. 	a->statusbar != b->statusbar ||
    236. 

  236. 	a->pagerMultiple != b->pagerMultiple ||
    237. 

  237. 	strcmp(a->language, b->language) ||
    238. 

  238. 	strcmp(a->font, b->font) ||
    239. 

  239. 	a->tt_font != b->tt_font ||
    240. 

  240. 	a->pointsize != b->pointsize ||
    241. 

  241. 	strcmp(a->style, b->style) ||
    242. 

  242. 	a->crows != b->crows ||
    243. 

  243. 	a->ccols != b->ccols ||
    244. 

  244. 	a->cx != b->cx ||
    245. 

  245. 	a->cy != b->cy ||
    246. 

  246. 	a->cbb != b->cbb ||
    247. 

  247. 	a->cbl != b->cbl ||
    248. 

  248. 	a->setWidthOnResize != b->setWidthOnResize ||
    249. 

  249. 	a->prows != b->prows ||
    250. 

  250. 	a->pcols != b->pcols ||
    251. 

  251. 	a->grx != b->grx ||
    252. 

  252. 	a->gry != b->gry ;
    253. 

  253. }
    254. 

  254. 

  255. 

  256. static void cleanup(void)
    257. 

  257. {
    258. 

  258.     hide(wconfig);
    259. 

  259.     delobj(l_mdi); delobj(rb_mdi); delobj(rb_sdi);
    260. 

  260.     delobj(toolbar); delobj(statusbar);
    261. 

  261.     delobj(l_mwin); delobj(g_mwin); delobj(rb_mwin); delobj(rb_swin);
    262. 

  262.     delobj(l_lang); delobj(f_lang);
    263. 

  263.     delobj(l_font); delobj(f_font); delobj(tt_font);
    264. 

  264.     delobj(l_point); delobj(d_point);
    265. 

  265.     delobj(l_style); delobj(f_style);
    266. 

  266.     delobj(l_crows); delobj(f_crows); delobj(l_ccols); delobj(f_ccols);
    267. 

  267.     delobj(c_resize); delobj(c_buff);
    268. 

  268.     delobj(l_cx); delobj(f_cx); delobj(l_cy); delobj(f_cy);
    269. 

  269.     delobj(l_cbb); delobj(f_cbb); delobj(l_cbl); delobj(f_cbl);
    270. 

  270.     delobj(l_prows); delobj(f_prows); delobj(l_pcols); delobj(f_pcols);
    271. 

  271.     delobj(l_grx); delobj(f_grx); delobj(l_gry); delobj(f_gry);
    272. 

  272.     delobj(l_cols);
    273. 

  273.     delobj(guielement); delobj(guicolor); delobj(guisample);
    274. 

  274.     delobj(bApply); delobj(bSave); delobj(bOK); delobj(bCancel);
    275. 

  275.     delobj(wconfig);
    276. 

  276. }
    277. 

  277. 

  278. void applyGUI(Gui newGUI)
    279. 

  279. {
    280. 

  280.     rect r = getrect(RConsole);
    281. 

  281.     ConsoleData p = (ConsoleData) getdata(RConsole);
    282. 

  282.     int havenewfont = 0;
    283. 

  283.     struct structGUI curGUI;
    284. 

  284. 

  285.     getActive(&curGUI);
    286. 

  286. 

  287.     if(!has_changed(&curGUI, newGUI)) return;
    288. 

  288. 

  289.     if(newGUI->MDI != curGUI.MDI || newGUI->toolbar != curGUI.toolbar ||
    290. 

  290.        newGUI->statusbar != curGUI.statusbar)
    291. 

  291. 	askok(G_("The overall console properties cannot be changed\non a running console.\n\nSave the preferences and restart Rgui to apply them.\n"));
    292. 

  292. 

  293.     if(strcmp(newGUI->language, curGUI.language)) {
    294. 

  294. 	char *buf = malloc(50);
    295. 

  295. 	askok(G_("The language for menus cannot be changed on a\n running console.\n\nSave the preferences and restart Rgui to apply to menus.\n"));
    296. 

  296. 	sprintf(buf, "LANGUAGE=%s", newGUI->language);
    297. 

  297. 	putenv(buf);
    298. 

  298.     }
    299. 

  299. 

  300. 

  301. /*  Set a new font? */
    302. 

  302.     if(strcmp(newGUI->font, curGUI.font) ||
    303. 

  303.        newGUI->pointsize != curGUI.pointsize ||
    304. 

  304.        strcmp(newGUI->style, curGUI.style))
    305. 

  305.     {
    306. 

  306. 	char msg[LF_FACESIZE + 128];
    307. 

  307. 	int sty = Plain;
    308. 

  308. 

  309. 	if(newGUI->tt_font) strcpy(fontname, "TT "); else strcpy(fontname, "");
    310. 

  310. 	strcat(fontname,  newGUI->font);
    311. 

  311. 	if (!strcmp(newGUI->style, "bold")) sty = Bold;
    312. 

  312. 	if (!strcmp(newGUI->style, "italic")) sty = Italic;
    313. 

  313. 	pointsize = newGUI->pointsize;
    314. 

  314. 	fontsty = sty;
    315. 

  315. 

  316. 	/* Don't delete font: open pagers may be using it */
    317. 

  317. 	if (strcmp(fontname, "FixedFont"))
    318. 

  318. 	    consolefn = gnewfont(NULL, fontname, fontsty, pointsize, 0.0, 1);
    319. 

  319. 	else consolefn = FixedFont;
    320. 

  320. 	if (!consolefn) {
    321. 

  321. 	    sprintf(msg,
    322. 

  322. 		    G_("Font %s-%d-%d  not found.\nUsing system fixed font"),
    323. 

  323. 		    fontname, fontsty | FixedWidth, pointsize);
    324. 

  324. 	    R_ShowMessage(msg);
    325. 

  325. 	    consolefn = FixedFont;
    326. 

  326. 	}
    327. 

  327. 	/* if (!ghasfixedwidth(consolefn)) {
    328. 

  328. 	   sprintf(msg,
    329. 

  329. 	   G_("Font %s-%d-%d has variable width.\nUsing system fixed font"),
    330. 

  330. 	   fontname, fontsty, pointsize);
    331. 

  331. 	   R_ShowMessage(msg);
    332. 

  332. 	   consolefn = FixedFont;
    333. 

  333. 	   } */
    334. 

  334. 	p->f = consolefn;
    335. 

  335. 	FH = fontheight(p->f);
    336. 

  336. 	FW = fontwidth(p->f);
    337. 

  337. 	havenewfont = 1;
    338. 

  338.     }
    339. 

  339. 

  340. /* resize console, possibly with new font */
    341. 

  341.     if (consoler != newGUI->crows || consolec != newGUI->ccols || havenewfont) {
    342. 

  342. 	char buf[20];
    343. 

  343. 	consoler = newGUI->crows;
    344. 

  344. 	consolec = newGUI->ccols;
    345. 

  345. 	r.width = (consolec + 1) * FW;
    346. 

  346. 	r.height = (consoler + 1) * FH;
    347. 

  347. 	resize(RConsole, r);
    348. 

  348. 	sprintf(buf, "%d", ROWS); settext(f_crows, buf);
    349. 

  349. 	sprintf(buf, "%d", COLS); settext(f_ccols, buf);
    350. 

  350.     }
    351. 

  351.     if (p->lbuf->dim != newGUI->cbb || p->lbuf->ms != newGUI->cbl)
    352. 

  352. 	xbufgrow(p->lbuf, newGUI->cbb, newGUI->cbl);
    353. 

  353. 

  354. /* Set colours and redraw */
    355. 

  355.     for (int i=0; i<numGuiColors; i++)
    356. 

  356.     	p->guiColors[i] = guiColors[i] = newGUI->guiColors[i];
    357. 

  357.     drawconsole(RConsole, r);
    358. 

  358.     if(haveusedapager &&
    359. 

  359.        (newGUI->prows != curGUI.prows || newGUI->pcols != curGUI.pcols))
    360. 

  360. 	askok(G_("Changes in pager size will not apply to any open pagers"));
    361. 

  361.     pagerrow = newGUI->prows;
    362. 

  362.     pagercol = newGUI->pcols;
    363. 

  363. 

  364.     if(newGUI->pagerMultiple != pagerMultiple) {
    365. 

  365. 	if(!haveusedapager ||
    366. 

  366. 	   askokcancel(G_("Do not change pager type if any pager is open\nProceed?"))
    367. 

  367. 	   == YES)
    368. 

  368. 	    pagerMultiple = newGUI->pagerMultiple;
    369. 

  369. 	if(pagerMultiple) {
    370. 

  370. 	    check(rb_mwin); uncheck(rb_swin);
    371. 

  371. 	} else {check(rb_swin); uncheck(rb_mwin);}
    372. 

  372.     }
    373. 

  373. 

  374.     setWidthOnResize = newGUI->setWidthOnResize;
    375. 

  375.     consolebuffered = newGUI->buffered;
    376. 

  376. 

  377.     Rwin_graphicsx = newGUI->grx;
    378. 

  378.     Rwin_graphicsy = newGUI->gry;
    379. 

  379. }
    380. 

  380. 

  381. static void do_apply(void)
    382. 

  382. {
    383. 

  383.     struct structGUI newGUI;
    384. 

  384. 

  385.     getChoices(&newGUI);
    386. 

  386.     applyGUI(&newGUI);
    387. 

  387. }
    388. 

  388. 

  389. static void save(button b)
    390. 

  390. {
    391. 

  391.     char *file, buf[256], *p;
    392. 

  392.     FILE *fp;
    393. 

  393. 

  394.     setuserfilter("All files (*.*)\0*.*\0\0");
    395. 

  395.     strcpy(buf, getenv("R_USER"));
    396. 

  396.     R_fixbackslash(buf);
    397. 

  397.     file = askfilesavewithdir(G_("Select directory for file 'Rconsole'"),
    398. 

  398. 			      "Rconsole", buf);
    399. 

  399.     if(!file) return;
    400. 

  400.     strcpy(buf, file);
    401. 

  401.     p = buf + strlen(buf) - 2;
    402. 

  402.     if(!strncmp(p, ".*", 2)) *p = '\0';
    403. 

  403. 

  404.     fp = R_fopen(buf, "w");
    405. 

  405.     if(fp == NULL) {
    406. 

  406. 	MessageBox(0, "Cannot open file to fp",
    407. 

  407. 		   "Configuration Save Error",
    408. 

  408. 		   MB_TASKMODAL | MB_ICONSTOP | MB_OK);
    409. 

  409. 	return;
    410. 

  410.     }
    411. 

  411. 

  412.     fprintf(fp, "%s\n%s\n%s\n\n%s\n%s\n",
    413. 

  413. 	    "# Optional parameters for the console and the pager",
    414. 

  414. 	    "# The system-wide copy is in rwxxxx/etc.",
    415. 

  415. 	    "# A user copy can be installed in `R_USER'.",
    416. 

  416. 	    "## Style",
    417. 

  417. 	    "# This can be `yes' (for MDI) or `no' (for SDI).");
    418. 

  418.     fprintf(fp, "MDI = %s\n",  ischecked(rb_mdi)?"yes":"no");
    419. 

  419.     fprintf(fp, "%s\n%s%s\n%s%s\n\n",
    420. 

  420. 	    "# the next two are only relevant for MDI",
    421. 

  421. 	    "toolbar = ", ischecked(toolbar)?"yes":"no",
    422. 

  422. 	    "statusbar = ", ischecked(statusbar)?"yes":"no");
    423. 

  423. 

  424.     fprintf(fp, "%s\n%s\n%s\n%s\n%s\n",
    425. 

  425. 	    "## Font.",
    426. 

  426. 	    "# Please use only fixed width font.",
    427. 

  427. 	    "# If font=FixedFont the system fixed font is used; in this case",
    428. 

  428. 	    "# points and style are ignored. If font begins with \"TT \", only",
    429. 

  429. 	    "# True Type fonts are searched for.");
    430. 

  430.     fprintf(fp, "font = %s%s\npoints = %s\nstyle = %s # Style can be normal, bold, italic\n\n\n",
    431. 

  431. 	    ischecked(tt_font)?"TT ":"",
    432. 

  432. 	    gettext(f_font),
    433. 

  433. 	    gettext(d_point),
    434. 

  434. 	    gettext(f_style));
    435. 

  435.     fprintf(fp, "# Dimensions (in characters) of the console.\n");
    436. 

  436.     fprintf(fp, "rows = %s\ncolumns = %s\n",
    437. 

  437. 	    gettext(f_crows), gettext(f_ccols));
    438. 

  438.     fprintf(fp, "# Dimensions (in characters) of the internal pager.\n");
    439. 

  439.     fprintf(fp, "pgrows = %s\npgcolumns = %s\n",
    440. 

  440. 	    gettext(f_prows), gettext(f_pcols));
    441. 

  441.     fprintf(fp, "# should options(width=) be set to the console width?\n");
    442. 

  442.     fprintf(fp, "setwidthonresize = %s\n\n",
    443. 

  443. 	    ischecked(c_resize) ? "yes" : "no");
    444. 

  444.     fprintf(fp, "# memory limits for the console scrolling buffer, in chars and lines\n");
    445. 

  445.     fprintf(fp, "bufbytes = %s\nbuflines = %s\n\n",
    446. 

  446. 	    gettext(f_cbb), gettext(f_cbl));
    447. 

  447.     fprintf(fp, "# Initial position of the console (pixels, relative to the workspace for MDI)\n");
    448. 

  448.     fprintf(fp, "xconsole = %s\nyconsole = %s\n\n",
    449. 

  449. 	    gettext(f_cx), gettext(f_cy));
    450. 

  450.     fprintf(fp, "%s\n%s\n%s\n%s\n%s\n%s\n\n",
    451. 

  451. 	    "# Dimension of MDI frame in pixels",
    452. 

  452. 	    "# Format (w*h+xorg+yorg) or use -ve w and h for offsets from right bottom",
    453. 

  453. 	    "# This will come up maximized if w==0",
    454. 

  454. 	    "# MDIsize = 0*0+0+0",
    455. 

  455. 	    "# MDIsize = 1000*800+100+0",
    456. 

  456. 	    "# MDIsize = -50*-50+50+50  # 50 pixels space all round");
    457. 

  457.     fprintf(fp, "%s\n%s\n%s\npagerstyle = %s\n\n\n",
    458. 

  458. 	    "# The internal pager can displays help in a single window",
    459. 

  459. 	    "# or in multiple windows (one for each topic)",
    460. 

  460. 	    "# pagerstyle can be set to `singlewindow' or `multiplewindows'",
    461. 

  461. 	    ischecked(rb_mwin) ? "multiplewindows" : "singlewindow");
    462. 

  462. 

  463.     fprintf(fp, "## Colours for console and pager(s)\n# (see rwxxxx/etc/rgb.txt for the known colours).\n");
    464. 

  464.     for (int i=0; i<numGuiColors; i++)
    465. 

  465.     	fprintf(fp, "%s = %s\n", GuiElementNames[i], rgbtoname(dialogColors[i]));
    466. 

  466.     fprintf(fp, "\n\n%s\n%s\nxgraphics = %s\nygraphics = %s\n",
    467. 

  467. 	    "## Initial position of the graphics window",
    468. 

  468. 	    "## (pixels, <0 values from opposite edge)",
    469. 

  469. 	    gettext(f_grx), gettext(f_gry));
    470. 

  470.     fprintf(fp, "\n\n%s\nlanguage = %s\n",
    471. 

  471. 	    "## Language for messages",
    472. 

  472. 	    gettext(f_lang));
    473. 

  473.     fprintf(fp, "\n\n## Default setting for console buffering: 'yes' or 'no'\n");
    474. 

  474.     fprintf(fp, "buffered = %s\n",
    475. 

  475. 	    ischecked(c_buff) ? "yes" : "no");
    476. 

  476.     fclose(fp);
    477. 

  477. }
    478. 

  478. 

  479. static void load(button b) /* button callback */
    480. 

  480. {
    481. 

  481.     char *optf, buf[256];
    482. 

  482.     struct structGUI newGUI;
    483. 

  483. 

  484.     setuserfilter("All files (*.*)\0*.*\0\0");
    485. 

  485.     strcpy(buf, getenv("R_USER"));
    486. 

  486.     R_fixbackslash(buf);
    487. 

  487.     optf = askfilenamewithdir(G_("Select 'Rconsole' file"), "Rconsole", buf);
    488. 

  488.     if(!optf) return;
    489. 

  489. 

  490.     getChoices(&newGUI);
    491. 

  491.     if (loadRconsole(&newGUI, optf)) {
    492. 

  492. 	cleanup();
    493. 

  493. 	showDialog(&newGUI);
    494. 

  494.     }
    495. 

  495. }
    496. 

  496. 

  497. int loadRconsole(Gui gui, const char *optf)
    498. 

  498. {
    499. 

  499.     int ok, done, cfgerr;
    500. 

  500.     char *opt[2];
    501. 

  501. 

  502.     if (!optopenfile(optf)) {
    503. 

  503. 	return 0; /* this should not happen unless there are permission problems, etc */
    504. 

  504.     }
    505. 

  505.     cfgerr = 0;
    506. 

  506.     while ((ok = optread(opt, '='))) {
    507. 

  507. 	done = 0;
    508. 

  508. 	if (ok == 2) {
    509. 

  509. 	    if (!strcmp(opt[0], "font")) {
    510. 

  510. 		if(strlen(opt[1]) > 127) opt[1][127] = '\0';
    511. 

  511. 		gui->tt_font = FALSE;
    512. 

  512. 		{
    513. 

  513. 		    const char *pf;
    514. 

  514. 		    if ((strlen(opt[1]) > 1) &&
    515. 

  515. 			(opt[1][0] == 'T') && (opt[1][1] == 'T')) {
    516. 

  516. 			gui->tt_font = TRUE;
    517. 

  517. 			for (pf = opt[1]+2; isspace(*pf) ; pf++);
    518. 

  518. 		    } else pf = opt[1];
    519. 

  519. 		    strcpy(gui->font, pf);
    520. 

  520. 		}
    521. 

  521. 		done = 1;
    522. 

  522. 	    }
    523. 

  523. 	    if (!strcmp(opt[0], "points")) {
    524. 

  524. 		gui->pointsize = atoi(opt[1]);
    525. 

  525. 		done = 1;
    526. 

  526. 	    }
    527. 

  527. 	    if (!strcmp(opt[0], "style")) {
    528. 

  528. 		strcpy(gui->style, opt[1]);
    529. 

  529. 		done = 1;
    530. 

  530. 	    }
    531. 

  531. 	    if (!strcmp(opt[0], "rows")) {
    532. 

  532. 		gui->crows = atoi(opt[1]);
    533. 

  533. 		done = 1;
    534. 

  534. 	    }
    535. 

  535. 	    if (!strcmp(opt[0], "columns")) {
    536. 

  536. 		gui->ccols = atoi(opt[1]);
    537. 

  537. 		done = 1;
    538. 

  538. 	    }
    539. 

  539. 	    if (!strcmp(opt[0], "xconsole")) {
    540. 

  540. 		gui->cx = atoi(opt[1]);
    541. 

  541. 		done = 1;
    542. 

  542. 	    }
    543. 

  543. 	    if (!strcmp(opt[0], "yconsole")) {
    544. 

  544. 		gui->cy = atoi(opt[1]);
    545. 

  545. 		done = 1;
    546. 

  546. 	    }
    547. 

  547. 	    if (!strcmp(opt[0], "xgraphics")) {
    548. 

  548. 		gui->grx = atoi(opt[1]);
    549. 

  549. 		done = 1;
    550. 

  550. 	    }
    551. 

  551. 	    if (!strcmp(opt[0], "ygraphics")) {
    552. 

  552. 		gui->gry = atoi(opt[1]);
    553. 

  553. 		done = 1;
    554. 

  554. 	    }
    555. 

  555. 	    if (!strcmp(opt[0], "pgrows")) {
    556. 

  556. 		gui->prows = atoi(opt[1]);
    557. 

  557. 		done = 1;
    558. 

  558. 	    }
    559. 

  559. 	    if (!strcmp(opt[0], "pgcolumns")) {
    560. 

  560. 		gui->pcols = atoi(opt[1]);
    561. 

  561. 		done = 1;
    562. 

  562. 	    }
    563. 

  563. 	    if (!strcmp(opt[0], "pagerstyle")) {
    564. 

  564. 		if (!strcmp(opt[1], "singlewindow"))
    565. 

  565. 		    gui->pagerMultiple = 0;
    566. 

  566. 		else
    567. 

  567. 		    gui->pagerMultiple = 1;
    568. 

  568. 		done = 1;
    569. 

  569. 	    }
    570. 

  570. 	    if (!strcmp(opt[0], "bufbytes")) {
    571. 

  571. 		gui->cbb = atoi(opt[1]);
    572. 

  572. 		done = 1;
    573. 

  573. 	    }
    574. 

  574. 	    if (!strcmp(opt[0], "buflines")) {
    575. 

  575. 		gui->cbl = atoi(opt[1]);
    576. 

  576. 		done = 1;
    577. 

  577. 	    }
    578. 

  578. #ifdef USE_MDI
    579. 

  579. 	    if (!strcmp(opt[0], "MDI")) {
    580. 

  580. 		if (!strcmp(opt[1], "yes"))
    581. 

  581. 		    gui->MDI = 1;
    582. 

  582. 		else if (!strcmp(opt[1], "no"))
    583. 

  583. 		    gui->MDI = 0;
    584. 

  584. 		done = 1;
    585. 

  585. 	    }
    586. 

  586. 	    if (!strcmp(opt[0], "toolbar")) {
    587. 

  587. 		if (!strcmp(opt[1], "yes"))
    588. 

  588. 		    gui->toolbar = 1;
    589. 

  589. 		else if (!strcmp(opt[1], "no"))
    590. 

  590. 		    gui->toolbar = 0;
    591. 

  591. 		done = 1;
    592. 

  592. 	    }
    593. 

  593. 	    if (!strcmp(opt[0], "statusbar")) {
    594. 

  594. 		if (!strcmp(opt[1], "yes"))
    595. 

  595. 		    gui->statusbar = 1;
    596. 

  596. 		else if (!strcmp(opt[1], "no"))
    597. 

  597. 		    gui->statusbar = 0;
    598. 

  598. 		done = 1;
    599. 

  599. 	    }
    600. 

  600. 	    if (!strcmp(opt[0], "MDIsize")) { /* wxh+x+y */
    601. 

  601. 		int x=0, y=0, w=0, h=0, sign;
    602. 

  602. 		char *p = opt[1];
    603. 

  603. 

  604. 		if(*p == '-') {sign = -1; p++;} else sign = +1;
    605. 

  605. 		for(w=0; isdigit(*p); p++) w = 10*w + (*p - '0');
    606. 

  606. 		w *= sign;
    607. 

  607. 		p++;
    608. 

  608. 

  609. 		if(*p == '-') {sign = -1; p++;} else sign = +1;
    610. 

  610. 		for(h=0; isdigit(*p); p++) h = 10*h + (*p - '0');
    611. 

  611. 		h *= sign;
    612. 

  612. 

  613. 		if(*p == '-') sign = -1; else sign = +1;
    614. 

  614. 		p++;
    615. 

  615. 		for(x=0; isdigit(*p); p++) x = 10*x + (*p - '0');
    616. 

  616. 		x *= sign;
    617. 

  617. 		if(*p == '-') sign = -1; else sign = +1;
    618. 

  618. 		p++;
    619. 

  619. 		for(y=0; isdigit(*p); p++) y = 10*y + (*p - '0');
    620. 

  620. 		y *= sign;
    621. 

  621. 

  622. 		gui->MDIsize = rect(x, y, w, h);
    623. 

  623. 

  624. 		done = 1;
    625. 

  625. 	    }
    626. 

  626. #endif
    627. 

  627. 	    for (int i=0; i<numGuiColors; i++) 
    628. 

  628. 		if (!strcmp(opt[0], GuiElementNames[i])) {
    629. 

  629. 		    if (!strcmpi(opt[1], "Windows"))
    630. 

  630. 			gui->guiColors[i] = myGetSysColor(COLOR_WINDOW);
    631. 

  631. 		    else gui->guiColors[i] = nametorgb(opt[1]);
    632. 

  632. 		    if (gui->guiColors[i] != Transparent)
    633. 

  633. 		    	done = 1;
    634. 

  634. 		}
    635. 

  635. 	    if (!strcmp(opt[0], "setwidthonresize")) {
    636. 

  636. 		if (!strcmp(opt[1], "yes"))
    637. 

  637. 		    gui->setWidthOnResize = 1;
    638. 

  638. 		else if (!strcmp(opt[1], "no"))
    639. 

  639. 		    gui->setWidthOnResize = 0;
    640. 

  640. 		done = 1;
    641. 

  641. 	    }
    642. 

  642. 	    if (!strcmp(opt[0], "language")) {
    643. 

  643. 		strcpy(gui->language, opt[1]);
    644. 

  644. 		done = 1;
    645. 

  645. 	    }
    646. 

  646. 	    if (!strcmp(opt[0], "buffered")) {
    647. 

  647. 		if (!strcmp(opt[1], "yes"))
    648. 

  648. 		    gui->buffered = 1;
    649. 

  649. 		else if (!strcmp(opt[1], "no"))
    650. 

  650. 		    gui->buffered = 0;
    651. 

  651. 		done = 1;
    652. 

  652. 	    }
    653. 

  653. 	} else if (ok == 3) { /* opt[1] == "" */
    654. 

  654. 	    if (!strcmp(opt[0], "language")) {
    655. 

  655. 		strcpy(gui->language, opt[1]);
    656. 

  656. 		done = 1;
    657. 

  657. 	    }
    658. 

  658. 	}
    659. 

  659. 	if (!done) {
    660. 

  660. 	    char  buf[128];
    661. 

  661. 

  662. 	    snprintf(buf, 128, G_("Error at line %d of file %s"),
    663. 

  663. 		     optline(), optfile());
    664. 

  664. 	    askok(buf);
    665. 

  665. 	    cfgerr = 1;
    666. 

  666. 	}
    667. 

  667.     }
    668. 

  668.     return !cfgerr;
    669. 

  669. }
    670. 

  670. 

  671. static void apply(button b) /* button callback */
    672. 

  672. {
    673. 

  673.     do_apply(); /* to be used outside button callbacks */
    674. 

  674. }
    675. 

  675. 

  676. static void cancel(button b)
    677. 

  677. {
    678. 

  678.     cleanup();
    679. 

  679.     show(RConsole);
    680. 

  680. }
    681. 

  681. 

  682. static void ok(button b)
    683. 

  683. {
    684. 

  684.     do_apply();
    685. 

  685.     cleanup();
    686. 

  686.     show(RConsole);
    687. 

  687. }
    688. 

  688. 

  689. static void cMDI(button b)
    690. 

  690. {
    691. 

  691.     enable(toolbar);
    692. 

  692.     enable(statusbar);
    693. 

  693. }
    694. 

  694. 

  695. static void cSDI(button b)
    696. 

  696. {
    697. 

  697.     disable(toolbar);
    698. 

  698.     disable(statusbar);
    699. 

  699. }
    700. 

  700. 

  701. static rgb whichbg[numGuiColors] = { consolebg, consolebg, consolebg,
    702. 

  702.                                      pagerbg, pagerbg, pagerbg,
    703. 

  703.                                      dataeditbg, dataeditbg, dataeditbg,
    704. 

  704.                                      editorbg, editorbg };
    705. 

  705. static rgb whichfg[numGuiColors] = { consolefg, consolefg, consoleuser,
    706. 

  706. 				     pagerfg, pagerfg, pagerhighlight,
    707. 

  707. 				     dataeditfg, dataeditfg, dataedituser,
    708. 

  708. 				     editorfg, editorfg };
    709. 

  709. static void clickColor(control c, int argument)
    710. 

  710. {
    711. 

  711.     int element = cmatch(gettext(guielement), GuiElementNames);
    712. 

  712.     dialogColors[element] = nametorgb(ColorName[argument]);
    713. 

  713.     setforeground(guisample, dialogColors[whichfg[element]]);
    714. 

  714.     setbackground(guisample, dialogColors[whichbg[element]]);
    715. 

  715. }
    716. 

  716. 

  717. static void changeElement(control c, int argument)
    718. 

  718. {   
    719. 

  719.     int newcolor = rgbtonum(dialogColors[argument]);
    720. 

  720.     setlistitem(guicolor, newcolor);
    721. 

  721.     clickColor(guicolor, newcolor);
    722. 

  722. }
    723. 

  723. 

  724. static void changeFont(control c)
    725. 

  725. {
    726. 

  726.     char fontname[LF_FACESIZE+4];
    727. 

  727.     
    728. 

  728.     if (samplefont) delobj(samplefont);
    729. 

  729.     
    730. 

  730.     if(ischecked(tt_font)) strcpy(fontname, "TT "); else strcpy(fontname, "");
    731. 

  731.     
    732. 

  732.     if (sampleFontNum >= 0) {
    733. 

  733.     	strcat(fontname,  FontsList[sampleFontNum]);
    734. 

  734.     } else 
    735. 

  735.     	strcat(fontname, gettext(f_font));
    736. 

  736.     
    737. 

  737.     samplefont = gnewfont(NULL, fontname, sampleStyle, samplePointsize, 0.0, 1);
    738. 

  738.     settextfont(guisample, samplefont);
    739. 

  739.     clickColor(c, getlistitem(guicolor));
    740. 

  740. }
    741. 

  741. 

  742. static void scrollFont(scrollbar s, int position)
    743. 

  743. {
    744. 

  744.     sampleFontNum = position;
    745. 

  745.     changeFont(s);
    746. 

  746. }
    747. 

  747. 

  748. static void scrollPoints(scrollbar s, int position)
    749. 

  749. {
    750. 

  750.     samplePointsize = atoi(PointsList[position]);
    751. 

  751.     changeFont(s);
    752. 

  752. }
    753. 

  753. 

  754. static void scrollStyle(scrollbar s, int position)
    755. 

  755. {
    756. 

  756.     sampleStyle = Plain;
    757. 

  757.     if (!strcmp(gettext(f_style), "bold")) sampleStyle = Bold;
    758. 

  758.     if (!strcmp(gettext(f_style), "italic")) sampleStyle = Italic;    
    759. 

  759.     changeFont(s);
    760. 

  760. }
    761. 

  761. 

  762. static void showDialog(Gui gui)
    763. 

  763. {
    764. 

  764.     char buf[100];
    765. 

  765. 

  766.     wconfig = newwindow(G_("Rgui Configuration Editor"), rect(0, 0, 550, 450),
    767. 

  767. 			Titlebar | Centered | Modal);
    768. 

  768.     setbackground(wconfig, dialog_bg());
    769. 

  769.     l_mdi = newlabel("Single or multiple windows",
    770. 

  770. 		     rect(10, 10, 140, 20), AlignLeft);
    771. 

  771.     rb_mdi = newradiobutton("MDI", rect(150, 10 , 70, 20), cMDI);
    772. 

  772.     rb_sdi = newradiobutton("SDI", rect(220, 10 , 70, 20), cSDI);
    773. 

  773. 

  774. 

  775.     toolbar = newcheckbox("MDI toolbar", rect(300, 10, 100, 20), NULL);
    776. 

  776.     if(gui->toolbar) check(toolbar);
    777. 

  777.     statusbar = newcheckbox("MDI statusbar", rect(420, 10, 130, 20), NULL);
    778. 

  778.     if(gui->statusbar) check(statusbar);
    779. 

  779.     if(gui->MDI) {
    780. 

  780. 	check(rb_mdi); cMDI(rb_mdi);
    781. 

  781.     } else {
    782. 

  782. 	check(rb_sdi); cSDI(rb_sdi);
    783. 

  783.     }
    784. 

  784. 

  785.     l_mwin = newlabel("Pager style", rect(10, 40, 90, 20), AlignLeft);
    786. 

  786.     g_mwin = newradiogroup();
    787. 

  787.     rb_mwin = newradiobutton("multiple windows", rect(150, 40, 150, 20), NULL);
    788. 

  788.     rb_swin = newradiobutton("single window", rect(150, 60 , 150, 20), NULL);
    789. 

  789.     if(gui->pagerMultiple) check(rb_mwin); else check(rb_swin);
    790. 

  790. 

  791.     l_lang = newlabel("Language for menus\nand messages",
    792. 

  792. 		      rect(320, 40, 130, 40), AlignLeft);
    793. 

  793.     f_lang = newfield(gui->language, rect(450, 45, 60, 20));
    794. 

  794. 

  795. /* Font, pointsize, style */
    796. 

  796. 

  797.     l_font = newlabel("Font", rect(10, 100, 40, 20), AlignLeft);
    798. 

  798. 

  799.     f_font = newdropfield(FontsList, rect(50, 100, 120, 20), scrollFont);
    800. 

  800.     tt_font = newcheckbox("TrueType only", rect(180, 100, 110, 20), changeFont);
    801. 

  801.     if (gui->tt_font) check(tt_font);
    802. 

  802.     settext(f_font, gui->font);
    803. 

  803. 

  804.     l_point = newlabel("size", rect(310, 100, 30, 20), AlignLeft);
    805. 

  805.     d_point = newdropfield(PointsList, rect(345, 100, 50, 20), scrollPoints);
    806. 

  806.     sprintf(buf, "%d", gui->pointsize);
    807. 

  807.     settext(d_point, buf);
    808. 

  808.     l_style = newlabel("style", rect(410, 100, 40, 20), AlignLeft);
    809. 

  809.     f_style = newdroplist(StyleList, rect(450, 100, 80, 20), scrollStyle);
    810. 

  810.     setlistitem(f_style, cmatch(gui->style, StyleList));
    811. 

  811. 

  812. /* Console size, set widthonresize */
    813. 

  813.     l_crows = newlabel("Console   rows", rect(10, 150, 100, 20), AlignLeft);
    814. 

  814.     sprintf(buf, "%d", gui->crows);
    815. 

  815.     f_crows = newfield(buf, rect(110, 150, 30, 20));
    816. 

  816.     l_ccols = newlabel("columns", rect(150, 150, 60, 20), AlignLeft);
    817. 

  817.     sprintf(buf, "%d", gui->ccols);
    818. 

  818.     f_ccols = newfield(buf, rect(220, 150, 30, 20));
    819. 

  819.     l_cx = newlabel("Initial left", rect(270, 150, 70, 20), AlignLeft);
    820. 

  820.     sprintf(buf, "%d", gui->cx);
    821. 

  821.     f_cx = newfield(buf, rect(350, 150, 40, 20));
    822. 

  822.     l_cy = newlabel("top", rect(430, 150, 30, 20), AlignLeft);
    823. 

  823.     sprintf(buf, "%d", gui->cy);
    824. 

  824.     f_cy = newfield(buf, rect(480, 150, 40, 20));
    825. 

  825. 

  826.     c_resize = newcheckbox("set options(width) on resize?",
    827. 

  827. 			   rect(20, 175, 200, 20), NULL);
    828. 

  828.     if(gui->setWidthOnResize) check(c_resize);
    829. 

  829. 

  830.     l_cbb = newlabel("buffer chars", rect(270, 175, 70, 20), AlignLeft);
    831. 

  831.     sprintf(buf, "%d", gui->cbb);
    832. 

  832.     f_cbb = newfield(buf, rect(350, 175, 60, 20));
    833. 

  833.     l_cbl = newlabel("lines", rect(430, 175, 50, 20), AlignLeft);
    834. 

  834.     sprintf(buf, "%d", gui->cbl);
    835. 

  835.     f_cbl = newfield(buf, rect(480, 175, 40, 20));
    836. 

  836. 

  837.     c_buff = newcheckbox("buffer console by default?",
    838. 

  838. 			 rect(20, 190, 200, 20), NULL);
    839. 

  839.     if(gui->buffered) check(c_buff);
    840. 

  840. 

  841. /* Pager size */
    842. 

  842.     l_prows = newlabel("Pager   rows", rect(10, 220, 100, 20), AlignLeft);
    843. 

  843.     sprintf(buf, "%d", gui->prows);
    844. 

  844.     f_prows = newfield(buf, rect(110, 220, 30, 20));
    845. 

  845.     l_pcols = newlabel("columns", rect(150, 220, 60, 20), AlignLeft);
    846. 

  846.     sprintf(buf, "%d", gui->pcols);
    847. 

  847.     f_pcols = newfield(buf, rect(220, 220, 30, 20));
    848. 

  848. 

  849. /* Graphics window */
    850. 

  850.     l_grx = newlabel("Graphics windows: initial left",
    851. 

  851. 		     rect(10, 260, 190, 20), AlignLeft);
    852. 

  852.     sprintf(buf, "%d", gui->grx);
    853. 

  853.     f_grx = newfield(buf, rect(200, 260, 40, 20));
    854. 

  854.     l_gry = newlabel("top", rect(270, 260, 30, 20), AlignLeft);
    855. 

  855.     sprintf(buf, "%d", gui->gry);
    856. 

  856.     f_gry = newfield(buf, rect(300, 260, 40, 20));
    857. 

  857. 

  858. /* Font colours */
    859. 

  859.     l_cols = newlabel("Console and Pager Colours",
    860. 

  860. 		      rect(10, 300, 520, 20), AlignCenter);
    861. 

  861. 			      
    862. 

  862.     guielement = newlistbox(GuiElementNames, rect(50, 320, 100, 80), changeElement, NULL);
    863. 

  863.     guicolor = newlistbox(ColorName, rect(205, 320, 100, 80), clickColor, NULL);
    864. 

  864.     guisample = newrichtextarea("Sample text", rect(350, 320, 150, 55));
    865. 

  865. 	
    866. 

  866.     for (int i=0; i<numGuiColors; i++)
    867. 

  867.     	dialogColors[i] = gui->guiColors[i];
    868. 

  868.     	
    869. 

  869.     setlistitem(guielement, 0);
    870. 

  870.     changeElement(guielement, 0);
    871. 

  871.     sampleFontNum = cmatch(gettext(f_font), FontsList);
    872. 

  872.     samplePointsize = atoi(gettext(d_point));
    873. 

  873.     scrollStyle(f_style, 0); /* the 0 is ignored */
    874. 

  874. 

  875.     bApply = newbutton("Apply", rect(50, 410, 70, 25), apply);
    876. 

  876.     bSave = newbutton("Save...", rect(130, 410, 70, 25), save);
    877. 

  877.     bLoad = newbutton("Load...", rect(210, 410, 70, 25), load);
    878. 

  878.     bOK = newbutton("OK", rect(350, 410, 70, 25), ok);
    879. 

  879.     bCancel = newbutton("Cancel", rect(430, 410, 70, 25), cancel);
    880. 

  880.     show(wconfig);
    881. 

  881. }
    882. 

  882. 

  883. void Rgui_configure()
    884. 

  884. {
    885. 

  885.     struct structGUI curGUI;
    886. 

  886. 

  887.     getActive(&curGUI);
    888. 

  888.     showDialog(&curGUI);
    889. 

  889. }
    890. 

  890.