source: projects/synaptic/trunk/gtk/rgsummarywindow.cc @ 280

Revision 280, 17.2 KB checked in by yasumichi, 15 years ago (diff)

first import

Line 
1/* rgsummarywindow.cc
2 *
3 * Copyright (c) 2000, 2001 Conectiva S/A
4 *               2002 Michael Vogt <mvo@debian.org>
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 <X11/keysym.h>
28
29#include <apt-pkg/configuration.h>
30#include <apt-pkg/strutl.h>
31
32#include "rpackagelister.h"
33
34#include <stdio.h>
35#include <string>
36#include <cassert>
37
38#include "rgsummarywindow.h"
39#include "rguserdialog.h"
40
41#include "i18n.h"
42
43
44void RGSummaryWindow::clickedOk(GtkWidget *self, void *data)
45{
46   RGSummaryWindow *me = (RGSummaryWindow *) data;
47
48   me->_confirmed = true;
49   gtk_main_quit();
50}
51
52
53void RGSummaryWindow::clickedCancel(GtkWidget *self, void *data)
54{
55   RGSummaryWindow *me = (RGSummaryWindow *) data;
56
57   me->_confirmed = false;
58   gtk_main_quit();
59}
60
61void RGSummaryWindow::buildTree(RGSummaryWindow *me)
62{
63   RPackageLister *lister = me->_lister;
64   GtkTreeIter iter, iter_child;
65
66   vector<RPackage *> held;
67   vector<RPackage *> kept;
68   vector<RPackage *> essential;
69   vector<RPackage *> toInstall;
70   vector<RPackage *> toReInstall;
71   vector<RPackage *> toUpgrade;
72   vector<RPackage *> toRemove;
73   vector<RPackage *> toPurge;
74   vector<RPackage *> toDowngrade;
75#ifdef WITH_APT_AUTH
76   vector<string> notAuthenticated;
77#endif
78   double sizeChange;
79
80   lister->getDetailedSummary(held, kept, essential, toInstall, toReInstall,
81                              toUpgrade,  toRemove, toPurge, toDowngrade, 
82#ifdef WITH_APT_AUTH
83                              notAuthenticated,
84#endif
85                              sizeChange);
86
87#ifdef WITH_APT_AUTH
88   if(notAuthenticated.size() > 0) {
89      GtkWidget *label;
90      label = glade_xml_get_widget(me->_gladeXML, "label_auth_warning");
91      assert(label);
92      // FIXME: make this a message from a trust class (and remeber to
93      // change the text in rgchangeswindow then too)
94      gchar *msg = g_strdup_printf("<span weight=\"bold\" size=\"larger\">%s"
95                                   "</span>\n\n%s",
96                                   _("Warning"), 
97                                   _("You are about to install software that "
98                                     "<b>can't be authenticated</b>! Doing "
99                                     "this could allow a malicious individual "
100                                     "to damage or take control of your "
101                                     "system."));
102      gtk_label_set_markup(GTK_LABEL(label), msg);
103      gtk_widget_show(label);
104      g_free(msg);
105
106      /* not authenticated */
107      gtk_tree_store_append(me->_treeStore, &iter, NULL);
108      gtk_tree_store_set(me->_treeStore, &iter,
109                         PKG_COLUMN, _("NOT AUTHENTICATED"), -1);
110
111      for (vector<string>::const_iterator p = notAuthenticated.begin();
112           p != notAuthenticated.end(); p++) {
113         gtk_tree_store_append(me->_treeStore, &iter_child, &iter);
114         gtk_tree_store_set(me->_treeStore, &iter_child,
115                            PKG_COLUMN, (*p).c_str(), -1);
116      }
117   }
118#endif
119
120
121   if (essential.size() > 0) {
122      /* (Essentail) removed */
123      gtk_tree_store_append(me->_treeStore, &iter, NULL);
124      gtk_tree_store_set(me->_treeStore, &iter,
125                         PKG_COLUMN, _("<b>(ESSENTIAL) to be removed</b>"), 
126                         -1);
127
128      for (vector<RPackage *>::const_iterator p = essential.begin();
129           p != essential.end(); p++) {
130         gtk_tree_store_append(me->_treeStore, &iter_child, &iter);
131         gtk_tree_store_set(me->_treeStore, &iter_child,
132                            PKG_COLUMN, (*p)->name(), -1);
133      }
134   }
135   if (toDowngrade.size() > 0) {
136      /* removed */
137      gtk_tree_store_append(me->_treeStore, &iter, NULL);
138      gtk_tree_store_set(me->_treeStore, &iter,
139                         PKG_COLUMN, _("<b>To be DOWNGRADED</b>"), -1);
140      for (vector<RPackage *>::const_iterator p = toDowngrade.begin();
141           p != toDowngrade.end(); p++) {
142         gtk_tree_store_append(me->_treeStore, &iter_child, &iter);
143         gtk_tree_store_set(me->_treeStore, &iter_child,
144                            PKG_COLUMN, (*p)->name(), -1);
145      }
146   }
147
148   if (toRemove.size() > 0) {
149      /* removed */
150      gtk_tree_store_append(me->_treeStore, &iter, NULL);
151      gtk_tree_store_set(me->_treeStore, &iter,
152                         PKG_COLUMN, _("<b>To be removed</b>"), -1);
153      for (vector<RPackage *>::const_iterator p = toRemove.begin();
154           p != toRemove.end(); p++) {
155         gtk_tree_store_append(me->_treeStore, &iter_child, &iter);
156         gtk_tree_store_set(me->_treeStore, &iter_child,
157                            PKG_COLUMN, (*p)->name(), -1);
158      }
159   }
160
161   if (toPurge.size() > 0) {
162      /* removed */
163      gtk_tree_store_append(me->_treeStore, &iter, NULL);
164      gtk_tree_store_set(me->_treeStore, &iter,
165                         PKG_COLUMN, _("<b>To be completely removed (including configuration files)</b>"), 
166                         -1);
167      for (vector<RPackage *>::const_iterator p = toPurge.begin();
168           p != toPurge.end(); p++) {
169         gtk_tree_store_append(me->_treeStore, &iter_child, &iter);
170         gtk_tree_store_set(me->_treeStore, &iter_child,
171                            PKG_COLUMN, (*p)->name(), -1);
172      }
173   }
174
175   if (toUpgrade.size() > 0) {
176      gtk_tree_store_append(me->_treeStore, &iter, NULL);
177      gtk_tree_store_set(me->_treeStore, &iter,
178                         PKG_COLUMN, _("To be upgraded"), -1);
179      for (vector<RPackage *>::const_iterator p = toUpgrade.begin();
180           p != toUpgrade.end(); p++) {
181         gtk_tree_store_append(me->_treeStore, &iter_child, &iter);
182         gtk_tree_store_set(me->_treeStore, &iter_child,
183                            PKG_COLUMN, (*p)->name(), -1);
184      }
185   }
186
187   if (toInstall.size() > 0) {
188      gtk_tree_store_append(me->_treeStore, &iter, NULL);
189      gtk_tree_store_set(me->_treeStore, &iter,
190                         PKG_COLUMN, _("To be installed"), -1);
191      for (vector<RPackage *>::const_iterator p = toInstall.begin();
192           p != toInstall.end(); p++) {
193         gtk_tree_store_append(me->_treeStore, &iter_child, &iter);
194         gtk_tree_store_set(me->_treeStore, &iter_child,
195                            PKG_COLUMN, (*p)->name(), -1);
196      }
197   }
198
199  if(toReInstall.size() > 0) {
200    gtk_tree_store_append (me->_treeStore, &iter, NULL); 
201    gtk_tree_store_set (me->_treeStore, &iter,
202                        PKG_COLUMN, _("To be re-installed"),-1);
203    for (vector<RPackage*>::const_iterator p = toReInstall.begin(); 
204         p != toReInstall.end(); 
205         p++) 
206      {
207        gtk_tree_store_append (me->_treeStore, &iter_child, &iter);
208        gtk_tree_store_set(me->_treeStore, &iter_child,
209                           PKG_COLUMN,(*p)->name(), -1);
210      }
211  }
212
213
214   if (held.size() > 0) {
215      gtk_tree_store_append(me->_treeStore, &iter, NULL);
216      gtk_tree_store_set(me->_treeStore, &iter,
217                         PKG_COLUMN, _("Unchanged"), -1);
218      for (vector<RPackage *>::const_iterator p = held.begin();
219           p != held.end(); p++) {
220         gtk_tree_store_append(me->_treeStore, &iter_child, &iter);
221         gtk_tree_store_set(me->_treeStore, &iter_child,
222                            PKG_COLUMN, (*p)->name(), -1);
223      }
224   }
225
226   
227
228}
229
230
231void RGSummaryWindow::buildLabel(RGSummaryWindow *me)
232{
233   GtkWidget *info;
234   string text;
235   gchar *str;
236
237   info = glade_xml_get_widget(me->_gladeXML, "label_details");
238
239   vector<RPackage *> held;
240   vector<RPackage *> kept;
241   vector<RPackage *> essential;
242   vector<RPackage *> toInstall;
243   vector<RPackage *> toReInstall;
244   vector<RPackage *> toUpgrade;
245   vector<RPackage *> toRemove;
246   vector<RPackage *> toPurge;
247   vector<RPackage *> toDowngrade;
248   vector<string> notAuthenticated;
249   double sizeChange;
250
251   me->_lister->getDetailedSummary(held, kept, essential,
252                                   toInstall,toReInstall,toUpgrade, 
253                                   toRemove, toPurge, toDowngrade, 
254#ifdef WITH_APT_AUTH
255                                   notAuthenticated,
256#endif
257                                   sizeChange);
258
259   for (vector<RPackage *>::const_iterator p = essential.begin();
260        p != essential.end(); p++) {
261      str =
262         g_strdup_printf(_("<b>%s</b> (<b>essential</b>) will be removed\n"),
263                         (*p)->name());
264      text += str;
265      g_free(str);
266   }
267
268   for (vector<RPackage *>::const_iterator p = toDowngrade.begin();
269        p != toDowngrade.end(); p++) {
270      str =
271         g_strdup_printf(_("<b>%s</b> will be <b>downgraded</b>\n"),
272                         (*p)->name());
273      text += str;
274      g_free(str);
275   }
276
277   for (vector<RPackage *>::const_iterator p = toPurge.begin();
278        p != toPurge.end(); p++) {
279      str = g_strdup_printf(_("<b>%s</b> will be removed with configuration\n"), 
280                            (*p)->name());
281      text += str;
282      g_free(str);
283   }
284
285   for (vector<RPackage *>::const_iterator p = toRemove.begin();
286        p != toRemove.end(); p++) {
287      str = g_strdup_printf(_("<b>%s</b> will be removed\n"), (*p)->name());
288      text += str;
289      g_free(str);
290   }
291
292   for (vector<RPackage *>::const_iterator p = toUpgrade.begin();
293        p != toUpgrade.end(); p++) {
294      str =
295         g_strdup_printf(_
296                         ("<b>%s</b> (version <i>%s</i>) will be upgraded to version <i>%s</i>\n"),
297                         (*p)->name(), (*p)->installedVersion(),
298                         (*p)->availableVersion());
299      text += str;
300      g_free(str);
301   }
302
303   for (vector<RPackage *>::const_iterator p = toInstall.begin();
304        p != toInstall.end(); p++) {
305      str =
306         g_strdup_printf(_
307                         ("<b>%s</b> (version <i>%s</i>) will be installed\n"),
308                         (*p)->name(), (*p)->availableVersion());
309      text += str;
310      g_free(str);
311   }
312
313   for (vector<RPackage*>::const_iterator p = toReInstall.begin(); 
314        p != toReInstall.end(); p++) {
315       str = g_strdup_printf(_("<b>%s</b> (version <i>%s</i>) will be re-installed\n"),(*p)->name(), (*p)->installedVersion());
316       text += str;
317       g_free(str);
318   }
319
320   gtk_label_set_markup(GTK_LABEL(info), text.c_str());
321}
322
323void RGSummaryWindow::clickedDetails(GtkWidget *self, void *data)
324{
325   RGSummaryWindow *me = (RGSummaryWindow *) data;
326   GtkWidget *s,*d;
327   GtkWidget *info;
328
329   s = glade_xml_get_widget(me->_gladeXML, "scrolledwindow_summary");
330   d = glade_xml_get_widget(me->_gladeXML, "scrolledwindow_details");
331
332   if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self))) {
333      gtk_widget_hide(s);
334      gtk_widget_show(d);
335   } else {
336      gtk_widget_show(s);
337      gtk_widget_hide(d);
338   }
339}
340
341
342RGSummaryWindow::RGSummaryWindow(RGWindow *wwin, RPackageLister *lister)
343: RGGladeWindow(wwin, "summary")
344{
345   GtkWidget *button;
346
347   _potentialBreak = false;
348   _lister = lister;
349
350   setTitle(_("Summary"));
351   //gtk_window_set_default_size(GTK_WINDOW(_win), 400, 250);
352
353
354   _summaryL = glade_xml_get_widget(_gladeXML, "label_summary");
355   assert(_summaryL);
356
357   _summarySpaceL = glade_xml_get_widget(_gladeXML, "label_summary_space");
358   assert(_summarySpaceL);
359
360   // details label
361   buildLabel(this);
362
363   // new tree store
364   _treeStore = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING);
365   buildTree(this);
366   _tree = glade_xml_get_widget(_gladeXML, "treeview_summary");
367   assert(_tree);
368   gtk_tree_view_set_model(GTK_TREE_VIEW(_tree), GTK_TREE_MODEL(_treeStore));
369
370   GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
371   //GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("Summary",renderer, PKG_COLUMN, "pkg", NULL);
372   GtkTreeViewColumn *column;
373   column = gtk_tree_view_column_new_with_attributes(_("Marked Changes"),
374                                                     renderer,
375                                                     "markup", PKG_COLUMN, NULL);
376   /* Add the column to the view. */
377   gtk_tree_view_append_column(GTK_TREE_VIEW(_tree), column);
378   gtk_widget_show(_tree);
379
380   _dlonlyB = glade_xml_get_widget(_gladeXML, "checkbutton_download_only");
381
382   _checkSigsB = glade_xml_get_widget(_gladeXML, "checkbutton_check_signatures");
383   assert(_checkSigsB);
384#ifdef HAVE_RPM
385   bool check = _config->FindB("RPM::GPG-Check", true);
386   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_checkSigsB), check);
387   gtk_widget_show(_checkSigsB);
388#endif
389
390   button = glade_xml_get_widget(_gladeXML, "togglebutton_details");
391   gtk_signal_connect(GTK_OBJECT(button), "clicked",
392                      (GtkSignalFunc) clickedDetails, this);
393
394
395
396   button = _defBtn = glade_xml_get_widget(_gladeXML, "button_execute");
397   assert(button);
398   gtk_signal_connect(GTK_OBJECT(button), "clicked",
399                      (GtkSignalFunc) clickedOk, this);
400
401   button = glade_xml_get_widget(_gladeXML, "button_cancel");
402   assert(button);
403   gtk_signal_connect(GTK_OBJECT(button), "clicked",
404                      (GtkSignalFunc) clickedCancel, this);
405
406   int toInstall, toReInstall, toRemove, toUpgrade, toDowngrade;
407   int held, kept, essential, unAuthenticated;
408   double sizeChange, dlSize;
409   int dlCount;
410   GString *msg = g_string_new("");
411   GString *msg_space = g_string_new("");
412
413   lister->getSummary(held, kept, essential,
414                      toInstall, toReInstall, toUpgrade, toRemove, 
415                      toDowngrade, unAuthenticated,sizeChange);
416   lister->getDownloadSummary(dlCount, dlSize);
417
418#if 0
419   if (held) {
420      char *str = ngettext("%d package is locked\n",
421                           "%d packages are locked\n", held);
422      g_string_append_printf(msg, str, held);
423   }
424#endif
425
426   if (held) {
427      char *str = ngettext("%d package will be held back and not upgraded\n",
428                           "%d packages will be held back and not upgraded\n",
429                           held);
430      g_string_append_printf(msg, str, held);
431   }
432
433   if (toInstall) {
434      char *str = ngettext("%d new package will be installed\n",
435                           "%d new packages will be installed\n",
436                           toInstall);
437      g_string_append_printf(msg, str, toInstall);
438   }
439
440   if (toReInstall) {
441       char *str = ngettext("%d new package will be re-installed\n",
442                            "%d new packages will be re-installed\n",
443                            toReInstall);
444       g_string_append_printf(msg, str, toReInstall);
445   }
446
447   if (toUpgrade) {
448      char *str = ngettext("%d package will be upgraded\n",
449                           "%d packages will be upgraded\n",
450                           toUpgrade);
451      g_string_append_printf(msg, str, toUpgrade);
452   }
453
454   if (toRemove) {
455      char *str = ngettext("%d package will be removed\n",
456                           "%d packages will be removed\n",
457                           toRemove);
458      g_string_append_printf(msg, str, toRemove);
459   }
460
461   if (toDowngrade) {
462      char *str = ngettext("%d package will be <b>downgraded</b>\n",
463                           "%d packages will be <b>downgraded</b>\n",
464                           toDowngrade);
465      g_string_append_printf(msg, str, toDowngrade);
466   }
467
468   if (essential) {
469      char *str =
470         ngettext("<b>Warning:</b> %d essential package will be removed\n",
471                  "<b>Warning:</b> %d essential packages will be removed\n",
472                  essential);
473      g_string_append_printf(msg, str, essential);
474      _potentialBreak = true;
475   }
476   // remove the trailing newline of msg
477   if (msg->str[msg->len - 1] == '\n')
478      msg = g_string_truncate(msg, msg->len - 1);
479
480   /* this stuff goes to the msg_space string */
481   if (sizeChange > 0) {
482      g_string_append_printf(msg_space, _("%s of extra space will be used"),
483                             SizeToStr(sizeChange).c_str());
484   } else if (sizeChange < 0) {
485      g_string_append_printf(msg_space, _("%s of extra space will be freed"),
486                             SizeToStr(sizeChange).c_str());
487      sizeChange = -sizeChange;
488   }
489
490   if (dlSize > 0) {
491      g_string_append_printf(msg_space, _("\n%s have to be downloaded"),
492                             SizeToStr(dlSize).c_str());
493   }
494
495   gtk_label_set_markup(GTK_LABEL(_summaryL), msg->str);
496   gtk_label_set_markup(GTK_LABEL(_summarySpaceL), msg_space->str);
497   g_string_free(msg, TRUE);
498   g_string_free(msg_space, TRUE);
499   if(!_config->FindB("Volatile::HideMainwindow", false))
500      skipTaskbar(true);
501   else
502      skipTaskbar(false);
503}
504
505
506
507bool RGSummaryWindow::showAndConfirm()
508{
509   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_dlonlyB),
510                                _config->FindB("Volatile::Download-Only",
511                                               false));
512
513   show();
514   gtk_window_set_modal(GTK_WINDOW(_win), TRUE);
515   gtk_main();
516
517   RGUserDialog userDialog(this);
518   if (_confirmed && _potentialBreak
519       && userDialog.warning(_("Essential packages will be removed.\n"
520                               "This may render your system unusable!\n")
521                             , false) == false)
522      return false;
523
524   _config->Set("Volatile::Download-Only",
525                gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_dlonlyB)) ?
526                "true" : "false");
527#ifdef HAVE_RPM
528   _config->Set("RPM::GPG-Check",
529                gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(_checkSigsB)) ?
530                "true" : "false");
531#endif
532
533   return _confirmed;
534}
Note: See TracBrowser for help on using the repository browser.