source/common/preferences.cpp

   1 // preferences.cpp - Preferences subroutines.
   2 //
   3 // (c) 2012-2015 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Address Book.
   6 //
   7 // Xestia Address Book is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Address Book is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Address Book. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include <iostream>
  20 #include <iomanip>
  21 #include <ios>
  22 #include <string>
  23 #include <wx/fileconf.h>
  24
  25 #include "preferences.h"
  26
  27 using namespace std;
  28
  29 void SavePreferences();
  30 void LoadPreferences();
  31
  32 XABPreferences::XABPreferences(wxString PreferencesFilename){
  33
  34         // Load the settings into the XABPreferences object using the
  35         // settings file received in PreferencesFilename.
  36
  37         wxString fullprefpath;
  38
  39         bool accountnamevalid, accountaddressvalid, accounttypevalid, accountportvalid,
  40                 accountsslvalid, accountusernamevalid, accountpasswordvalid,
  41                 accountdirprefixvalid, accountdirvalid, accountrefreshvalid = FALSE;
  42
  43         bool preaccountstage = FALSE;
  44         bool isvalidaccount = FALSE;
  45         bool isvalidsection = FALSE;
  46         wxString accountname;
  47         wxString accountaddress;
  48         wxString accounttype;
  49         long accountport = 8080;
  50         long accountrefresh;
  51         bool accountssl;
  52         wxString accountusername;
  53         wxString accountpassword;
  54         wxString accountdirprefix;
  55         wxString accountdir;
  56
  57         wxString firstchar;
  58         string s;
  59
  60         wxString segmentname;
  61         wxString segmentvalue;
  62
  63         // Load the settings.
  64
  65         fullprefpath.Append(PreferencesFilename);
  66         fullprefpath.Append(wxT("settings"));
  67
  68         wxFileConfig *settingfile = new wxFileConfig("", "", fullprefpath);
  69
  70         wxString ValueInc;
  71         settingfile->Read(wxT("SaveWindowPosition"), &ValueInc);
  72
  73         if (ValueInc == wxT("true")){
  74
  75                 SaveWindowPos = TRUE;
  76                 wxRect WindowPosition;
  77
  78                 long PosX, PosY, PosH, PosW = 0;
  79
  80                 bool PosXValid, PosYValid, PosHValid, PosWValid = FALSE;
  81
  82                 PosXValid = settingfile->Read(wxT("WindowPositionX"), &PosX);
  83                 PosYValid = settingfile->Read(wxT("WindowPositionY"), &PosY);
  84                 PosHValid = settingfile->Read(wxT("WindowPositionHeight"), &PosH);
  85                 PosWValid = settingfile->Read(wxT("WindowPositionWidth"), &PosW);
  86
  87                 if (PosXValid == TRUE && PosYValid == TRUE && PosHValid == TRUE && PosWValid == TRUE){
  88
  89                         WindowPosition.SetX((int)PosX);
  90                         WindowPosition.SetY((int)PosY);
  91                         WindowPosition.SetHeight((int)PosH);
  92                         WindowPosition.SetWidth((int)PosW);
  93
  94                 } else {
  95
  96                         WindowPosition.SetX(-1);
  97                         WindowPosition.SetY(-1);
  98                         WindowPosition.SetHeight(500);
  99                         WindowPosition.SetWidth(300);
 100
 101                 }
 102
 103                 SetMainWindowData(WindowPosition);
 104
 105         }
 106
 107         settingfile->Read(wxT("HideLocalAddressBooks"), &ValueInc);
 108
 109         if (ValueInc == wxT("true")){
 110                 HideLocalABs = TRUE;
 111         }
 112
 113         delete settingfile;
 114         settingfile = NULL;
 115
 116         // Load the accounts.
 117
 118         fullprefpath.Clear();
 119         fullprefpath.Append(PreferencesFilename);
 120         fullprefpath.Append(wxT("accounts"));
 121
 122         wxFileConfig *cfgfile = new wxFileConfig("AddressBook", "Xestia", fullprefpath);
 123
 124         wxString EntryName, EntryValue;
 125         wxString AccAdr, AccUsr, AccPass, AccPrefix, AccDir;
 126         wxString AccSSLInc;
 127         bool AccSSL = FALSE;
 128         int AccRef, AccPort = 0;
 129         long itemindex = 0;
 130         bool ContinueAcc = TRUE;
 131
 132         ContinueAcc = cfgfile->GetFirstGroup(accountname, itemindex);
 133
 134         while (ContinueAcc){
 135
 136                 cfgfile->SetPath(accountname);
 137                 cfgfile->Read(wxT("type"), &EntryValue);
 138
 139                 if (EntryValue == wxT("Local")){
 140
 141                         // Get the account directory.
 142
 143                         cfgfile->Read(wxT("accountdir"), &AccDir);
 144
 145                         if (AccDir.Len() > 4){
 146
 147                                 accountdirvalid = TRUE;
 148
 149                         } else {
 150
 151                                 accountdirvalid = FALSE;
 152
 153                         }
 154
 155                         if (accountdirvalid == TRUE){
 156
 157                                 accounts.AddAccount(accountname, wxT("Local"), wxT(""), 0,
 158                                         0, wxT(""), wxT(""),
 159                                         wxT(""), AccDir, 0);
 160
 161                         }
 162
 163                 } else if (EntryValue == wxT("CardDAV")){
 164
 165                         cfgfile->Read(wxT("accountdir"), &AccDir);
 166                         accountaddressvalid = cfgfile->Read(wxT("address"), &AccAdr);
 167                         accountportvalid = cfgfile->Read(wxT("port"), &AccPort);
 168                         accountsslvalid = cfgfile->Read(wxT("ssl"), &AccSSLInc);
 169                         if (AccSSLInc == wxT("true")){
 170                                 AccSSL = TRUE;
 171                         }
 172                         else {
 173                                 AccSSL = FALSE;
 174                         }
 175                         accountusernamevalid = cfgfile->Read(wxT("username"), &AccUsr);
 176                         accountpasswordvalid = cfgfile->Read(wxT("password"), &AccPass);
 177                         accountdirprefixvalid = cfgfile->Read(wxT("prefix"), &AccPrefix);
 178                         accountrefreshvalid = cfgfile->Read(wxT("refresh"), &AccRef);
 179
 180                         if (AccDir.Len() > 4){
 181
 182                                 accountdirvalid = TRUE;
 183
 184                         }
 185
 186                         // Make sure it is not bigger than 65535 or less than 1.
 187                         // If so, default to port 8008.
 188
 189                         if (accountport < 1 || accountport > 65535){
 190                                 accountport = 8008;
 191                                 accountportvalid = TRUE;
 192                         }
 193
 194                         accounts.AddAccount(accountname, wxT("CardDAV"), AccAdr, AccPort,
 195                                 AccSSL, AccUsr, AccPass,
 196                                 AccPrefix, AccDir, AccRef);
 197
 198                 }
 199
 200                 // Clear up for the next account.
 201
 202                 accountnamevalid, accountaddressvalid, accounttypevalid, accountportvalid,
 203                 accountsslvalid, accountusernamevalid, accountpasswordvalid,
 204                 accountdirprefixvalid, accountdirvalid, accountrefreshvalid, accountssl,
 205                 isvalidaccount, isvalidsection = FALSE;
 206
 207                 AccAdr.Clear();
 208                 AccDir.Clear();
 209                 AccUsr.Clear();
 210                 AccPass.Clear();
 211                 AccPrefix.Clear();
 212                 accountname.Clear();
 213                 accountaddress.Clear();
 214                 accounttype.Clear();
 215                 accountport = 0;
 216                 accountrefresh = 0;
 217                 accountusername.Clear();
 218                 accountpassword.Clear();
 219                 accountdirprefix.Clear();
 220                 preaccountstage = TRUE;
 221
 222                 cfgfile->SetPath(wxT("/"));
 223                 ContinueAcc = cfgfile->GetNextGroup(accountname, itemindex);
 224
 225         }
 226
 227 }
 228
 229 XABPreferences::~XABPreferences(){
 230
 231 }
 232
 233 bool XABPreferences::GetBoolData(wxString SettingName){
 234
 235         // GetBoolData from the XABPreferences object.
 236
 237         if (SettingName == wxT("SaveWindowPosition")) { return SaveWindowPos; }
 238         else if (SettingName == wxT("HideLocalAddressBooks")) { return HideLocalABs; }
 239
 240         return FALSE;
 241
 242 }
 243
 244 wxRect XABPreferences::GetMainWindowData(){
 245
 246         // Return the main window data as a wxRect object.
 247
 248         return MainWindowData;
 249
 250 }
 251
 252 void XABPreferences::SetMainWindowData(wxRect WindowData){
 253
 254         // Set the main window data from a wxRect object.
 255
 256         MainWindowData = WindowData;
 257
 258 }
 259
 260 // XABPrefAccounts
 261
 262 XABPrefAccounts::XABPrefAccounts(){
 263
 264         // Setup the default values for XABPrefAccounts.
 265
 266         AccountsCount = 0;
 267
 268 }
 269
 270 int XABPrefAccounts::AddAccount(wxString NewAccName,
 271         wxString NewAccType,
 272         wxString NewAccAddress,
 273         int NewAccPort,
 274         int NewAccSSL,
 275         wxString NewAccUser,
 276         wxString NewAccPass,
 277         wxString NewAccDirPrefix,
 278         wxString NewAccDir,
 279         long NewAccRefresh
 280 ){
 281
 282         // Add an account to the list of accounts in the
 283         // XABPrefAccounts object.
 284
 285         AccountName.Add(NewAccName, 1);
 286         AccountType.Add(NewAccType, 1);
 287         AccountAddress.Add(NewAccAddress, 1);
 288         AccountPort.Add(NewAccPort, 1);
 289         AccountSSL.Add(NewAccSSL, 1);
 290         AccountUsername.Add(NewAccUser, 1);
 291         AccountPassword.Add(NewAccPass, 1);
 292         DirectoryPrefix.Add(NewAccDirPrefix, 1);
 293         AccountDirectory.Add(NewAccDir, 1);
 294         AccountRefresh.Add(NewAccRefresh, 1);
 295
 296         AccountsCount++;
 297
 298         return 0;
 299
 300 }
 301
 302 int XABPrefAccounts::GetCount(){
 303
 304         // Get the count of accounts in the XABPrefAccounts object.
 305
 306         return AccountsCount;
 307
 308 }
 309
 310 wxString XABPrefAccounts::GetAccountName(int AccountNum){
 311
 312         // Get the account name.
 313
 314         if (AccountNum > AccountsCount){
 315                 return wxT("");
 316         }
 317
 318         return AccountName[AccountNum];
 319
 320 }
 321
 322 wxString XABPrefAccounts::GetAccountType(int AccountNum){
 323
 324         // Get the account type.
 325
 326         if (AccountNum > AccountsCount){
 327                 return wxT("");
 328         }
 329
 330         return AccountType[AccountNum];
 331
 332 }
 333
 334 wxString XABPrefAccounts::GetAccountAddress(int AccountNum){
 335
 336         // Get the account server address.
 337
 338         if (AccountNum > AccountsCount){
 339                 return wxT("");
 340         }
 341
 342         return AccountAddress[AccountNum];
 343
 344 }
 345
 346 int XABPrefAccounts::GetAccountPort(int AccountNum){
 347
 348         // Get the account server port.
 349
 350         if (AccountNum > AccountsCount){
 351                 return 0;
 352         }
 353
 354         return AccountPort[AccountNum];
 355
 356 }
 357
 358 bool XABPrefAccounts::GetAccountSSL(int AccountNum){
 359
 360         // Get the account server SSL support.
 361
 362         if (AccountNum > AccountsCount){
 363                 return wxT("");
 364         }
 365
 366         return AccountSSL[AccountNum];
 367
 368 }
 369
 370 wxString XABPrefAccounts::GetAccountUsername(int AccountNum){
 371
 372         // Get the account username.
 373
 374         if (AccountNum > AccountsCount){
 375                 return wxT("");
 376         }
 377
 378         return AccountUsername[AccountNum];
 379
 380 }
 381
 382 wxString XABPrefAccounts::GetAccountPassword(int AccountNum){
 383
 384         // Get the account password.
 385
 386         if (AccountNum > AccountsCount){
 387                 return wxT("");
 388         }
 389
 390         return AccountPassword[AccountNum];
 391
 392 }
 393
 394 wxString XABPrefAccounts::GetAccountDirectory(int AccountNum){
 395
 396         // Get the account directory.
 397
 398         if (AccountNum > AccountsCount){
 399                 return wxT("");
 400         }
 401
 402         return AccountDirectory[AccountNum];
 403
 404 }
 405
 406 wxString XABPrefAccounts::GetAccountDirPrefix(int AccountNum){
 407
 408         // Get the account server directory prefix.
 409
 410         if (AccountNum > AccountsCount){
 411                 return wxT("");
 412         }
 413
 414         return DirectoryPrefix[AccountNum];
 415
 416 }
 417
 418 long XABPrefAccounts::GetAccountRefresh(int AccountNum){
 419
 420         // Get the account refresh time.
 421
 422         if (AccountNum > AccountsCount){
 423                 return 0;
 424         }
 425
 426         return AccountRefresh[AccountNum];
 427
 428 }