← Back to branch summary

~ubuntu-core-dev/synaptic/ubuntu

« back to all changes in this revision

Viewing changes to gtk/rgpreferenceswindow.cc

  • Committer: Michael Terry
  • Date: 2011-09-26 16:30:35 UTC
  • Revision ID: michael.terry@canonical.com-20110926163035-bck8ol261ksu1gmi
move to lp:ubuntu/synaptic

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk/rgpreferenceswindow.cc
1
 
/* rgpreferenceswindow.cc
2
 
 *
3
 
 * Copyright (c) 2000, 2001 Conectiva S/A
4
 
 *               2003 Michael Vogt
5
 
 *
6
 
 * Author: Alfredo K. Kojima <kojima@conectiva.com.br>
7
 
 *         Michael Vogt <mvo@debian.org>
8
 
 *
9
 
 * This program is free software; you can redistribute it and/or
10
 
 * modify it under the terms of the GNU General Public License as
11
 
 * published by the Free Software Foundation; either version 2 of the
12
 
 * License, or (at your option) any later version.
13
 
 *
14
 
 * This program is distributed in the hope that it will be useful,
15
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
 * GNU General Public License for more details.
18
 
 *
19
 
 * You should have received a copy of the GNU General Public License
20
 
 * along with this program; if not, write to the Free Software
21
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
22
 
 * USA
23
 
 */
24
 
 
25
 
#include "config.h"
26
 
 
27
 
#include <apt-pkg/error.h>
28
 
#include <apt-pkg/configuration.h>
29
 
#include <apt-pkg/strutl.h>
30
 
#include <gtk/gtk.h>
31
 
#include <cassert>
32
 
#include <cstring>
33
 
#include <cstdlib>
34
 
 
35
 
#include "rconfiguration.h"
36
 
#include "rgpreferenceswindow.h"
37
 
#include "rguserdialog.h"
38
 
#include "gsynaptic.h"
39
 
#include "rgpackagestatus.h"
40
 
 
41
 
#include "i18n.h"
42
 
 
43
 
enum { FONT_DEFAULT, FONT_TERMINAL };
44
 
 
45
 
const char * RGPreferencesWindow::column_names[] = 
46
 
   {"status", "supported", "name", "section", "component", "instVer", 
47
 
    "availVer", "instSize", "downloadSize", "descr", NULL };
48
 
 
49
 
const char *RGPreferencesWindow::column_visible_names[] = 
50
 
   {_("Status"), _("Supported"), _("Package Name"), _("Section"),
51
 
    _("Component"), _("Installed Version"), _("Available Version"), 
52
 
    _("Installed Size"), _("Download Size"),_("Description"), NULL };
53
 
 
54
 
const gboolean RGPreferencesWindow::column_visible_defaults[] = 
55
 
   { TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE }; 
56
 
 
57
 
const char *RGPreferencesWindow::removal_actions[] =
58
 
   { N_("Keep Configuration"), N_("Completely"), NULL };
59
 
 
60
 
const char *RGPreferencesWindow::update_ask[] =
61
 
   { N_("Always Ask"), N_("Ignore"), N_("Automatically"), NULL };
62
 
 
63
 
const char *RGPreferencesWindow::upgrade_method[] =
64
 
   { N_("Always Ask"), N_("Default Upgrade"), N_("Smart Upgrade"), NULL };
65
 
 
66
 
#if !GTK_CHECK_VERSION(2,6,0)
67
 
gchar *
68
 
gtk_combo_box_get_active_text (GtkComboBox *combo_box)
69
 
{
70
 
  GtkTreeIter iter;
71
 
  gchar *text = NULL;
72
 
 
73
 
  GtkTreeModel* model = gtk_combo_box_get_model(combo_box);
74
 
 
75
 
  if (gtk_combo_box_get_active_iter (combo_box, &iter))
76
 
    gtk_tree_model_get (model, &iter, 0, &text, -1);
77
 
 
78
 
  return text;
79
 
}
80
 
#endif
81
 
 
82
 
#if !GTK_CHECK_VERSION(3,0,0)
83
 
 #define GTK_COMBO_BOX_TEXT GTK_COMBO_BOX
84
 
 #define gtk_combo_box_text_remove gtk_combo_box_remove_text
85
 
 #define gtk_combo_box_text_append_text gtk_combo_box_append_text
86
 
#endif
87
 
 
88
 
void RGPreferencesWindow::cbHttpProxyEntryChanged(GtkWidget *self, void *data)
89
 
{
90
 
   // this function strips http:// from a entred proxy url
91
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
92
 
   const gchar *text = gtk_entry_get_text(GTK_ENTRY(self));
93
 
   gchar *new_text = NULL;
94
 
   if(g_str_has_prefix(text, "http://")) {
95
 
      new_text = g_strdup_printf("%s", &text[strlen("http://")]);
96
 
      gtk_entry_set_text(GTK_ENTRY(self), new_text);
97
 
   }
98
 
   if(new_text != NULL)
99
 
      g_free(new_text);
100
 
}
101
 
 
102
 
void RGPreferencesWindow::cbArchiveSelection(GtkWidget *self, void *data)
103
 
{
104
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
105
 
   //cout << "void RGPreferencesWindow::onArchiveSelection()" << endl;
106
 
   //cout << "data is: " << (char*)data << endl;
107
 
 
108
 
   if(me->_blockAction)
109
 
      return;
110
 
 
111
 
   gchar *s=gtk_combo_box_get_active_text(GTK_COMBO_BOX(self));
112
 
   if(s!=NULL) {
113
 
      me->_defaultDistro = s;
114
 
      //cout << "new default distro: " << me->_defaultDistro << endl;
115
 
      me->distroChanged = true;
116
 
   }
117
 
}
118
 
 
119
 
void RGPreferencesWindow::cbRadioDistributionChanged(GtkWidget *self, 
120
 
                                                     void *data)
121
 
{
122
 
   //cout << "void RGPreferencesWindow::cbRadioDistributionChanged()" << endl;
123
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
124
 
   
125
 
   // we are only interested in the active one
126
 
   if(me->_blockAction || !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self))) 
127
 
      return;
128
 
   
129
 
   gchar *defaultDistro = (gchar*)g_object_get_data(G_OBJECT(self),"defaultDistro");
130
 
   if(strcmp(defaultDistro, "distro") == 0) {
131
 
      gtk_widget_set_sensitive(GTK_WIDGET(me->_comboDefaultDistro),TRUE);
132
 
      gchar *s = gtk_combo_box_get_active_text(GTK_COMBO_BOX(me->_comboDefaultDistro));
133
 
      if(s!=NULL)
134
 
         me->_defaultDistro = s;
135
 
   } else {
136
 
      gtk_widget_set_sensitive(GTK_WIDGET(me->_comboDefaultDistro),FALSE);
137
 
      me->_defaultDistro = defaultDistro;
138
 
   }
139
 
   //cout << "new default distro: " << me->_defaultDistro << endl;
140
 
   me->distroChanged = true;
141
 
}
142
 
 
143
 
void RGPreferencesWindow::applyProxySettings()
144
 
{
145
 
   string http, ftp, noProxy;
146
 
   string httpUser, httpPass;
147
 
   gchar *s;
148
 
   int httpPort, ftpPort;
149
 
 
150
 
   // save apts settings here
151
 
   static bool firstRun = true;
152
 
   static string aptHttpProxy, aptFtpProxy;
153
 
 
154
 
   if(firstRun) {
155
 
      aptHttpProxy = _config->Find("Acquire::http::Proxy");
156
 
      aptFtpProxy = _config->Find("Acquire::ftp::Proxy");
157
 
      
158
 
      firstRun = false;
159
 
   }
160
 
 
161
 
   bool useProxy = _config->FindB("Synaptic::useProxy", false);
162
 
   // now set the stuff for apt
163
 
   if (useProxy) {
164
 
      http = _config->Find("Synaptic::httpProxy", "");
165
 
      httpPort = _config->FindI("Synaptic::httpProxyPort", 3128);
166
 
      ftp = _config->Find("Synaptic::ftpProxy", "");
167
 
      ftpPort = _config->FindI("Synaptic::ftpProxyPort", 3128);
168
 
      noProxy = _config->Find("Synaptic::noProxy", "");
169
 
      httpUser = _config->Find("Synaptic::httpProxyUser", "");
170
 
      httpPass = _config->Find("Synaptic::httpProxyPass", "");
171
 
 
172
 
      if(!http.empty()) {
173
 
         unsetenv("http_proxy");
174
 
         s = g_strdup_printf("http://%s:%i/", http.c_str(), httpPort);
175
 
         _config->Set("Acquire::http::Proxy", s);
176
 
         g_free(s);
177
 
      }
178
 
      // setup the proxy 
179
 
      if(!httpUser.empty() && !httpPass.empty()) { 
180
 
          s = g_strdup_printf("http://%s:%s@%s:%i/",
181
 
                  QuoteString(httpUser, "@%:/").c_str(),
182
 
                  QuoteString(httpPass, "@%:/").c_str(),
183
 
                  http.c_str(), httpPort);
184
 
         _config->Set("Acquire::http::Proxy", s);
185
 
         g_free(s);
186
 
      }
187
 
      if(!ftp.empty()) {
188
 
         unsetenv("ftp_proxy");
189
 
         s = g_strdup_printf("http://%s:%i", ftp.c_str(), ftpPort);
190
 
         _config->Set("Acquire::ftp::Proxy", s);
191
 
         g_free(s);
192
 
      }
193
 
      // set the no-proxies
194
 
      unsetenv("no_proxy");
195
 
      gchar **noProxyArray = g_strsplit(noProxy.c_str(), ",", 0);
196
 
      for (int j = 0; noProxyArray[j] != NULL; j++) {
197
 
         g_strstrip(noProxyArray[j]);
198
 
         s = g_strdup_printf("Acquire::http::Proxy::%s", noProxyArray[j]);
199
 
         _config->Set(s, "DIRECT");
200
 
         g_free(s);
201
 
         s = g_strdup_printf("Acquire::ftp::Proxy::%s", noProxyArray[j]);
202
 
         _config->Set(s, "DIRECT");
203
 
         g_free(s);
204
 
      }
205
 
      g_strfreev(noProxyArray);
206
 
   } else {
207
 
      //FIXME: we can't just clean here as apt may have it's own proxy 
208
 
      // settings!
209
 
      _config->Set("Acquire::http::Proxy",aptHttpProxy);
210
 
      _config->Set("Acquire::ftp::Proxy", aptFtpProxy);
211
 
   }
212
 
}
213
 
 
214
 
void RGPreferencesWindow::saveGeneral()
215
 
{
216
 
   bool newval;
217
 
   int i;
218
 
 
219
 
   // show package properties in main window
220
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_optionShowAllPkgInfoInMain));
221
 
   _config->Set("Synaptic::ShowAllPkgInfoInMain", newval ? "true" : "false");
222
 
   // apply the changes
223
 
   GtkWidget *notebook = GTK_WIDGET(gtk_builder_get_object
224
 
                                    (_mainWin->getGtkBuilder(),
225
 
                                     "notebook_pkginfo"));
226
 
   gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), newval);
227
 
   GtkWidget *box = GTK_WIDGET(gtk_builder_get_object
228
 
                               (_mainWin->getGtkBuilder(),
229
 
                                "vbox_pkgdescr"));
230
 
   if(newval) {
231
 
      gtk_container_set_border_width(GTK_CONTAINER(box), 6);
232
 
   } else {
233
 
      gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
234
 
      gtk_container_set_border_width(GTK_CONTAINER(box), 0);
235
 
   }
236
 
 
237
 
   // Ask to confirm changes also affecting other packages
238
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_optionAskRelated));
239
 
   _config->Set("Synaptic::AskRelated", newval ? "true" : "false");
240
 
 
241
 
   // Consider recommended packages as dependencies
242
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_optionCheckRecom));
243
 
   _config->Set("APT::Install-Recommends", newval ? "true" : "false");
244
 
 
245
 
   // Clicking on the status icon marks the most likely action
246
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_optionOneClick));
247
 
   _config->Set("Synaptic::OneClickOnStatusActions", newval ? "true" : "false");
248
 
 
249
 
   // Removal of packages: 
250
 
   int delAction = gtk_combo_box_get_active(GTK_COMBO_BOX(_comboRemovalAction));
251
 
   // ugly :( but we need this +2 because RGPkgAction starts with 
252
 
   //         "keep","install"
253
 
   delAction += 2;
254
 
   _config->Set("Synaptic::delAction", delAction);
255
 
 
256
 
   // System upgrade:
257
 
   // upgrade type, (ask=-1,normal=0,dist-upgrade=1)
258
 
   i = gtk_combo_box_get_active(GTK_COMBO_BOX(_comboUpgradeMethod));
259
 
   _config->Set("Synaptic::upgradeType", i - 1);
260
 
 
261
 
   // package list update date check
262
 
   i = gtk_combo_box_get_active(GTK_COMBO_BOX(_comboUpdateAsk));
263
 
   _config->Set("Synaptic::update::type", i);
264
 
   
265
 
 
266
 
   // Number of undo operations:
267
 
   int maxUndo = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(_maxUndoE));
268
 
   _config->Set("Synaptic::undoStackSize", maxUndo);
269
 
 
270
 
   // Apply changes in a terminal window
271
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_optionUseTerminal));
272
 
   _config->Set("Synaptic::UseTerminal", newval ? "true" : "false");
273
 
 
274
 
   // Ask to quit after the changes have been applied successfully
275
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_optionAskQuit));
276
 
   _config->Set("Synaptic::AskQuitOnProceed", newval ? "true" : "false");
277
 
 
278
 
}
279
 
 
280
 
void RGPreferencesWindow::saveColumnsAndFonts() 
281
 
{
282
 
   bool newval;
283
 
 
284
 
   // Use custom application font
285
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(_builder, "checkbutton_user_font")));
286
 
   _config->Set("Synaptic::useUserFont", newval);
287
 
 
288
 
   GValue value = { 0, };
289
 
   g_value_init(&value, G_TYPE_STRING);
290
 
   if (newval) {
291
 
      g_value_set_string(&value, _config->Find("Synaptic::FontName").c_str());
292
 
      g_object_set_property(G_OBJECT(gtk_settings_get_default()),
293
 
                            "gtk-font-name", &value);
294
 
   } else {
295
 
      g_value_set_string(&value,
296
 
                         _config->Find("Volatile::orginalFontName",
297
 
                                       "Sans 10").c_str());
298
 
      g_object_set_property(G_OBJECT(gtk_settings_get_default()),
299
 
                            "gtk-font-name", &value);
300
 
   }
301
 
   g_value_unset(&value);
302
 
 
303
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(_builder, "checkbutton_user_terminal_font")));
304
 
   _config->Set("Synaptic::useUserTerminalFont", newval);
305
 
   
306
 
 
307
 
   // treeviewstuff 
308
 
   // get from GtkListStore
309
 
   GtkListStore *store = _listColumns;
310
 
   GtkTreeIter iter;
311
 
   int i=0;
312
 
   char *column_name, *config_name;
313
 
   gboolean visible;
314
 
   gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
315
 
   do {
316
 
      gtk_tree_model_get (GTK_TREE_MODEL(store), &iter,
317
 
                          TREE_CHECKBOX_COLUMN, &visible,
318
 
                          TREE_NAME_COLUMN, &column_name,
319
 
                          -1);
320
 
 
321
 
      // pos
322
 
      config_name = g_strdup_printf("Synaptic::%sColumnPos",column_name);
323
 
      _config->Set(config_name, i);
324
 
      //cout << column_name << " : " << i << endl;
325
 
      g_free(config_name);
326
 
      
327
 
      // visible
328
 
      config_name = g_strdup_printf("Synaptic::%sColumnVisible",column_name);
329
 
      _config->Set(config_name, visible);
330
 
      g_free(config_name);
331
 
 
332
 
      i++;
333
 
   } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
334
 
 
335
 
   // rebuild the treeview
336
 
   _mainWin->rebuildTreeView();
337
 
}
338
 
 
339
 
void RGPreferencesWindow::saveColors()
340
 
{
341
 
   bool newval;
342
 
 
343
 
   // save the colors
344
 
   RGPackageStatus::pkgStatus.saveColors();
345
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_optionUseStatusColors));
346
 
   _config->Set("Synaptic::UseStatusColors", newval ? "true" : "false");
347
 
}
348
 
 
349
 
void RGPreferencesWindow::saveFiles()
350
 
{
351
 
   bool newval;
352
 
 
353
 
   // cache
354
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_cacheClean));
355
 
   _config->Set("Synaptic::CleanCache", newval ? "true" : "false");
356
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_cacheAutoClean));
357
 
   _config->Set("Synaptic::AutoCleanCache", newval ? "true" : "false");
358
 
 
359
 
   // history
360
 
   newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_delHistory));
361
 
   if(!newval) {
362
 
      _config->Set("Synaptic::delHistory", -1);
363
 
      return;
364
 
   }
365
 
   int delHistory= gtk_spin_button_get_value(GTK_SPIN_BUTTON(_spinDelHistory));
366
 
   _config->Set("Synaptic::delHistory", delHistory);
367
 
   _lister->cleanCommitLog();
368
 
}
369
 
 
370
 
void RGPreferencesWindow::saveNetwork()
371
 
{
372
 
   // proxy stuff
373
 
   bool useProxy;
374
 
   const gchar *http, *ftp, *noProxy;
375
 
   int httpPort, ftpPort;
376
 
 
377
 
   useProxy = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_useProxy));
378
 
   _config->Set("Synaptic::useProxy", useProxy);
379
 
   // http
380
 
   http = gtk_entry_get_text(
381
 
      GTK_ENTRY(gtk_builder_get_object(_builder, "entry_http_proxy")));
382
 
   _config->Set("Synaptic::httpProxy", http);
383
 
   httpPort = (int) gtk_spin_button_get_value(
384
 
      GTK_SPIN_BUTTON(gtk_builder_get_object(_builder,"spinbutton_http_port")));
385
 
   _config->Set("Synaptic::httpProxyPort", httpPort);
386
 
   // ftp
387
 
   ftp = gtk_entry_get_text(
388
 
      GTK_ENTRY(gtk_builder_get_object(_builder, "entry_ftp_proxy")));
389
 
   _config->Set("Synaptic::ftpProxy", ftp);
390
 
   ftpPort = (int) gtk_spin_button_get_value(
391
 
      GTK_SPIN_BUTTON(gtk_builder_get_object(_builder,"spinbutton_ftp_port")));
392
 
   _config->Set("Synaptic::ftpProxyPort", ftpPort);
393
 
   noProxy = gtk_entry_get_text(
394
 
      GTK_ENTRY(gtk_builder_get_object(_builder, "entry_no_proxy")));
395
 
   _config->Set("Synaptic::noProxy", noProxy);
396
 
 
397
 
   applyProxySettings();
398
 
}
399
 
 
400
 
void RGPreferencesWindow::saveDistribution()
401
 
{
402
 
   if (_defaultDistro.empty()) {
403
 
      _config->Clear("APT::Default-Release");
404
 
      _config->Clear("Synaptic::DefaultDistro");
405
 
   } else {
406
 
      _config->Set("APT::Default-Release", _defaultDistro);
407
 
      _config->Set("Synaptic::DefaultDistro", _defaultDistro);
408
 
   }
409
 
}
410
 
 
411
 
 
412
 
void RGPreferencesWindow::saveAction(GtkWidget *self, void *data)
413
 
{
414
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
415
 
 
416
 
   me->saveGeneral();
417
 
   me->saveColumnsAndFonts();
418
 
   me->saveColors();
419
 
   me->saveFiles();
420
 
   me->saveNetwork();
421
 
   me->saveDistribution();
422
 
 
423
 
   if (!RWriteConfigFile(*_config)) {
424
 
      _error->Error(_("An error occurred while saving configurations."));
425
 
      RGUserDialog userDialog(me);
426
 
      userDialog.showErrors();
427
 
   }
428
 
}
429
 
 
430
 
 
431
 
void RGPreferencesWindow::closeAction(GtkWidget *self, void *data)
432
 
{
433
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
434
 
   me->close();
435
 
}
436
 
 
437
 
void RGPreferencesWindow::doneAction(GtkWidget *self, void *data)
438
 
{
439
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
440
 
   me->saveAction(self, data);
441
 
   if (me->distroChanged) {
442
 
      me->hide();
443
 
      me->_lister->unregisterObserver(me->_mainWin);
444
 
      me->_mainWin->setTreeLocked(TRUE);
445
 
      if (!me->_lister->openCache()) {
446
 
         me->_mainWin->showErrors();
447
 
         exit(1);
448
 
      }
449
 
      me->_mainWin->setTreeLocked(FALSE);
450
 
      me->_lister->registerObserver(me->_mainWin);
451
 
      me->_mainWin->refreshTable();
452
 
   }
453
 
   me->closeAction(self, data);
454
 
}
455
 
 
456
 
void RGPreferencesWindow::changeFontAction(GtkWidget *self, void *data)
457
 
{
458
 
   const char *fontName, *propName;
459
 
   
460
 
   switch (GPOINTER_TO_INT(data)) {
461
 
      case FONT_DEFAULT:
462
 
         propName = "Synaptic::FontName";
463
 
              fontName = "sans 10";
464
 
         break;
465
 
      case FONT_TERMINAL:
466
 
         propName = "Synaptic::TerminalFontName";
467
 
              fontName = "monospace 10";
468
 
         break;
469
 
      default:
470
 
         cerr << "changeFontAction called with unknown argument" << endl;
471
 
         return;
472
 
   }
473
 
 
474
 
   GtkWidget *fontsel = gtk_font_selection_dialog_new(_("Choose font"));
475
 
 
476
 
   gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(fontsel),
477
 
                                           _config->Find(propName,
478
 
                                                         fontName).c_str());
479
 
 
480
 
   gint result = gtk_dialog_run(GTK_DIALOG(fontsel));
481
 
   if (result != GTK_RESPONSE_OK) {
482
 
      gtk_widget_destroy(fontsel);
483
 
      return;
484
 
   }
485
 
 
486
 
   fontName =
487
 
      gtk_font_selection_dialog_get_font_name(GTK_FONT_SELECTION_DIALOG
488
 
                                              (fontsel));
489
 
 
490
 
   //cout << "fontname: " << fontName << endl;
491
 
 
492
 
   _config->Set(propName, fontName);
493
 
 
494
 
   gtk_widget_destroy(fontsel);
495
 
}
496
 
 
497
 
void RGPreferencesWindow::clearCacheAction(GtkWidget *self, void *data)
498
 
{
499
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
500
 
 
501
 
   me->_lister->cleanPackageCache(true);
502
 
}
503
 
 
504
 
void RGPreferencesWindow::readGeneral()
505
 
{
506
 
   // Allow regular expressions in searches and filters
507
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_optionShowAllPkgInfoInMain),
508
 
                                _config->FindB("Synaptic::ShowAllPkgInfoInMain", false));
509
 
 
510
 
   // Ask to confirm changes also affecting other packages
511
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_optionAskRelated),
512
 
                                _config->FindB("Synaptic::AskRelated", true));
513
 
 
514
 
   // Consider recommended packages as dependencies
515
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_optionCheckRecom),
516
 
                                _config->FindB("APT::Install-Recommends",
517
 
                                               false));
518
 
 
519
 
   // Clicking on the status icon marks the most likely action
520
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_optionOneClick),
521
 
                                _config->FindB("Synaptic::OneClickOnStatusActions",
522
 
                                               false));
523
 
 
524
 
   // Removal of packages: 
525
 
   int delAction = _config->FindI("Synaptic::delAction", PKG_DELETE);
526
 
   // now set the combobox
527
 
   // ugly :( but we need this -2 because RGPkgAction starts with 
528
 
   //         "keep","install"
529
 
   gtk_combo_box_set_active(GTK_COMBO_BOX(_comboRemovalAction), delAction - 2);
530
 
 
531
 
 
532
 
   // System upgrade:
533
 
   // upgradeType (ask=-1,normal=0,dist-upgrade=1)
534
 
   int i = _config->FindI("Synaptic::upgradeType", 1);
535
 
   gtk_combo_box_set_active(GTK_COMBO_BOX(_comboUpgradeMethod), i + 1);
536
 
 
537
 
   i = _config->FindI("Synaptic::update::type", 0);
538
 
   gtk_combo_box_set_active(GTK_COMBO_BOX(_comboUpdateAsk), i);
539
 
 
540
 
 
541
 
   // Number of undo operations:
542
 
 
543
 
#ifdef HAVE_RPM
544
 
   int UndoStackSize = 3;
545
 
#else
546
 
   int UndoStackSize = 20;
547
 
#endif
548
 
   gtk_spin_button_set_value(GTK_SPIN_BUTTON(_maxUndoE),
549
 
                             _config->FindI("Synaptic::undoStackSize",
550
 
                                            UndoStackSize));
551
 
 
552
 
   
553
 
   // Apply changes in a terminal window
554
 
   bool UseTerminal = false;
555
 
#ifndef HAVE_TERMINAL
556
 
   gtk_widget_set_sensitive(GTK_WIDGET(_optionUseTerminal), false);
557
 
   _config->Set("Synaptic::UseTerminal", false);
558
 
#else
559
 
#ifndef HAVE_RPM 
560
 
#ifndef WITH_DPKG_STATUSFD
561
 
   UseTerminal = true;
562
 
#endif
563
 
#endif
564
 
#endif
565
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_optionUseTerminal),
566
 
                                _config->FindB("Synaptic::UseTerminal",
567
 
                                               UseTerminal));
568
 
 
569
 
   // Ask to quit after the changes have been applied successfully
570
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_optionAskQuit),
571
 
                                _config->FindB("Synaptic::AskQuitOnProceed",
572
 
                                               false));
573
 
}
574
 
 
575
 
void RGPreferencesWindow::readColumnsAndFonts()
576
 
{
577
 
   // font stuff
578
 
   bool b = _config->FindB("Synaptic::useUserFont", false);
579
 
   gtk_toggle_button_set_active(
580
 
      GTK_TOGGLE_BUTTON(gtk_builder_get_object(_builder,
581
 
                                             "checkbutton_user_font")), b);
582
 
   b = _config->FindB("Synaptic::useUserTerminalFont", false);
583
 
   gtk_toggle_button_set_active(
584
 
      GTK_TOGGLE_BUTTON(gtk_builder_get_object(_builder,
585
 
                                             "checkbutton_user_terminal_font")), b);
586
 
 
587
 
   readTreeViewValues();
588
 
 
589
 
}
590
 
 
591
 
void RGPreferencesWindow::readColors()
592
 
{
593
 
   GdkColor *color;
594
 
   gchar *color_button;
595
 
   GtkWidget *button = NULL;
596
 
 
597
 
   // Color packages by their status
598
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_optionUseStatusColors),
599
 
                                _config->FindB("Synaptic::UseStatusColors",
600
 
                                               true));
601
 
 
602
 
   // color buttons
603
 
   for (int i = 0; i < RGPackageStatus::N_STATUS_COUNT; i++) {
604
 
      color_button =
605
 
         g_strdup_printf("button_%s_color",
606
 
                         RGPackageStatus::pkgStatus.
607
 
                         getShortStatusString(RGPackageStatus::PkgStatus(i)));
608
 
      button = GTK_WIDGET(gtk_builder_get_object(_builder, color_button));
609
 
      assert(button);
610
 
      if (RGPackageStatus::pkgStatus.getColor(i) != NULL) {
611
 
         color = RGPackageStatus::pkgStatus.getColor(i);
612
 
         gtk_widget_modify_bg(button, GTK_STATE_PRELIGHT, color);
613
 
         gtk_widget_modify_bg(button, GTK_STATE_NORMAL, color);
614
 
      }
615
 
      g_free(color_button);
616
 
   }
617
 
 
618
 
}
619
 
 
620
 
void RGPreferencesWindow::readFiles()
621
 
{
622
 
   // <b>Temporary Files</b>
623
 
   bool postClean = _config->FindB("Synaptic::CleanCache", false);
624
 
   bool postAutoClean = _config->FindB("Synaptic::AutoCleanCache", true);
625
 
 
626
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_cacheClean), postClean);
627
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_cacheAutoClean), 
628
 
                                postAutoClean);
629
 
 
630
 
   if (postClean)
631
 
      gtk_button_clicked(GTK_BUTTON(_cacheClean));
632
 
   else if (postAutoClean)
633
 
      gtk_button_clicked(GTK_BUTTON(_cacheAutoClean));
634
 
   else
635
 
      gtk_button_clicked(GTK_BUTTON(_cacheLeave));
636
 
 
637
 
   // history
638
 
   int delHistory = _config->FindI("Synaptic::delHistory", -1);
639
 
   if(delHistory < 0) 
640
 
      gtk_button_clicked(GTK_BUTTON(_keepHistory));
641
 
   else {
642
 
      gtk_button_clicked(GTK_BUTTON(_delHistory));      
643
 
      gtk_spin_button_set_value(GTK_SPIN_BUTTON(_spinDelHistory), 
644
 
                                delHistory);      
645
 
   }
646
 
}
647
 
 
648
 
void RGPreferencesWindow::readNetwork()
649
 
{
650
 
   // proxy stuff
651
 
   bool useProxy = _config->FindB("Synaptic::useProxy", false);
652
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object
653
 
                                                  (_builder,"radio_use_proxy")),
654
 
                                                  useProxy);
655
 
   gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object
656
 
                            (_builder, "table_proxy")),
657
 
                            useProxy);
658
 
   string str = _config->Find("Synaptic::httpProxy", "");
659
 
   gtk_entry_set_text(GTK_ENTRY(gtk_builder_get_object
660
 
                                (_builder, "entry_http_proxy")), str.c_str());
661
 
   int i = _config->FindI("Synaptic::httpProxyPort", 3128);
662
 
   gtk_spin_button_set_value(GTK_SPIN_BUTTON
663
 
                             (gtk_builder_get_object
664
 
                              (_builder, "spinbutton_http_port")), i);
665
 
 
666
 
   str = _config->Find("Synaptic::ftpProxy", "");
667
 
   gtk_entry_set_text(
668
 
      GTK_ENTRY(gtk_builder_get_object(_builder, "entry_ftp_proxy")), str.c_str());
669
 
   i = _config->FindI("Synaptic::ftpProxyPort", 3128);
670
 
   gtk_spin_button_set_value(
671
 
      GTK_SPIN_BUTTON(gtk_builder_get_object(_builder, "spinbutton_ftp_port")), i);
672
 
   str = _config->Find("Synaptic::noProxy", "");
673
 
   gtk_entry_set_text(GTK_ENTRY(gtk_builder_get_object(_builder,
674
 
                                                       "entry_no_proxy")),
675
 
                      str.c_str());
676
 
 
677
 
}
678
 
 
679
 
void RGPreferencesWindow::readDistribution()
680
 
{
681
 
   // distro selection, block actions here because the combobox changes
682
 
   // and a signal is emited
683
 
   _blockAction = true;
684
 
 
685
 
   int distroMatch = 0;
686
 
   string defaultDistro = _config->Find("Synaptic::DefaultDistro", "");
687
 
   vector<string> archives = _lister->getPolicyArchives();
688
 
  
689
 
   // setup the toggle buttons
690
 
   GtkWidget *button, *ignore,*now,*distro;
691
 
   ignore = GTK_WIDGET(gtk_builder_get_object(_builder, "radiobutton_ignore"));
692
 
   g_object_set_data(G_OBJECT(ignore),"defaultDistro",(void*)"");
693
 
   g_signal_connect(G_OBJECT(ignore),
694
 
                    "toggled",
695
 
                    G_CALLBACK(cbRadioDistributionChanged), this);
696
 
   now = GTK_WIDGET(gtk_builder_get_object(_builder, "radiobutton_now"));
697
 
   g_object_set_data(G_OBJECT(now),"defaultDistro",(void*)"now");
698
 
   g_signal_connect(G_OBJECT(now),
699
 
                    "toggled",
700
 
                    G_CALLBACK(cbRadioDistributionChanged), this);
701
 
   distro = GTK_WIDGET(gtk_builder_get_object(_builder, "radiobutton_distro"));
702
 
   g_object_set_data(G_OBJECT(distro),"defaultDistro",(void*)"distro");
703
 
   g_signal_connect(G_OBJECT(distro),
704
 
                    "toggled",
705
 
                    G_CALLBACK(cbRadioDistributionChanged), this);
706
 
 
707
 
   // clear the combo box
708
 
   GtkTreeModel *model = gtk_combo_box_get_model(GTK_COMBO_BOX(_comboDefaultDistro));
709
 
   int num = gtk_tree_model_iter_n_children(model, NULL);
710
 
   for(;num >= 0;num--)
711
 
      gtk_combo_box_text_remove(GTK_COMBO_BOX(_comboDefaultDistro), num);
712
 
 
713
 
   if(defaultDistro == "") {
714
 
      button = ignore;
715
 
      gtk_widget_set_sensitive(GTK_WIDGET(_comboDefaultDistro),FALSE);
716
 
   } else if(defaultDistro == "now") {
717
 
      button = now;
718
 
      gtk_widget_set_sensitive(GTK_WIDGET(_comboDefaultDistro),FALSE);
719
 
   } else {
720
 
      button = distro;
721
 
      gtk_widget_set_sensitive(GTK_WIDGET(_comboDefaultDistro),TRUE);
722
 
   }
723
 
   assert(button);
724
 
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
725
 
 
726
 
 
727
 
   // set up combo-box
728
 
   g_signal_connect(G_OBJECT(_comboDefaultDistro), "changed",
729
 
                    G_CALLBACK(cbArchiveSelection), this);
730
 
 
731
 
   g_signal_connect(gtk_builder_get_object(_builder, "entry_http_proxy"),
732
 
                                 "changed",
733
 
                                 G_CALLBACK(cbHttpProxyEntryChanged), this);
734
 
 
735
 
   GtkTreeIter distroIter;
736
 
   GtkListStore *distroStore
737
 
      = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(_comboDefaultDistro)));
738
 
   for (unsigned int i = 0; i < archives.size(); i++) {
739
 
      // ignore "now", it's a toggle button item now
740
 
      if(archives[i] == "now")
741
 
         continue;
742
 
      gtk_list_store_append(distroStore, &distroIter);
743
 
      gtk_list_store_set(distroStore, &distroIter, 0, archives[i].c_str(), -1);
744
 
      if (defaultDistro == archives[i]) {
745
 
         //cout << "match for: " << archives[i] << " (" << i << ")" << endl;
746
 
         // we ignored the "now" archive, so we have to subtract by one
747
 
         distroMatch=i-1;
748
 
      }
749
 
   }
750
 
   GtkCellRenderer *crt;
751
 
   crt = gtk_cell_renderer_text_new();
752
 
   gtk_cell_layout_clear(GTK_CELL_LAYOUT(_comboDefaultDistro));
753
 
   gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(_comboDefaultDistro), crt, TRUE);
754
 
   gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(_comboDefaultDistro),
755
 
                                 crt, "text", 0);
756
 
   gtk_combo_box_set_active(GTK_COMBO_BOX(_comboDefaultDistro), distroMatch);
757
 
 
758
 
   _blockAction = false;
759
 
}
760
 
 
761
 
void RGPreferencesWindow::show()
762
 
{
763
 
   readGeneral();
764
 
   readColumnsAndFonts();
765
 
   readColors();
766
 
   readFiles();
767
 
   readNetwork();
768
 
   readDistribution();
769
 
 
770
 
   RGWindow::show();
771
 
}
772
 
 
773
 
 
774
 
void RGPreferencesWindow::readTreeViewValues()
775
 
{
776
 
 
777
 
   // number of entries in columns is (sizeof(columns)/sizeof(char*))-1 
778
 
   int number_of_columns = sizeof(column_names)/sizeof(char*)-1;
779
 
 
780
 
   // the position in this vector is the position of the column
781
 
   vector<column_struct> columns(number_of_columns);
782
 
 
783
 
   // make sure that we fail gracefully
784
 
   bool corrupt=false;
785
 
 
786
 
   // put into right place
787
 
   gchar *name;
788
 
   int pos;
789
 
   column_struct c;
790
 
   for(int i=0;column_names[i] != NULL; i++) {
791
 
      // pos
792
 
      name = g_strdup_printf("Synaptic::%sColumnPos",column_names[i]);
793
 
      pos = _config->FindI(name, i);
794
 
      g_free(name);
795
 
      
796
 
      // visible
797
 
      name = g_strdup_printf("Synaptic::%sColumnVisible",column_names[i]);
798
 
      c.visible = _config->FindB(name, column_visible_defaults[i]);
799
 
      c.name = column_names[i];
800
 
      c.visible_name = column_visible_names[i];
801
 
      g_free(name);
802
 
 
803
 
      if(pos > number_of_columns || pos < 0 || columns[pos].name != NULL) {
804
 
         //cerr << "invalid column config found, reseting"<<endl;
805
 
         corrupt=true;
806
 
         continue;
807
 
      }
808
 
      columns[pos] = c;
809
 
   }
810
 
 
811
 
   // if corrupt for some reason, repair
812
 
   if(corrupt) {
813
 
      cerr << "seting column order to default" << endl;
814
 
      for(int i=0;column_names[i] != NULL; i++) {
815
 
         name = g_strdup_printf("Synaptic::%sColumnPos",column_names[i]);
816
 
         _config->Set(name, i);
817
 
         c.visible = column_visible_defaults[i];
818
 
         c.name = column_names[i];
819
 
         c.visible_name = column_visible_names[i];
820
 
         columns[i] = c;
821
 
      }
822
 
   }
823
 
 
824
 
 
825
 
   // put into GtkListStore
826
 
   GtkListStore *store = _listColumns = gtk_list_store_new(3, 
827
 
                                                           G_TYPE_BOOLEAN, 
828
 
                                                           G_TYPE_STRING, 
829
 
                                                           G_TYPE_STRING);
830
 
   GtkTreeIter iter;
831
 
   for(unsigned int i=0;i<columns.size();i++) {
832
 
      gtk_list_store_append (store, &iter);
833
 
      gtk_list_store_set (store, &iter,
834
 
                          TREE_CHECKBOX_COLUMN, columns[i].visible,
835
 
                          TREE_NAME_COLUMN, columns[i].name,
836
 
                          TREE_VISIBLE_NAME_COLUMN, _(columns[i].visible_name),
837
 
                          -1);
838
 
      
839
 
   }
840
 
 
841
 
   // now set the model
842
 
   gtk_tree_view_set_model(GTK_TREE_VIEW(_treeView), 
843
 
                           GTK_TREE_MODEL(_listColumns));
844
 
 
845
 
}
846
 
 
847
 
void RGPreferencesWindow::cbMoveColumnUp(GtkWidget *self, void *data)
848
 
{
849
 
   //cout << "void RGPReferencesWindow::cbMoveColumnUp()" << endl;
850
 
   RGPreferencesWindow *me = (RGPreferencesWindow*)data;
851
 
 
852
 
   GtkTreeIter iter, next;
853
 
   GtkTreePath *first = gtk_tree_path_new_first();
854
 
 
855
 
   GtkTreeSelection* selection;
856
 
   selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(me->_treeView));
857
 
   if(!gtk_tree_selection_get_selected (selection, NULL,
858
 
                                        &iter)) {
859
 
      return;
860
 
   }
861
 
   next = iter;
862
 
   GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(me->_listColumns), &iter);
863
 
   gtk_tree_path_prev(path);
864
 
   gtk_tree_model_get_iter(GTK_TREE_MODEL(me->_listColumns), &next, path);
865
 
   
866
 
   if(gtk_tree_path_compare(path, first) == 0)
867
 
      gtk_list_store_move_after(me->_listColumns, &iter, NULL);
868
 
   else
869
 
      gtk_list_store_move_before(me->_listColumns, &iter, &next);
870
 
   
871
 
}
872
 
 
873
 
void RGPreferencesWindow::cbMoveColumnDown(GtkWidget *self, void *data)
874
 
{
875
 
   //cout << "void RGPReferencesW2indow::cbMoveColumnDown()" << endl;
876
 
   RGPreferencesWindow *me = (RGPreferencesWindow*)data;
877
 
 
878
 
   GtkTreeIter iter, next;
879
 
 
880
 
   GtkTreeSelection* selection;
881
 
   selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(me->_treeView));
882
 
   if(!gtk_tree_selection_get_selected (selection, NULL,
883
 
                                        &iter)) {
884
 
      return;
885
 
   }
886
 
   next = iter;
887
 
   if(!gtk_tree_model_iter_next(GTK_TREE_MODEL(me->_listColumns), &next))
888
 
      return;
889
 
   gtk_list_store_move_after(me->_listColumns, &iter, &next);
890
 
}
891
 
 
892
 
void RGPreferencesWindow::cbToggleColumn(GtkWidget *self, char*path_string,
893
 
                                         void *data)
894
 
{
895
 
   //cout << "void RGPReferencesWindow::cbToggle()" << endl;
896
 
   RGPreferencesWindow *me = (RGPreferencesWindow*)data;
897
 
   GtkTreeIter iter;
898
 
   gboolean res;
899
 
 
900
 
   GtkTreeModel *model = (GtkTreeModel*)me->_listColumns;
901
 
   GtkTreePath* path = gtk_tree_path_new_from_string(path_string);
902
 
   gtk_tree_model_get_iter(model, &iter, path);
903
 
   gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
904
 
                      TREE_CHECKBOX_COLUMN, &res, -1);
905
 
   gtk_list_store_set(GTK_LIST_STORE(model), &iter,
906
 
                      TREE_CHECKBOX_COLUMN, !res,
907
 
                      -1);
908
 
 
909
 
}
910
 
 
911
 
 
912
 
void RGPreferencesWindow::colorClicked(GtkWidget *self, void *data)
913
 
{
914
 
   GtkWidget *color_dialog;
915
 
   GtkWidget *color_selection;
916
 
   RGPreferencesWindow *me;
917
 
   me = (RGPreferencesWindow *) g_object_get_data(G_OBJECT(self), "me");
918
 
 
919
 
   color_dialog = gtk_color_selection_dialog_new(_("Color selection"));
920
 
   color_selection =
921
 
        gtk_color_selection_dialog_get_color_selection(
922
 
                GTK_COLOR_SELECTION_DIALOG(color_dialog));
923
 
 
924
 
   GdkColor *color = NULL;
925
 
   color = RGPackageStatus::pkgStatus.getColor(GPOINTER_TO_INT(data));
926
 
   if (color != NULL)
927
 
      gtk_color_selection_set_current_color(GTK_COLOR_SELECTION
928
 
                                            (color_selection), color);
929
 
 
930
 
   if (gtk_dialog_run(GTK_DIALOG(color_dialog)) == GTK_RESPONSE_OK) {
931
 
      GdkColor current_color;
932
 
      gtk_color_selection_get_current_color(GTK_COLOR_SELECTION(color_selection), &current_color);
933
 
      RGPackageStatus::pkgStatus.setColor(GPOINTER_TO_INT(data),
934
 
                                          gdk_color_copy(&current_color));
935
 
      me->readColors();
936
 
   }
937
 
   gtk_widget_destroy(color_dialog);
938
 
}
939
 
 
940
 
void RGPreferencesWindow::useProxyToggled(GtkWidget *self, void *data)
941
 
{
942
 
   //cout << "void RGPreferencesWindow::useProxyToggled() " << endl;
943
 
   bool useProxy;
944
 
 
945
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
946
 
   useProxy = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(me->_useProxy));
947
 
   gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(me->_builder,
948
 
                                                              "table_proxy")),
949
 
                            useProxy);
950
 
}
951
 
 
952
 
void RGPreferencesWindow::checkbuttonUserFontToggled(GtkWidget *self,
953
 
                                                     void *data)
954
 
{
955
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
956
 
 
957
 
   GtkWidget *button =
958
 
      GTK_WIDGET(gtk_builder_get_object(me->_builder, "button_default_font"));
959
 
   GtkWidget *check =
960
 
      GTK_WIDGET(gtk_builder_get_object(me->_builder, "checkbutton_user_font"));
961
 
   gtk_widget_set_sensitive(button,
962
 
                            gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
963
 
                                                         (check)));
964
 
}
965
 
 
966
 
void RGPreferencesWindow::checkbuttonUserTerminalFontToggled(GtkWidget *self,
967
 
                                                             void *data)
968
 
{
969
 
   RGPreferencesWindow *me = (RGPreferencesWindow *) data;
970
 
 
971
 
   GtkWidget *button =
972
 
      GTK_WIDGET(gtk_builder_get_object(me->_builder, "button_terminal_font"));
973
 
   GtkWidget *check =
974
 
      GTK_WIDGET(gtk_builder_get_object(me->_builder,
975
 
                                        "checkbutton_user_terminal_font"));
976
 
   gtk_widget_set_sensitive(button,
977
 
                            gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
978
 
                                                         (check)));
979
 
}
980
 
 
981
 
 
982
 
 
983
 
RGPreferencesWindow::RGPreferencesWindow(RGWindow *win,
984
 
                                         RPackageLister *lister)
985
 
   : RGGtkBuilderWindow(win, "preferences"), distroChanged(false)
986
 
{
987
 
   GtkWidget *button;
988
 
   GtkCellRenderer *crt;
989
 
   GtkListStore *comboStore;
990
 
   GtkTreeIter comboIter;
991
 
 
992
 
   _optionShowAllPkgInfoInMain = GTK_WIDGET(gtk_builder_get_object
993
 
                                            (_builder,
994
 
                                             "check_show_all_pkg_info"));
995
 
   _optionUseStatusColors =
996
 
      GTK_WIDGET(gtk_builder_get_object(_builder, "check_use_colors"));
997
 
 
998
 
   _optionAskRelated =
999
 
      GTK_WIDGET(gtk_builder_get_object(_builder, "check_ask_related"));
1000
 
   _optionUseTerminal =
1001
 
      GTK_WIDGET(gtk_builder_get_object(_builder, "check_terminal"));
1002
 
   _optionCheckRecom =
1003
 
      GTK_WIDGET(gtk_builder_get_object(_builder, "check_recommends"));
1004
 
   _optionAskQuit =
1005
 
      GTK_WIDGET(gtk_builder_get_object(_builder, "check_ask_quit"));
1006
 
   _optionOneClick =
1007
 
      GTK_WIDGET(gtk_builder_get_object(_builder, "check_oneclick"));
1008
 
 
1009
 
   // cache
1010
 
   _cacheLeave = GTK_WIDGET(gtk_builder_get_object(_builder,
1011
 
                                                   "radio_cache_leave"));
1012
 
   _cacheClean = GTK_WIDGET(gtk_builder_get_object(_builder,
1013
 
                                                   "radio_cache_del_after"));
1014
 
   // history
1015
 
   _delHistory = GTK_WIDGET(gtk_builder_get_object(_builder,
1016
 
                                                   "radio_delete_history"));
1017
 
   _keepHistory = GTK_WIDGET(gtk_builder_get_object(_builder,
1018
 
                                                    "radio_keep_history"));
1019
 
   _spinDelHistory = GTK_WIDGET(gtk_builder_get_object(_builder,
1020
 
                                                       "spin_del_history"));
1021
 
   _cacheAutoClean =
1022
 
      GTK_WIDGET(gtk_builder_get_object(_builder, "radio_cache_del_obsolete"));
1023
 
   _useProxy = GTK_WIDGET(gtk_builder_get_object(_builder, "radio_use_proxy"));
1024
 
   _mainWin = (RGMainWindow *) win;
1025
 
 
1026
 
   _maxUndoE = GTK_WIDGET(gtk_builder_get_object(_builder,
1027
 
                                                 "spinbutton_max_undos"));
1028
 
   assert(_maxUndoE);
1029
 
 
1030
 
   _comboRemovalAction =
1031
 
      GTK_WIDGET(gtk_builder_get_object(_builder,
1032
 
                                        "combo_removal_action"));
1033
 
   
1034
 
   comboStore = GTK_LIST_STORE(
1035
 
                   gtk_combo_box_get_model(
1036
 
                      GTK_COMBO_BOX(_comboRemovalAction)));
1037
 
   for (int i = 0; removal_actions[i] != NULL; i++) {
1038
 
      gtk_list_store_append(comboStore, &comboIter);
1039
 
      gtk_list_store_set(comboStore, &comboIter, 0, _(removal_actions[i]), -1);
1040
 
   }
1041
 
   crt = gtk_cell_renderer_text_new();
1042
 
   gtk_cell_layout_clear(GTK_CELL_LAYOUT(_comboRemovalAction));
1043
 
   gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(_comboRemovalAction), crt, TRUE);
1044
 
   gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(_comboRemovalAction),
1045
 
                                          crt, "text", 0);
1046
 
   gtk_combo_box_set_active(GTK_COMBO_BOX(_comboRemovalAction), 0);
1047
 
   assert(_comboRemovalAction);
1048
 
 
1049
 
   _comboUpdateAsk = GTK_WIDGET(gtk_builder_get_object(_builder,
1050
 
                                                       "combo_update_ask"));
1051
 
   comboStore = GTK_LIST_STORE(
1052
 
                   gtk_combo_box_get_model(
1053
 
                      GTK_COMBO_BOX(_comboUpdateAsk)));
1054
 
   for (int i = 0; update_ask[i] != NULL; i++) {
1055
 
      gtk_list_store_append(comboStore, &comboIter);
1056
 
      gtk_list_store_set(comboStore, &comboIter, 0, _(update_ask[i]), -1);
1057
 
   }
1058
 
   crt = gtk_cell_renderer_text_new();
1059
 
   gtk_cell_layout_clear(GTK_CELL_LAYOUT(_comboUpdateAsk));
1060
 
   gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(_comboUpdateAsk), crt, TRUE);
1061
 
   gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(_comboUpdateAsk),
1062
 
                                          crt, "text", 0);
1063
 
   gtk_combo_box_set_active(GTK_COMBO_BOX(_comboUpdateAsk), 0);
1064
 
   assert(_comboUpdateAsk);
1065
 
   
1066
 
   _comboUpgradeMethod = GTK_WIDGET(gtk_builder_get_object(_builder,
1067
 
                                                       "combo_upgrade_method"));
1068
 
   comboStore = GTK_LIST_STORE(
1069
 
                   gtk_combo_box_get_model(
1070
 
                      GTK_COMBO_BOX(_comboUpgradeMethod)));
1071
 
   for (int i = 0; upgrade_method[i] != NULL; i++) {
1072
 
      gtk_list_store_append(comboStore, &comboIter);
1073
 
      gtk_list_store_set(comboStore, &comboIter, 0, _(upgrade_method[i]), -1);
1074
 
   }
1075
 
   crt = gtk_cell_renderer_text_new();
1076
 
   gtk_cell_layout_clear(GTK_CELL_LAYOUT(_comboUpgradeMethod));
1077
 
   gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(_comboUpgradeMethod), crt, TRUE);
1078
 
   gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(_comboUpgradeMethod),
1079
 
                                          crt, "text", 0);
1080
 
   gtk_combo_box_set_active(GTK_COMBO_BOX(_comboUpgradeMethod), 0);
1081
 
   assert(_comboUpgradeMethod);
1082
 
 
1083
 
   _comboDefaultDistro =
1084
 
      GTK_WIDGET(gtk_builder_get_object(_builder, "combobox_default_distro"));
1085
 
   assert(_comboDefaultDistro);
1086
 
   gtk_widget_set_tooltip_text(GTK_WIDGET(gtk_builder_get_object
1087
 
                                   (_builder, "radiobutton_distro")),
1088
 
                       _("Prefer package versions from the selected "
1089
 
                       "distribution when upgrading packages. If you "
1090
 
                       "manually force a version from a different "
1091
 
                       "distribution, the package version will follow "
1092
 
                       "that distribution until it enters the default "
1093
 
                       "distribution."));
1094
 
   gtk_widget_set_tooltip_text(GTK_WIDGET(gtk_builder_get_object        
1095
 
                                   (_builder, "radiobutton_now")),
1096
 
                       _("Never upgrade to a new version automatically. "
1097
 
                            "Be _very_ careful with this option as you will "
1098
 
                            "not get security updates automatically! "
1099
 
                       "If you manually force a version "
1100
 
                       "the package version will follow "
1101
 
                       "the chosen distribution."));
1102
 
   gtk_widget_set_tooltip_text(GTK_WIDGET(gtk_builder_get_object
1103
 
                                   (_builder,"radiobutton_ignore")),
1104
 
                        _("Let synaptic pick the best version for you. "
1105
 
                        "If unsure use this option. "));
1106
 
 
1107
 
 
1108
 
   // hide the "remove with configuration" from rpm users
1109
 
#ifdef HAVE_RPM
1110
 
   GtkWidget *w = GTK_WIDGET(gtk_builder_get_object(_builder,
1111
 
                                                    "menuitem_purge"));
1112
 
   gtk_widget_hide(w);
1113
 
   int delAction = _config->FindI("Synaptic::delAction", PKG_DELETE);
1114
 
   // purge not available 
1115
 
   if (delAction == PKG_PURGE)
1116
 
      delAction = PKG_DELETE;
1117
 
   gtk_widget_hide(GTK_WIDGET(_comboRemovalAction));
1118
 
   gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(_builder,"label_removal"));
1119
 
#endif
1120
 
 
1121
 
   // set data for the checkbutton
1122
 
   g_object_set_data(gtk_builder_get_object
1123
 
                      (_builder, "checkbutton_user_font"), "me", this);
1124
 
   g_object_set_data(gtk_builder_get_object
1125
 
                      (_builder, "checkbutton_user_terminal_font"), "me",
1126
 
                     this);
1127
 
 
1128
 
   // save the lister
1129
 
   _lister = lister;
1130
 
 
1131
 
   // treeview stuff
1132
 
   _treeView = GTK_WIDGET(gtk_builder_get_object(_builder, "treeview_columns"));
1133
 
   GtkCellRenderer *renderer;
1134
 
   GtkTreeViewColumn *column;
1135
 
   renderer = gtk_cell_renderer_toggle_new ();
1136
 
   g_object_set(renderer, "activatable", TRUE, NULL);
1137
 
   g_signal_connect(renderer, "toggled", 
1138
 
                    (GCallback) cbToggleColumn, this);
1139
 
   column = gtk_tree_view_column_new_with_attributes(_("Visible"),
1140
 
                                                      renderer,
1141
 
                                                      "active", TREE_CHECKBOX_COLUMN,
1142
 
                                                      NULL);
1143
 
   gtk_tree_view_append_column (GTK_TREE_VIEW(_treeView), column);
1144
 
   renderer = gtk_cell_renderer_text_new ();
1145
 
   column = gtk_tree_view_column_new_with_attributes (_("Name"),
1146
 
                                                      renderer,
1147
 
                                                      "text", TREE_VISIBLE_NAME_COLUMN,
1148
 
                                                      NULL);
1149
 
   gtk_tree_view_append_column (GTK_TREE_VIEW(_treeView), column);
1150
 
 
1151
 
 
1152
 
   // lots of signals :)
1153
 
   g_signal_connect(gtk_builder_get_object(_builder, "button_column_up"),
1154
 
                    "clicked",
1155
 
                    G_CALLBACK(cbMoveColumnUp), this);
1156
 
   g_signal_connect(gtk_builder_get_object(_builder, "button_column_down"),
1157
 
                    "clicked",
1158
 
                    G_CALLBACK(cbMoveColumnDown), this);
1159
 
 
1160
 
   g_signal_connect(gtk_builder_get_object(_builder, "close"),
1161
 
                    "clicked",
1162
 
                    G_CALLBACK(closeAction), this);
1163
 
   g_signal_connect(gtk_builder_get_object(_builder, "apply"),
1164
 
                    "clicked",
1165
 
                    G_CALLBACK(saveAction), this);
1166
 
   g_signal_connect(gtk_builder_get_object(_builder, "ok"),
1167
 
                    "clicked",
1168
 
                    G_CALLBACK(doneAction), this);
1169
 
 
1170
 
   g_signal_connect(gtk_builder_get_object(_builder, "button_clean_cache"),
1171
 
                    "clicked",
1172
 
                    G_CALLBACK(clearCacheAction), this);
1173
 
 
1174
 
   g_signal_connect(gtk_builder_get_object(_builder, "radio_use_proxy"),
1175
 
                    "toggled",
1176
 
                    G_CALLBACK(useProxyToggled), this);
1177
 
 
1178
 
   g_signal_connect(gtk_builder_get_object(_builder, "button_authentication"),
1179
 
                    "clicked",
1180
 
                    G_CALLBACK(buttonAuthenticationClicked), this);
1181
 
 
1182
 
   g_signal_connect(gtk_builder_get_object(_builder, "button_default_font"),
1183
 
                    "clicked",
1184
 
                    G_CALLBACK(changeFontAction),GINT_TO_POINTER(FONT_DEFAULT));
1185
 
 
1186
 
   g_signal_connect(gtk_builder_get_object(_builder, "checkbutton_user_terminal_font"),
1187
 
                    "toggled",
1188
 
                    G_CALLBACK (checkbuttonUserTerminalFontToggled), this);
1189
 
   g_signal_connect(gtk_builder_get_object(_builder, "checkbutton_user_font"),
1190
 
                    "toggled",
1191
 
                    G_CALLBACK(checkbuttonUserFontToggled), this);
1192
 
 
1193
 
   g_signal_connect(gtk_builder_get_object(_builder, "button_terminal_font"),
1194
 
                                 "clicked",
1195
 
                                 G_CALLBACK(changeFontAction),
1196
 
                                 GINT_TO_POINTER(FONT_TERMINAL));
1197
 
 
1198
 
   checkbuttonUserTerminalFontToggled(NULL, this);
1199
 
   checkbuttonUserFontToggled(NULL, this);
1200
 
 
1201
 
   // color stuff
1202
 
   char *color_button = NULL;
1203
 
   for (int i = 0; i < RGPackageStatus::N_STATUS_COUNT; i++) {
1204
 
      color_button =
1205
 
         g_strdup_printf("button_%s_color",
1206
 
                         RGPackageStatus::pkgStatus.
1207
 
                         getShortStatusString(RGPackageStatus::PkgStatus(i)));
1208
 
      button = GTK_WIDGET(gtk_builder_get_object(_builder, color_button));
1209
 
      assert(button);
1210
 
      g_object_set_data(G_OBJECT(button), "me", this);
1211
 
      g_signal_connect(G_OBJECT(button), "clicked",
1212
 
                       G_CALLBACK(colorClicked), GINT_TO_POINTER(i));
1213
 
      g_free(color_button);
1214
 
   }
1215
 
 
1216
 
   skipTaskbar(true);
1217
 
   setTitle(_("Preferences"));
1218
 
}
1219
 
 
1220
 
void 
1221
 
RGPreferencesWindow::buttonAuthenticationClicked(GtkWidget *self, void *data)
1222
 
{
1223
 
   RGPreferencesWindow *me = (RGPreferencesWindow *)data;
1224
 
 
1225
 
   RGGtkBuilderUserDialog dia(me, "authentication");
1226
 
   GtkBuilder *dia_xml = dia.getGtkBuilder();
1227
 
   GtkWidget *entry_user = GTK_WIDGET(gtk_builder_get_object(dia_xml,"entry_username"));
1228
 
   GtkWidget *entry_pass = GTK_WIDGET(gtk_builder_get_object(dia_xml,"entry_password"));
1229
 
 
1230
 
   // now set the values
1231
 
   string now_user =  _config->Find("Synaptic::httpProxyUser","");
1232
 
   gtk_entry_set_text(GTK_ENTRY(entry_user), now_user.c_str());
1233
 
   string now_pass =   _config->Find("Synaptic::httpProxyPass","");
1234
 
   gtk_entry_set_text(GTK_ENTRY(entry_pass), now_pass.c_str());
1235
 
 
1236
 
   int res = dia.run();
1237
 
 
1238
 
   if(!res) 
1239
 
      return;
1240
 
 
1241
 
   // get the entered data
1242
 
   const gchar *user = gtk_entry_get_text(GTK_ENTRY(entry_user));
1243
 
   const gchar *pass = gtk_entry_get_text(GTK_ENTRY(entry_pass));
1244
 
   
1245
 
   // write out the configuration   
1246
 
   _config->Set("Synaptic::httpProxyUser",user);
1247
 
   _config->Set("Synaptic::httpProxyPass",pass);
1248
 
}
1249
 
 
1250
 
// vim:ts=3:sw=3:et