libyui-ncurses-pkg  2.43.4.1
 All Classes Functions
NCPkgTable.cc
1 /****************************************************************************
2 |
3 | Copyright (c) [2002-2011] Novell, Inc.
4 | All Rights Reserved.
5 |
6 | This program is free software; you can redistribute it and/or
7 | modify it under the terms of version 2 of the GNU General Public License as
8 | published by the Free Software Foundation.
9 |
10 | This program is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | GNU General Public License for more details.
14 |
15 | You should have received a copy of the GNU General Public License
16 | along with this program; if not, contact Novell, Inc.
17 |
18 | To contact Novell about this file by physical or electronic mail,
19 | you may find current contact information at www.novell.com
20 |
21 |***************************************************************************/
22 
23 
24 /*---------------------------------------------------------------------\
25 | |
26 | __ __ ____ _____ ____ |
27 | \ \ / /_ _/ ___|_ _|___ \ |
28 | \ V / _` \___ \ | | __) | |
29 | | | (_| |___) || | / __/ |
30 | |_|\__,_|____/ |_| |_____| |
31 | |
32 | core system |
33 | (C) SuSE GmbH |
34 \----------------------------------------------------------------------/
35 
36  File: NCPkgTable.cc
37 
38  Author: Gabriele Strattner <gs@suse.de>
39 
40 /-*/
41 #define YUILogComponent "ncurses-pkg"
42 #include <YUILog.h>
43 #include <YDialog.h>
44 
45 #include "NCurses.h"
46 #include "NCPkgTable.h"
47 #include "NCTable.h"
48 #include "NCPopupInfo.h"
49 #include "NCPkgStrings.h"
50 #include "NCi18n.h"
51 #include "NCPkgPopupDiskspace.h"
52 #include "NCPackageSelector.h"
53 #include <zypp/ui/Selectable.h>
54 #include "NCZypp.h"
55 
56 using std::endl;
57 
58 /*
59  Textdomain "ncurses-pkg"
60 */
61 
62 ///////////////////////////////////////////////////////////////////
63 //
64 //
65 // METHOD NAME : NCPkgTableTag::NCPkgTableTag
66 // METHOD TYPE : Constructor
67 //
68 // DESCRIPTION :
69 //
70 NCPkgTableTag::NCPkgTableTag( ZyppObj objPtr, ZyppSel selPtr,
71  ZyppStatus stat )
72  : YTableCell( " " )
73  , status ( stat )
74  , dataPointer( objPtr )
75  , selPointer( selPtr )
76 {
77  setLabel( statusToString(stat) );
78 }
79 
80 std::string NCPkgTableTag::statusToString( ZyppStatus stat ) const
81 {
82  // convert ZyppStatus to std::string
83  switch ( stat )
84  {
85  case S_NoInst: // Is not installed and will not be installed
86  return " ";
87  case S_KeepInstalled: // Is installed - keep this version
88  return " i ";
89  case S_Install: // Will be installed
90  return " + ";
91  case S_Del: // Will be deleted
92  return " - ";
93  case S_Update: // Will be updated
94  return " > ";
95  case S_AutoInstall: // Will be automatically installed
96  return " a+ ";
97  case S_AutoDel: // Will be automatically deleted
98  return " a- ";
99  case S_AutoUpdate: // Will be automatically updated
100  return " a> ";
101  case S_Taboo: // Never install this
102  return " ---";
103  case S_Protected: // always keep installed version
104  return " -i-";
105  default:
106  return "####";
107  }
108 
109  return " ";
110 }
111 
112 ///////////////////////////////////////////////////////////////////
113 //
114 //
115 // METHOD NAME : NCPkgTable::NCPkgTable
116 // METHOD TYPE : Constructor
117 //
118 // DESCRIPTION :
119 //
120 NCPkgTable::NCPkgTable( YWidget * parent, YTableHeader * tableHeader )
121  : NCTable( parent, tableHeader )
122  , packager ( 0 )
123  , statusStrategy( new PackageStatStrategy ) // default strategy: packages
124  , tableType ( T_Packages ) // default type: packages
125  , haveInstalledVersion ( false )
126  , visibleInfo( I_Technical )
127 {
128  yuiDebug() << "NCPkgTable created" << endl;
129 }
130 
131 
132 ///////////////////////////////////////////////////////////////////
133 //
134 //
135 // METHOD NAME : NCPkgTable::~NCPkgTable
136 // METHOD TYPE : Destructor
137 //
138 // DESCRIPTION :
139 //
140 NCPkgTable::~NCPkgTable()
141 {
142  delete statusStrategy;
143  yuiDebug() << endl;
144 }
145 
146 
147 
148 ///////////////////////////////////////////////////////////////////
149 //
150 //
151 // METHOD NAME : NCPkgTable::addLine
152 // METHOD TYPE : void
153 //
154 // DESCRIPTION :
155 //
156 void NCPkgTable::addLine( ZyppStatus stat,
157  const std::vector<std::string> & elements,
158  ZyppObj objPtr,
159  ZyppSel slbPtr )
160 {
161  YTableItem *tabItem = new YTableItem();
162 
163  // fill first column (containing the status information and the package pointers)
164  tabItem->addCell( new NCPkgTableTag( objPtr, slbPtr, stat ));
165 
166 
167  for ( unsigned i = 1; i < elements.size()+1; ++i ) {
168  tabItem->addCell( elements[i-1] );
169  }
170 
171  // use all-at-once insertion mode - DrawPad() is called only after the loop
172  addItem(tabItem, true);
173 
174 }
175 
176 ///////////////////////////////////////////////////////////////////
177 //
178 //
179 // METHOD NAME : NCPkgTable::deleteAllItems
180 // METHOD TYPE : void
181 //
182 // DESCRIPTION :
183 //
185 {
186  return NCTable::deleteAllItems();
187 }
188 
189 
190 ///////////////////////////////////////////////////////////////////
191 //
192 //
193 // METHOD NAME : NCPkgTable::cellChanged
194 // METHOD TYPE : void
195 //
196 // DESCRIPTION :
197 //
198 void NCPkgTable::cellChanged( int index, int colnum, const std::string & newtext )
199 {
200  return NCTable::cellChanged( index, colnum, newtext );
201 }
202 
203 ///////////////////////////////////////////////////////////////////
204 //
205 //
206 // METHOD NAME : NCPkgTable::changeStatus
207 // METHOD TYPE : bool
208 //
209 // DESCRIPTION : sets the new status in first column of the package table
210 // and informs the package manager
211 //
212 bool NCPkgTable::changeStatus( ZyppStatus newstatus,
213  const ZyppSel & slbPtr,
214  // objPtr is candidatePtr or what the user selected instead of it.
215  ZyppObj objPtr,
216  bool singleChange )
217 {
218  if ( !packager || !slbPtr )
219  return false;
220 
221  std::string notify;
222  std::string license;
223  bool license_confirmed = true;
224  ZyppPkg pkgPtr = NULL;
225  std::string header;
226  bool ok = true;
227  int cols = NCurses::cols();
228  int lines = NCurses::lines();
229 
230  switch ( newstatus )
231  {
232  case S_Del:
233  case S_NoInst:
234  case S_Taboo:
235  if ( objPtr )
236  {
237  notify = objPtr->delnotify();
238  yuiMilestone() << "DELETE message: " << notify << endl;
239  header = NCPkgStrings::WarningLabel();
240  }
241  break;
242  //display notify msg only if we mark pkg for installation
243  //disregard update, to be consistent with Qt (#308410)
244  case S_Install:
245  if ( objPtr )
246  {
247  notify = objPtr->insnotify();
248  yuiMilestone() << "NOTIFY message: " << notify << endl;
249  header = NCPkgStrings::NotifyLabel();
250  }
251  case S_Update:
252  case S_AutoInstall:
253  case S_AutoUpdate:
254  if ( objPtr )
255  {
256  // check license of packages and patches in case of S_Install/S_Update/S_AutoInstall/S_AutoUpdate
257  license = objPtr->licenseToConfirm();
258  license_confirmed = slbPtr->hasLicenceConfirmed();
259  }
260  break;
261 
262  default: break;
263  }
264 
265  std::string pkgName = slbPtr->name();
266 
267  if ( !license.empty() )
268  {
269  if ( !license_confirmed )
270  {
271  license_confirmed = packager->showLicensePopup( pkgName, license);
272  }
273 
274  if ( !license_confirmed )
275  {
276  // make sure the package won't be installed
277  switch ( newstatus )
278  {
279  case S_Install:
280  case S_AutoInstall:
281  newstatus = S_Taboo;
282  break;
283 
284  case S_Update:
285  case S_AutoUpdate:
286  newstatus = S_Protected;
287  break;
288 
289  default:
290  break;
291  }
292 
293  ok = false;
294  } else {
295  yuiMilestone() << "User confirmed license agreement for " << pkgName << endl;
296  slbPtr->setLicenceConfirmed (true);
297  }
298  }
299 
300  if ( ok && !notify.empty() )
301  {
302  std::string html_text = packager->InfoText()->createHtmlText( notify );
303  NCPopupInfo * info = new NCPopupInfo( wpos( (lines * 35)/100, (cols * 25)/100),
304  header,
305  "<i>" + pkgName + "</i><br><br>" + html_text
306  );
307  info->setPreferredSize( (NCurses::cols() * 50)/100, (NCurses::lines() * 30)/100);
308  info->showInfoPopup( );
309 
310  YDialog::deleteTopmostDialog();
311  }
312 
313  // inform the package manager
314  ok = statusStrategy->setObjectStatus( newstatus, slbPtr, objPtr );
315 
316  if ( ok && singleChange )
317  {
318  switch ( tableType )
319  {
320  case T_Packages:
321  case T_PatchPkgs:
322  case T_Update:
323  // check/show dependencies of packages
324  packager->showPackageDependencies( false ); // only check if automatic check is ON
325  // show the required diskspace
326  packager->showDiskSpace();
327  break;
328  case T_Availables:
329  // check/show dependencies of packages
330  packager->showPackageDependencies( false );
331  // don't show diskspace (type T_Availables is also used in YOU mode)
332  break;
333  case T_Selections:
334  // check/show dependencies of selections
335  packager->showSelectionDependencies();
336  packager->showDiskSpace();
337  break;
338 
339  case T_Patches:
340  // show the download size for all selected patches
341  packager->showDownloadSize();
342  packager->showPackageDependencies( false );
343  break;
344 
345  default:
346  break;
347  }
348  // update this list to show the status changes
349  updateTable();
350 
351  if ( tableType == T_Availables || tableType == T_MultiVersion )
352  {
353  // additionally update the package list
354  packager->updatePackageList();
355  }
356  }
357 
358  return ok;
359 }
360 
361 ///////////////////////////////////////////////////////////////////
362 //
363 //
364 // METHOD NAME : NCPkgTable::updateTable
365 // METHOD TYPE : bool
366 //
367 // DESCRIPTION : set the new status info if status has changed
368 //
370 {
371  unsigned int size = getNumLines();
372  unsigned int index = 0;
373  bool ret = true;
374 
375  while ( index < size )
376  {
377  // get the table line
378  NCTableLine * cl = myPad()->ModifyLine( index );
379  if ( !cl )
380  {
381  ret = false;
382  break;
383  }
384 
385  // get first column (the column containing the status info)
386  YTableItem *it = dynamic_cast<YTableItem*> (cl->origItem() );
387  YTableCell *tcell = it->cell(0);
388  NCPkgTableTag * cc = static_cast<NCPkgTableTag*>( tcell );
389  // get the object pointer
390  ZyppSel slbPtr = getSelPointer( index );
391  ZyppObj objPtr = getDataPointer( index );
392 
393  if ( !cc )
394  {
395  ret = false;
396  break;
397  }
398 
399  ZyppStatus newstatus = S_NoInst;
400  if ( slbPtr && objPtr)
401  {
402  if ( tableType == T_Availables && !slbPtr->multiversionInstall() )
403  {
404  std::string isCandidate = " ";
405  if ( objPtr == slbPtr->candidateObj() )
406  isCandidate = " x ";
407 
408  cl->AddCol( 2, new NCTableCol( isCandidate ) );
409  }
410  else
411  {
412  // get the new status and replace old status
413  newstatus = statusStrategy->getPackageStatus( slbPtr, objPtr );
414 
415  // set new status (if status has changed)
416  if ( getStatus(index) != newstatus )
417  {
418  cc->setStatus( newstatus );
419  cellChanged( index, 0, cc->statusToString (newstatus) );
420  }
421  }
422  }
423  index++;
424  }
425 
426  DrawPad();
427 
428  return ret;
429 }
430 
431 ///////////////////////////////////////////////////////////////////
432 //
433 // slbHasInstalledObj
434 //
435 // a helper to call a method
436 //
437 static bool slbHasInstalledObj (const ZyppSel & slb)
438 {
439  return ! slb->installedEmpty ();
440 }
441 
442 ///////////////////////////////////////////////////////////////////
443 //
444 // fillHeader
445 //
446 // Fillup the column headers of the package table
447 //
449 {
450  std::vector<std::string> header;
451 
452  switch ( tableType )
453  {
454  case T_Packages:
455  case T_Update: {
456  bool haveInstalledPkgs = find_if (zyppPkgBegin (), zyppPkgEnd (),
457  slbHasInstalledObj) != zyppPkgEnd ();
458 
459  header.reserve(7);
460  header.push_back( "L" + NCPkgStrings::PkgStatus() );
461  header.push_back( "L" + NCPkgStrings::PkgName() );
462  header.push_back( "L" + NCPkgStrings::PkgSummary() );
463  if ( haveInstalledPkgs > 0 )
464  {
465  header.push_back( "L" + NCPkgStrings::PkgVersionNew() );
466  header.push_back( "L" + NCPkgStrings::PkgVersionInst() );
467  haveInstalledVersion = true;
468  }
469  else
470  {
471  header.push_back( "L" + NCPkgStrings::PkgVersion() );
472  }
473  header.push_back( "L" + NCPkgStrings::PkgSize() );
474 // installation of source rpms is not possible
475 #ifdef FIXME
476  header.push_back( "L" + NCPkgStrings::PkgSource() );
477 #endif
478  break;
479  }
480  case T_PatchPkgs: {
481  header.reserve(7);
482  header.push_back( "L" + NCPkgStrings::PkgStatus() );
483  header.push_back( "L" + NCPkgStrings::PkgName() );
484  header.push_back( "L" + NCPkgStrings::PkgVersionNew() );
485  header.push_back( "L" + NCPkgStrings::PkgVersionInst() );
486  header.push_back( "L" + NCPkgStrings::PkgSummary() );
487  header.push_back( "L" + NCPkgStrings::PkgSize() );
488  break;
489  }
490  case T_Patches: {
491  header.reserve(6);
492  header.push_back( "L" + NCPkgStrings::PkgStatus() );
493  header.push_back( "L" + NCPkgStrings::PkgName() );
494  header.push_back( "L" + NCPkgStrings::PkgSummary() );
495  header.push_back( "L" + NCPkgStrings::PatchKind() );
496  header.push_back( "L" + NCPkgStrings::PkgVersion() );
497  // header.push_back( "L" + NCPkgStrings::PkgSize() );
498  break;
499  }
500  case T_Selections: {
501  header.reserve(3);
502  header.push_back( "L" + NCPkgStrings::PkgStatus() );
503  header.push_back( "L" + NCPkgStrings::PatternsLabel() );
504  break;
505  }
506  case T_Languages: {
507  header.reserve(4);
508  header.push_back( "L" + NCPkgStrings::PkgStatus() );
509  header.push_back( "L" + NCPkgStrings::LangCode() );
510  header.push_back( "L" + NCPkgStrings::LangName() );
511  break;
512  }
513  case T_Availables: {
514  header.reserve(6);
515  header.push_back( "L" + NCPkgStrings::PkgStatus() );
516  header.push_back( "L" + NCPkgStrings::PkgName() );
517  header.push_back( "L" + NCPkgStrings::PkgStatus() );
518  header.push_back( "L" + NCPkgStrings::PkgVersion() );
519  header.push_back( "L" + NCPkgStrings::PkgInstSource() );
520  header.push_back( "L" + NCPkgStrings::PkgSize() );
521  header.push_back( "L" + NCPkgStrings::PkgArch() );
522  break;
523  }
524  case T_MultiVersion: {
525  header.reserve(5);
526  header.push_back( "L" + NCPkgStrings::PkgStatus() );
527  header.push_back( "L" + NCPkgStrings::PkgName() );
528  header.push_back( "L" + NCPkgStrings::PkgVersion() );
529  header.push_back( "L" + NCPkgStrings::PkgInstSource() );
530  header.push_back( "L" + NCPkgStrings::PkgSize() );
531  header.push_back( "L" + NCPkgStrings::PkgArch() );
532  break;
533  }
534  default: {
535  header.reserve(4);
536  header.push_back( "L" + NCPkgStrings::PkgStatus() );
537  header.push_back( "L" + NCPkgStrings::PkgName() );
538  header.push_back( "L" + NCPkgStrings::PkgSummary() );
539  break;
540  }
541  }
542  setHeader( header );
543 }
544 
545 ///////////////////////////////////////////////////////////////////
546 //
547 // createListEntry
548 //
549 //
550 bool NCPkgTable::createListEntry ( ZyppPkg pkgPtr, ZyppSel slbPtr )
551 {
552  std::vector<std::string> pkgLine;
553  pkgLine.reserve(6);
554 
555  if ( !pkgPtr || !slbPtr )
556  {
557  yuiError() << "No valid package available" << endl;
558  return false;
559  }
560 
561  // add the package name
562  pkgLine.push_back( slbPtr->name() );
563 
564  std::string instVersion = "";
565  std::string version = "";
566  ZyppStatus status;
567 
568  switch( tableType )
569  {
570  case T_PatchPkgs: {
571  // if the package is installed, get the installed version
572  if ( ! slbPtr->installedEmpty() )
573  {
574  instVersion = slbPtr->installedObj()->edition().asString();
575  }
576  // if a candidate is available, get the candidate version
577  if ( slbPtr->hasCandidateObj() )
578  {
579  version = slbPtr->candidateObj()->edition().asString();
580  }
581  else
582  {
583  version = pkgPtr->edition().asString();
584  }
585  pkgLine.push_back( version );
586 
587  // in case of YOU there are always installed packages
588  // => always add installed version (or empty column)
589  pkgLine.push_back( instVersion );
590 
591  pkgLine.push_back( pkgPtr->summary() ); // short description
592 
593  status = slbPtr->status(); // the package status
594  yuiMilestone() << "Status of " << slbPtr->name() << ": " << status << endl;
595  zypp::ByteCount size = pkgPtr->installSize(); // installed size
596  pkgLine.push_back( size.asString( 8 ) ); // format size
597 
598  break;
599  }
600  case T_Availables: {
601  std::string isCandidate = " ";
602  if ( pkgPtr == slbPtr->candidateObj() )
603  isCandidate = " x ";
604  pkgLine.push_back( isCandidate );
605 
606  version = pkgPtr->edition().asString();
607  pkgLine.push_back( version );
608  // show the name of the repository (the installation source)
609  pkgLine.push_back( pkgPtr->repository().info().name() );
610 
611  // set package status either to S_NoInst or S_KeepInstalled
612  status = S_NoInst;
613  zypp::ui::Selectable::installed_iterator it = slbPtr->installedBegin();
614 
615  while ( it != slbPtr->installedEnd() )
616  {
617  if ( pkgPtr->edition() == (*it)->edition() &&
618  pkgPtr->arch() == (*it)->arch() &&
619  pkgPtr->vendor() == (*it)->vendor() )
620  {
621  status = S_KeepInstalled;
622  }
623  ++it;
624  }
625 
626  zypp::ByteCount size = pkgPtr->installSize(); // installed size
627  pkgLine.push_back( size.asString( 8 ) ); // format size
628  pkgLine.push_back( pkgPtr->arch().asString()); // architecture
629 
630  break;
631  }
632  case T_MultiVersion: {
633  version = pkgPtr->edition().asString();
634  pkgLine.push_back( version );
635  // show the name of the repository (the installation source)
636  pkgLine.push_back( pkgPtr->repository().info().name() );
637 
638  zypp::PoolItem itemPtr( pkgPtr->satSolvable() );
639  status = slbPtr->pickStatus( itemPtr );
640  yuiMilestone() << "Multi version: status of " << version << ": " << status << endl;
641 
642  zypp::ByteCount size = pkgPtr->installSize(); // installed size
643  pkgLine.push_back( size.asString( 8 ) ); // format size
644  pkgLine.push_back( pkgPtr->arch().asString()); // architecture
645  break;
646  }
647  default: {
648  // if the package is installed, get the installed version
649  pkgLine.push_back( pkgPtr->summary() ); // short description
650  if ( ! slbPtr->installedEmpty() )
651  {
652  instVersion = slbPtr->installedObj()->edition().version();
653 
654  // if a candidate is available, get the candidate version
655  if ( slbPtr->hasCandidateObj() )
656  {
657  version = slbPtr->candidateObj()->edition().version();
658  }
659  }
660  else
661  {
662  version = pkgPtr->edition().version();
663  }
664  pkgLine.push_back( version ); // the available version (the candidate)
665 
666  if ( haveInstalledVersion )
667  {
668  pkgLine.push_back( instVersion ); // installed version
669  }
670 
671  status = slbPtr->status(); // the package status
672 
673  zypp::ByteCount size = pkgPtr->installSize(); // installed size
674  pkgLine.push_back( size.asString( 8 ) ); // format size
675 
676 // Selectable does not have source_install
677 #ifdef FIXME
678  if ( slbPtr->source_install() )
679  {
680  pkgLine.push_back( " x " );
681  }
682  else
683 #endif
684  {
685  pkgLine.push_back( " " );
686  }
687  }
688  }
689 
690  addLine( status, // the package status
691  pkgLine, // the package data
692  pkgPtr, // the corresponding package pointer
693  slbPtr
694  );
695 
696  return true;
697 }
698 
699 ///////////////////////////////////////////////////////////////////
700 //
701 // createInfoEntry
702 //
703 //
704 bool NCPkgTable::createInfoEntry ( std::string text )
705 {
706  std::vector<std::string> pkgLine;
707  pkgLine.reserve(2);
708 
709  pkgLine.push_back( text );
710  addLine( S_NoInst, // use status NoInst
711  pkgLine,
712  ZyppObj(),
713  ZyppSel()); // null pointer
714 
715  return true;
716 }
717 
718 ///////////////////////////////////////////////////////////////////
719 //
720 // createPatchEntry
721 //
722 //
723 bool NCPkgTable::createPatchEntry ( ZyppPatch patchPtr, ZyppSel slb )
724 {
725  std::vector<std::string> pkgLine;
726  pkgLine.reserve(5);
727 
728  if ( !patchPtr || !slb )
729  {
730  yuiError() << "No valid patch available" << endl;
731  return false;
732  }
733 
734  pkgLine.push_back( slb->name() ); // show the patch name
735 
736  if ( !patchPtr->summary().empty() )
737  pkgLine.push_back( patchPtr->summary() ); // short description
738  else
739  pkgLine.push_back( slb->name() ); // name
740 
741  pkgLine.push_back( patchPtr->category() ); // patch kind
742  pkgLine.push_back( patchPtr->edition().asString() ); // patch version
743 
744  // zypp::ByteCount size = patchPtr->size();
745  // pkgLine.push_back( size.asString( 8 ) );
746 
747 
748  addLine( slb->status(), // get the status
749  pkgLine,
750  patchPtr,
751  slb ); // the corresponding pointer
752 
753  return true;
754 }
755 
756 ///////////////////////////////////////////////////////////////////
757 //
758 // showInformation
759 //
760 //
762 {
763  ZyppObj objPtr = getDataPointer( getCurrentItem() );
764  ZyppSel slbPtr = getSelPointer( getCurrentItem() );
765 
766  if ( !packager )
767  return false;
768 
769  switch ( tableType )
770  {
771  case T_Packages:
772  case T_Update:
773  // show the required package info
774  if (objPtr && slbPtr)
775  {
776  updateInfo( objPtr, slbPtr, VisibleInfo() );
777  packager->PackageLabel()->setLabel( slbPtr->name() );
778  }
779  break;
780  case T_Patches:
781  // show the patch info
782  if (objPtr && slbPtr )
783  updateInfo( objPtr, slbPtr, VisibleInfo() );
784  break;
785  default:
786  break;
787  }
788 
789  return true;
790 }
791 
792 
793 ///////////////////////////////////////////////////////////////////
794 //
795 //
796 // METHOD NAME : NCPkgTable::wHandleInput
797 // METHOD TYPE : NCursesEvent
798 //
799 // DESCRIPTION :
800 //
801 NCursesEvent NCPkgTable::wHandleInput( wint_t key )
802 {
803  NCursesEvent ret = NCursesEvent::none;
804 
805  // call handleInput of NCPad
806  handleInput( key );
807 
808  if ( packager->isTestMode() )
809  {
810  if ( packager->diskSpacePopup() )
811  packager->diskSpacePopup()->setDiskSpace( key );
812  return ret;
813  }
814 
815  switch ( key )
816  {
817  case KEY_UP:
818  case KEY_DOWN:
819  case KEY_NPAGE:
820  case KEY_PPAGE:
821  case KEY_END:
822  case KEY_HOME: {
823  // show the corresponding information
824  showInformation( );
825  break;
826  }
827  case KEY_SPACE:
828  case KEY_RETURN: {
829  // toggle status
830  toggleObjStatus( );
831  break;
832  }
833  //from the parent class, to enable sorting
834  case CTRL('o'): {
835  NCTable::wHandleInput( key);
836  break;
837  }
838  case '-':
839  case '+':
840  case '>':
841  case '<':
842  case '!':
843  case '*': {
844  // set the new status
845  changeObjStatus( key );
846  }
847  default: {
848  break;
849  }
850  }
851 
852  NCDialog * currentDialog = static_cast<NCDialog *>(YDialog::topmostDialog());
853  if ( currentDialog )
854  currentDialog->setStatusLine();
855 
856  return NCursesEvent::handled;
857 }
858 
859 ///////////////////////////////////////////////////////////////////
860 //
861 // NCPkgTable::getStatus()
862 //
863 // Gets the status of the package of selected line
864 //
865 ZyppStatus NCPkgTable::getStatus( int index )
866 {
867  // get the tag
868  NCPkgTableTag * cc = getTag( index);
869  if ( !cc )
870  return S_NoInst;
871 
872  return cc->getStatus();
873 }
874 
875 ZyppObj NCPkgTable::getDataPointer( int index )
876 {
877  // get the tag
878  NCPkgTableTag *cc = getTag( index );
879  if ( !cc )
880  return ZyppObj( );
881 
882  return cc->getDataPointer();
883 }
884 
885 ZyppSel NCPkgTable::getSelPointer( int index )
886 {
887  // get the tag
888  NCPkgTableTag *cc = getTag( index );
889  if ( !cc )
890  return ZyppSel( );
891 
892  return cc->getSelPointer();
893 }
894 
895 NCPkgTableTag * NCPkgTable::getTag( const int & index )
896 {
897  // get the table line
898  NCTableLine * cl = myPad()->ModifyLine( index );
899  if ( !cl )
900  return 0;
901 
902  // get first column (the column containing the status info)
903  YTableItem *it = dynamic_cast<YTableItem*> (cl->origItem() );
904  YTableCell *tcell = it->cell(0);
905  NCPkgTableTag * cc = static_cast<NCPkgTableTag *>( tcell );
906 
907  return cc;
908 }
909 
910 #ifdef FIXME
911 ///////////////////////////////////////////////////////////////////
912 //
913 // NCPkgTable::SourceInstall()
914 //
915 //
916 bool NCPkgTable::SourceInstall( bool install )
917 {
918  int index = getCurrentItem();
919  ZyppObj objPtr = getDataPointer( index );
920  bool ok;
921 
922  if ( !objPtr )
923  {
924  yuiError() << "Invalid Pointer" << endl;
925  return false;
926  }
927  ZyppSel selPtr = objPtr->getSelectable();
928  NCTableLine * currentLine = myPad()->ModifyLine( index );
929 
930  if ( !selPtr || !currentLine )
931  {
932  yuiError() << "Invalid Selectable" << endl;
933  return false;
934  }
935 
936  NCTableCol * currentCol = currentLine->GetCol( currentLine->Cols()-1 );
937 
938  if ( install && selPtr->providesSources() )
939  {
940  ok = selPtr->set_source_install( true );
941  yuiMilestone() << "Set source install returns: " << (ok?"true":"false") << endl;
942  if ( currentCol )
943  currentCol->SetLabel( NClabel( " x " ) );
944  }
945  else if ( !install && selPtr->source_install() )
946  {
947  ok = selPtr->set_source_install( false );
948  yuiMilestone() << "ReSet source install returns: " << (ok?"true":"false") << endl;
949  if ( currentCol )
950  currentCol->SetLabel( NClabel( " " ) );
951  }
952 
953  return true;
954 }
955 #endif
956 
957 ///////////////////////////////////////////////////////////////////
958 //
959 // NCPkgTable::toggleObjStatus()
960 //
961 //
962 bool NCPkgTable::toggleObjStatus( )
963 {
964  ZyppSel slbPtr = getSelPointer( getCurrentItem() );
965  ZyppObj objPtr = getDataPointer( getCurrentItem() );
966 
967  if ( !slbPtr )
968  return false;
969 
970  ZyppStatus newStatus;
971 
972  bool ok = statusStrategy->toggleStatus( slbPtr, objPtr, newStatus );
973 
974  if ( ok )
975  {
976  changeStatus( newStatus, slbPtr, objPtr, true );
977  }
978 
979  return true;
980 }
981 
982 ///////////////////////////////////////////////////////////////////
983 //
984 // NCPkgTable::changeObjStatus()
985 //
986 //
987 bool NCPkgTable::changeObjStatus( int key )
988 {
989  ZyppSel slbPtr = getSelPointer( getCurrentItem() );
990  ZyppObj objPtr = getDataPointer( getCurrentItem() );
991 
992  if ( !slbPtr )
993  {
994  return false;
995  }
996  ZyppStatus newStatus;
997 
998  bool ok = statusStrategy->keyToStatus( key, slbPtr, objPtr, newStatus );
999 
1000  if ( ok )
1001  {
1002  changeStatus( newStatus, slbPtr, objPtr, true );
1003  }
1004  return true;
1005 }
1006 
1007 ///////////////////////////////////////////////////////////////////
1008 //
1009 // NCPkgTable::changeListObjStatus()
1010 //
1011 //
1012 bool NCPkgTable::changeListObjStatus( NCPkgTableListAction type )
1013 {
1014  ZyppStatus newStatus;
1015  unsigned int size = getNumLines();
1016  unsigned int index = 0;
1017 
1018  while ( index < size )
1019  {
1020  // get the object pointer
1021  ZyppSel slbPtr = getSelPointer( index );
1022  ZyppObj objPtr = getDataPointer( index );
1023  bool ok = false;
1024 
1025  if ( slbPtr )
1026  {
1027  switch ( type ) {
1028  case A_Install: {
1029  if ( slbPtr->status() == S_NoInst )
1030  ok = statusStrategy->keyToStatus( '+', slbPtr, objPtr, newStatus );
1031  break;
1032  }
1033  case A_Delete: {
1034  if ( slbPtr->installedObj() && slbPtr->status() != S_Protected )
1035  ok = statusStrategy->keyToStatus( '-', slbPtr, objPtr, newStatus );
1036  break;
1037  }
1038  case A_UpdateNewer: {
1039  // set status to update respecting "vendor change" settings
1040  if ( slbPtr->installedObj() && slbPtr->status() != S_Protected && slbPtr->updateCandidateObj() )
1041  {
1042  slbPtr->setOnSystem( slbPtr->updateCandidateObj() );
1043  ok = statusStrategy->keyToStatus( '>', slbPtr, objPtr, newStatus );
1044  }
1045  break;
1046  }
1047  case A_Update: {
1048  if ( slbPtr->installedObj() && slbPtr->status() != S_Protected )
1049  ok = statusStrategy->keyToStatus( '>', slbPtr, objPtr, newStatus );
1050  break;
1051  }
1052  case A_Keep: {
1053  if ( slbPtr->status() == S_Install
1054  || slbPtr->status() == S_AutoInstall
1055  || slbPtr->status() == S_Update
1056  || slbPtr->status() == S_AutoUpdate )
1057  ok = statusStrategy->keyToStatus( '<', slbPtr, objPtr, newStatus );
1058  else if ( slbPtr->status() == S_Del
1059  || slbPtr->status() == S_AutoDel )
1060  ok = statusStrategy->keyToStatus( '+', slbPtr, objPtr, newStatus );
1061  break;
1062  }
1063  default:
1064  yuiError() << "Unknown list action" << endl;
1065  }
1066 
1067  if ( ok )
1068  {
1069  changeStatus( newStatus,
1070  slbPtr,
1071  objPtr,
1072  false ); // do not do the updates with every change
1073  }
1074  }
1075 
1076  index++;
1077  }
1078 
1079  // do the updates now
1080  packager->showPackageDependencies( false );
1081  packager->showDiskSpace();
1082 
1083  updateTable();
1084 
1085  return true;
1086 }
1087 
1088 bool NCPkgTable::fillAvailableList ( ZyppSel slb )
1089 {
1090  if ( !slb )
1091  {
1092  yuiError() << "Package pointer not valid" << endl;
1093  return false;
1094  }
1095 
1096  // clear the package table
1097  itemsCleared ();
1098 
1099  NCPkgStatusStrategy * strategy;
1100  NCPkgTableType type;
1101 
1102  if ( slb->multiversionInstall() )
1103  {
1104  type = T_MultiVersion;
1105  strategy = new MultiVersionStatStrategy();
1106  yuiMilestone() << "Multi version package " << slb->name() << endl;
1107  }
1108  else
1109  {
1110  type = T_Availables;
1111  strategy = new AvailableStatStrategy();
1112  }
1113 
1114  setTableType( type, strategy );
1115  this->fillHeader();
1116 
1117  // pick list contains installed and available packages (valid for single and multi version)
1118  zypp::ui::Selectable::picklist_iterator it = slb->picklistBegin();
1119  while ( it != slb->picklistEnd() )
1120  {
1121  createListEntry( tryCastToZyppPkg(*it), slb );
1122  ++it;
1123  }
1124 
1125 #if 0
1126  // show installed packages
1127  {
1128  zypp::ui::Selectable::installed_iterator it = slb->installedBegin();
1129  while ( it != slb->installedEnd() )
1130  {
1131  createListEntry( tryCastToZyppPkg(*it), slb );
1132  ++it;
1133  }
1134  }
1135  // and all availables
1136  {
1137  zypp::ui::Selectable::available_iterator it = slb->availableBegin();
1138  while ( it != slb->availableEnd() )
1139  {
1140  createListEntry( tryCastToZyppPkg(*it), slb );
1141  ++it;
1142  }
1143  }
1144 #endif
1145 
1146  // show the package list
1147  drawList();
1148 
1149  if ( getNumLines() > 0 )
1150  {
1151  setCurrentItem( 0 );
1152  }
1153  return true;
1154 
1155 }
1156 
1157 bool NCPkgTable::fillSummaryList( NCPkgTable::NCPkgTableListType type )
1158 {
1159  // clear the package table
1160  itemsCleared ();
1161 
1162  // get the package list and sort it
1163  std::list<ZyppSel> pkgList( zyppPkgBegin (), zyppPkgEnd () );
1164  pkgList.sort( sortByName );
1165 
1166  // fill the package table
1167  std::list<ZyppSel>::iterator listIt;
1168  ZyppPkg pkgPtr;
1169 
1170  // If the dependency check is off, the dependencies will not be solved for
1171  // the installation summary.
1172  // This is not necessary because the dependencies will be solved and the
1173  // "Automatic Changes" list will be shown if the OK button is pressed.
1174  //if ( !autoCheck )
1175  //{
1176  // showPackageDependencies( true );
1177  //}
1178 
1179  for ( listIt = pkgList.begin(); listIt != pkgList.end(); ++listIt )
1180  {
1181  ZyppSel selectable = *listIt;
1182  ZyppPkg pkg = tryCastToZyppPkg (selectable->theObj ());
1183  // show all matching packages
1184  switch ( type )
1185  {
1186  case NCPkgTable::L_Changes: {
1187  if ( selectable->status() != S_NoInst
1188  && selectable->status() != S_KeepInstalled )
1189  {
1190  createListEntry( pkg, selectable );
1191  }
1192  break;
1193  }
1194  case NCPkgTable::L_Installed: {
1195  if ( selectable->status() == S_KeepInstalled )
1196  {
1197  createListEntry( pkg, selectable );
1198  }
1199  break;
1200  }
1201  default:
1202  break;
1203  }
1204  }
1205 
1206  // show the package list
1207  drawList();
1208 
1209  return true;
1210 }
1211 
1212 void NCPkgTable::updateInfo( ZyppObj pkgPtr, ZyppSel slbPtr, NCPkgTableInfoType mode )
1213 {
1214  switch (mode)
1215  {
1216  case I_Descr:
1217  if ( packager->InfoText() )
1218  packager->InfoText()->longDescription( pkgPtr );
1219  break;
1220  case I_Technical:
1221  if ( packager->InfoText() )
1222  packager->InfoText()->technicalData( pkgPtr, slbPtr );
1223  break;
1224  case I_Files:
1225  if ( packager->InfoText() )
1226  packager->InfoText()->fileList( slbPtr );
1227  break;
1228  case I_Deps:
1229  if ( packager->InfoText() )
1230  packager->InfoText()->dependencyList( pkgPtr, slbPtr );
1231  break;
1232  case I_Versions:
1233  if ( packager->VersionsList() )
1234  packager->VersionsList()->fillAvailableList( slbPtr );
1235  break;
1236  case I_PatchDescr:
1237  if ( packager->InfoText() )
1238  packager->InfoText()->patchDescription( pkgPtr, slbPtr );
1239  break;
1240  case I_PatchPkgs:
1241  if ( packager->PatchPkgs() )
1242  packager->fillPatchPackages( packager->PatchPkgs(), pkgPtr );
1243  break;
1244  case I_PatchPkgsVersions:
1245  if ( packager->PatchPkgsVersions() )
1246  packager->fillPatchPackages( packager->PatchPkgsVersions(), pkgPtr, true );
1247  break;
1248  // Intentionally omitting 'default' branch so the compiler can
1249  // catch unhandled enum states
1250  }
1251 }