programs/wineconsole/registry.c

   1 /*
   2  * an application for displaying Win32 console
   3  *      registry and init functions
   4  *
   5  * Copyright 2001 Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winreg.h"
  27 #include "winecon_private.h"
  28
  29 #include "wine/unicode.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(wineconsole);
  33
  34 static const WCHAR wszColorTable[]        = {'C','o','l','o','r','T','a','b','l','e',0};
  35 static const WCHAR wszConsole[]           = {'C','o','n','s','o','l','e',0};
  36 static const WCHAR wszCursorSize[]        = {'C','u','r','s','o','r','S','i','z','e',0};
  37 static const WCHAR wszCursorVisible[]     = {'C','u','r','s','o','r','V','i','s','i','b','l','e',0};
  38 static const WCHAR wszEditionMode[]       = {'E','d','i','t','i','o','n','M','o','d','e',0};
  39 static const WCHAR wszExitOnDie[]         = {'E','x','i','t','O','n','D','i','e',0};
  40 static const WCHAR wszFaceName[]          = {'F','a','c','e','N','a','m','e',0};
  41 static const WCHAR wszFontSize[]          = {'F','o','n','t','S','i','z','e',0};
  42 static const WCHAR wszFontWeight[]        = {'F','o','n','t','W','e','i','g','h','t',0};
  43 static const WCHAR wszHistoryBufferSize[] = {'H','i','s','t','o','r','y','B','u','f','f','e','r','S','i','z','e',0};
  44 static const WCHAR wszHistoryNoDup[]      = {'H','i','s','t','o','r','y','N','o','D','u','p',0};
  45 static const WCHAR wszInsertMode[]        = {'I','n','s','e','r','t','M','o','d','e',0};
  46 static const WCHAR wszMenuMask[]          = {'M','e','n','u','M','a','s','k',0};
  47 static const WCHAR wszPopupColors[]       = {'P','o','p','u','p','C','o','l','o','r','s',0};
  48 static const WCHAR wszQuickEdit[]         = {'Q','u','i','c','k','E','d','i','t',0};
  49 static const WCHAR wszScreenBufferSize[]  = {'S','c','r','e','e','n','B','u','f','f','e','r','S','i','z','e',0};
  50 static const WCHAR wszScreenColors[]      = {'S','c','r','e','e','n','C','o','l','o','r','s',0};
  51 static const WCHAR wszWindowSize[]        = {'W','i','n','d','o','w','S','i','z','e',0};
  52
  53 static const WCHAR color_name_fmt[] = {'%','s','%','0','2','d',0};
  54
  55 #define NUM_COLORS 16
  56
  57 void WINECON_DumpConfig(const char* pfx, const struct config_data* cfg)
  58 {
  59     WINE_TRACE("%s cell=(%u,%u) cursor=(%d,%d) attr=%02x pop-up=%02x font=%s/%u hist=%u/%d flags=%c%c%c "
  60                "msk=%08x sb=(%u,%u) win=(%u,%u)x(%u,%u) edit=%u registry=%s\n",
  61                pfx, cfg->cell_width, cfg->cell_height, cfg->cursor_size, cfg->cursor_visible, cfg->def_attr,
  62                cfg->popup_attr, wine_dbgstr_w(cfg->face_name), cfg->font_weight, cfg->history_size,
  63                cfg->history_nodup ? 1 : 2, cfg->insert_mode ? 'I' : 'i', cfg->quick_edit ? 'Q' : 'q',
  64                cfg->exit_on_die ? 'X' : 'x', cfg->menu_mask, cfg->sb_width, cfg->sb_height,
  65                cfg->win_pos.X, cfg->win_pos.Y, cfg->win_width, cfg->win_height, cfg->edition_mode,
  66                wine_dbgstr_w(cfg->registry));
  67 }
  68
  69 /******************************************************************
  70  *              WINECON_CreateKeyName
  71  *
  72  * Get a proper key name from an appname (mainly convert '\\' to '_')
  73  */
  74 static LPWSTR   WINECON_CreateKeyName(LPCWSTR kn)
  75 {
  76     LPWSTR      ret = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(kn) + 1) * sizeof(WCHAR));
  77     LPWSTR      ptr = ret;
  78
  79     if (!ptr) WINECON_Fatal("OOM");
  80
  81     do
  82     {
  83         *ptr++ = *kn == '\\' ? '_' : *kn;
  84     } while (*kn++ != 0);
  85     return ret;
  86 }
  87
  88 /******************************************************************
  89  *              WINECON_RegLoadHelper
  90  *
  91  * Read the basic configuration from any console key or subkey
  92  */
  93 static void WINECON_RegLoadHelper(HKEY hConKey, struct config_data* cfg)
  94 {
  95     int   i;
  96     DWORD type, count, val;
  97     WCHAR color_name[13];
  98
  99     for (i = 0; i < NUM_COLORS; i++)
 100     {
 101         sprintfW(color_name, color_name_fmt, wszColorTable, i);
 102         count = sizeof(val);
 103         if (!RegQueryValueExW(hConKey, color_name, 0, &type, (LPBYTE)&val, &count))
 104             cfg->color_map[i] = val;
 105     }
 106
 107     count = sizeof(val);
 108     if (!RegQueryValueExW(hConKey, wszCursorSize, 0, &type, (LPBYTE)&val, &count))
 109         cfg->cursor_size = val;
 110
 111     count = sizeof(val);
 112     if (!RegQueryValueExW(hConKey, wszCursorVisible, 0, &type, (LPBYTE)&val, &count))
 113         cfg->cursor_visible = val;
 114
 115     count = sizeof(val);
 116     if (!RegQueryValueExW(hConKey, wszEditionMode, 0, &type, (LPBYTE)&val, &count))
 117         cfg->edition_mode = val;
 118
 119     count = sizeof(val);
 120     if (!RegQueryValueExW(hConKey, wszExitOnDie, 0, &type, (LPBYTE)&val, &count))
 121         cfg->exit_on_die = val;
 122
 123     count = sizeof(cfg->face_name);
 124     RegQueryValueExW(hConKey, wszFaceName, 0, &type, (LPBYTE)&cfg->face_name, &count);
 125
 126     count = sizeof(val);
 127     if (!RegQueryValueExW(hConKey, wszFontSize, 0, &type, (LPBYTE)&val, &count))
 128     {
 129         cfg->cell_height = HIWORD(val);
 130         cfg->cell_width  = LOWORD(val);
 131     }
 132
 133     count = sizeof(val);
 134     if (!RegQueryValueExW(hConKey, wszFontWeight, 0, &type, (LPBYTE)&val, &count))
 135         cfg->font_weight = val;
 136
 137     count = sizeof(val);
 138     if (!RegQueryValueExW(hConKey, wszHistoryBufferSize, 0, &type, (LPBYTE)&val, &count))
 139         cfg->history_size = val;
 140
 141     count = sizeof(val);
 142     if (!RegQueryValueExW(hConKey, wszHistoryNoDup, 0, &type, (LPBYTE)&val, &count))
 143         cfg->history_nodup = val;
 144
 145     count = sizeof(val);
 146     if (!RegQueryValueExW(hConKey, wszInsertMode, 0, &type, (LPBYTE)&val, &count))
 147         cfg->insert_mode = val;
 148
 149     count = sizeof(val);
 150     if (!RegQueryValueExW(hConKey, wszMenuMask, 0, &type, (LPBYTE)&val, &count))
 151         cfg->menu_mask = val;
 152
 153     count = sizeof(val);
 154     if (!RegQueryValueExW(hConKey, wszPopupColors, 0, &type, (LPBYTE)&val, &count))
 155         cfg->popup_attr = val;
 156
 157     count = sizeof(val);
 158     if (!RegQueryValueExW(hConKey, wszQuickEdit, 0, &type, (LPBYTE)&val, &count))
 159         cfg->quick_edit = val;
 160
 161     count = sizeof(val);
 162     if (!RegQueryValueExW(hConKey, wszScreenBufferSize, 0, &type, (LPBYTE)&val, &count))
 163     {
 164         cfg->sb_height = HIWORD(val);
 165         cfg->sb_width  = LOWORD(val);
 166     }
 167
 168     count = sizeof(val);
 169     if (!RegQueryValueExW(hConKey, wszScreenColors, 0, &type, (LPBYTE)&val, &count))
 170         cfg->def_attr = val;
 171
 172     count = sizeof(val);
 173     if (!RegQueryValueExW(hConKey, wszWindowSize, 0, &type, (LPBYTE)&val, &count))
 174     {
 175         cfg->win_height = HIWORD(val);
 176         cfg->win_width  = LOWORD(val);
 177     }
 178
 179     /* win_pos isn't read from registry */
 180 }
 181
 182 /******************************************************************
 183  *              WINECON_RegLoad
 184  *
 185  *
 186  */
 187 void WINECON_RegLoad(const WCHAR* appname, struct config_data* cfg)
 188 {
 189     static const COLORREF color_map[NUM_COLORS] =
 190     {
 191         RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x80), RGB(0x00, 0x80, 0x00), RGB(0x00, 0x80, 0x80),
 192         RGB(0x80, 0x00, 0x00), RGB(0x80, 0x00, 0x80), RGB(0x80, 0x80, 0x00), RGB(0xC0, 0xC0, 0xC0),
 193         RGB(0x80, 0x80, 0x80), RGB(0x00, 0x00, 0xFF), RGB(0x00, 0xFF, 0x00), RGB(0x00, 0xFF, 0xFF),
 194         RGB(0xFF, 0x00, 0x00), RGB(0xFF, 0x00, 0xFF), RGB(0xFF, 0xFF, 0x00), RGB(0xFF, 0xFF, 0xFF),
 195     };
 196
 197     int  i;
 198     HKEY hConKey;
 199
 200     WINE_TRACE("loading %s registry settings.\n", appname ? wine_dbgstr_w(appname) : "default");
 201
 202     /* first set default values */
 203     for (i = 0; i < NUM_COLORS; i++)
 204     {
 205         cfg->color_map[i] = color_map[i];
 206     }
 207     cfg->cursor_size = 25;
 208     cfg->cursor_visible = 1;
 209     cfg->exit_on_die = 1;
 210     memset(cfg->face_name, 0, sizeof(cfg->face_name));
 211     cfg->cell_height = 12;
 212     cfg->cell_width  = 8;
 213     cfg->font_weight = 0;
 214     cfg->history_size = 50;
 215     cfg->history_nodup = 0;
 216     cfg->insert_mode = 1;
 217     cfg->menu_mask = 0;
 218     cfg->popup_attr = 0xF5;
 219     cfg->quick_edit = 0;
 220     cfg->sb_height = 25;
 221     cfg->sb_width  = 80;
 222     cfg->def_attr = 0x000F;
 223     cfg->win_height = 25;
 224     cfg->win_width  = 80;
 225     cfg->win_pos.X = 0;
 226     cfg->win_pos.Y = 0;
 227     cfg->edition_mode = 0;
 228     cfg->registry = NULL;
 229
 230     /* then read global settings */
 231     if (!RegOpenKeyW(HKEY_CURRENT_USER, wszConsole, &hConKey))
 232     {
 233         WINECON_RegLoadHelper(hConKey, cfg);
 234         /* if requested, load part related to console title */
 235         if (appname)
 236         {
 237             HKEY        hAppKey;
 238
 239             cfg->registry = WINECON_CreateKeyName(appname);
 240             if (!RegOpenKeyW(hConKey, cfg->registry, &hAppKey))
 241             {
 242                 WINECON_RegLoadHelper(hAppKey, cfg);
 243                 RegCloseKey(hAppKey);
 244             }
 245         }
 246         RegCloseKey(hConKey);
 247     }
 248     WINECON_DumpConfig("load", cfg);
 249 }
 250
 251 /******************************************************************
 252  *              WINECON_RegSaveHelper
 253  *
 254  *
 255  */
 256 static void WINECON_RegSaveHelper(HKEY hConKey, const struct config_data* cfg)
 257 {
 258     int   i;
 259     DWORD val;
 260     WCHAR color_name[13];
 261
 262     WINECON_DumpConfig("save", cfg);
 263
 264     for (i = 0; i < NUM_COLORS; i++)
 265     {
 266         sprintfW(color_name, color_name_fmt, wszColorTable, i);
 267         val = cfg->color_map[i];
 268         RegSetValueExW(hConKey, color_name, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 269     }
 270
 271     val = cfg->cursor_size;
 272     RegSetValueExW(hConKey, wszCursorSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 273
 274     val = cfg->cursor_visible;
 275     RegSetValueExW(hConKey, wszCursorVisible, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 276
 277     val = cfg->edition_mode;
 278     RegSetValueExW(hConKey, wszEditionMode, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 279
 280     val = cfg->exit_on_die;
 281     RegSetValueExW(hConKey, wszExitOnDie, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 282
 283     RegSetValueExW(hConKey, wszFaceName, 0, REG_SZ, (LPBYTE)&cfg->face_name, sizeof(cfg->face_name));
 284
 285     val = MAKELONG(cfg->cell_width, cfg->cell_height);
 286     RegSetValueExW(hConKey, wszFontSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 287
 288     val = cfg->font_weight;
 289     RegSetValueExW(hConKey, wszFontWeight, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 290
 291     val = cfg->history_size;
 292     RegSetValueExW(hConKey, wszHistoryBufferSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 293
 294     val = cfg->history_nodup;
 295     RegSetValueExW(hConKey, wszHistoryNoDup, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 296
 297     val = cfg->insert_mode;
 298     RegSetValueExW(hConKey, wszInsertMode, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 299
 300     val = cfg->menu_mask;
 301     RegSetValueExW(hConKey, wszMenuMask, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 302
 303     val = cfg->popup_attr;
 304     RegSetValueExW(hConKey, wszPopupColors, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 305
 306     val = cfg->quick_edit;
 307     RegSetValueExW(hConKey, wszQuickEdit, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 308
 309     val = MAKELONG(cfg->sb_width, cfg->sb_height);
 310     RegSetValueExW(hConKey, wszScreenBufferSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 311
 312     val = cfg->def_attr;
 313     RegSetValueExW(hConKey, wszScreenColors, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 314
 315     val = MAKELONG(cfg->win_width, cfg->win_height);
 316     RegSetValueExW(hConKey, wszWindowSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
 317 }
 318
 319 /******************************************************************
 320  *              WINECON_RegSave
 321  *
 322  *
 323  */
 324 void WINECON_RegSave(const struct config_data* cfg)
 325 {
 326     HKEY        hConKey;
 327
 328     WINE_TRACE("saving registry settings.\n");
 329     if (RegCreateKeyW(HKEY_CURRENT_USER, wszConsole, &hConKey))
 330     {
 331         WINE_ERR("Can't open registry for saving\n");
 332     }
 333     else
 334     {
 335         if (cfg->registry)
 336         {
 337             HKEY    hAppKey;
 338
 339             if (RegCreateKeyW(hConKey, cfg->registry, &hAppKey))
 340             {
 341                 WINE_ERR("Can't open registry for saving\n");
 342             }
 343             else
 344             {
 345                 /* FIXME: maybe only save the values different from the default value ? */
 346                 WINECON_RegSaveHelper(hAppKey, cfg);
 347                 RegCloseKey(hAppKey);
 348             }
 349         }
 350         else WINECON_RegSaveHelper(hConKey, cfg);
 351         RegCloseKey(hConKey);
 352     }
 353 }