libyui-ncurses-pkg  2.48.5.2
NCPkgStatusStrategy.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: NCPkgStatusStrategy.cc
37 
38  Author: Gabriele Strattner <gs@suse.de>
39 
40 /-*/
41 #define YUILogComponent "ncurses-pkg"
42 #include <YUILog.h>
43 
44 #include "NCPkgStatusStrategy.h"
45 #include "NCTable.h"
46 #include "NCZypp.h"
47 #include "NCPopupInfo.h"
48 #include "NCPkgStrings.h"
49 
50 #include <zypp/ui/Selectable.h>
51 #include <zypp/base/LogTools.h>
52 #include <zypp/ResObject.h>
53 
54 using std::endl;
55 
56 //------------------------------------------------------------
57 // Base class for strategies to handle status
58 //------------------------------------------------------------
59 
60 //
61 // Constructor
62 //
63 NCPkgStatusStrategy::NCPkgStatusStrategy()
64 {
65 }
66 
67 //
68 // Destructor - must be defined here (because it is pure virtual)
69 //
70 NCPkgStatusStrategy::~NCPkgStatusStrategy()
71 {
72 }
73 
74 ///////////////////////////////////////////////////////////////////
75 //
76 // NCPkgStatusStrategy::getPackageStatus()
77 //
78 // Gets status from package manager
79 //
80 ZyppStatus NCPkgStatusStrategy::getPackageStatus( ZyppSel slbPtr,
81  ZyppObj objPtr )
82 {
83  if ( slbPtr )
84  {
85  return slbPtr->status();
86  }
87  else
88  {
89  yuiError() << "Selectable pointer not valid" << endl;
90  return S_NoInst;
91  }
92 }
93 
94 /////////////////////////////////////////////////////////////////
95 //
96 // NCPkgStatusStrategy::setObjectStatus()
97 //
98 // Informs the package manager about the status change
99 //
100 bool NCPkgStatusStrategy::setObjectStatus( ZyppStatus newstatus, ZyppSel slbPtr, ZyppObj objPtr )
101 {
102  bool ok = false;
103 
104  if ( !slbPtr )
105  {
106  yuiError() << "Invalid package object" << endl;
107  return false;
108  }
109 
110  ok = slbPtr->setStatus( newstatus );
111 
112  yuiMilestone() << "Set status of: " << slbPtr->name() << " to: "
113  << newstatus << " returns: " << (ok?"true":"false") << endl;
114 
115  return ok;
116 }
117 
118 ///////////////////////////////////////////////////////////////////
119 //
120 // NCPkgStatusStrategy::keyToStatus()
121 //
122 // Returns the corresponding status
123 //
124 bool NCPkgStatusStrategy::keyToStatus( const int & key,
125  ZyppSel slbPtr,
126  ZyppObj objPtr,
127  ZyppStatus & newStat )
128 {
129  if ( !slbPtr )
130  return false;
131 
132  bool valid = true;
133  ZyppStatus retStat = S_NoInst;
134  ZyppStatus oldStatus = getPackageStatus( slbPtr, objPtr );
135  bool installed = !slbPtr->installedEmpty();
136 
137  // get the new status
138  switch ( key )
139  {
140  case '-':
141  if ( installed ) // installed package -> always set status to delete
142  {
143  // if required, NCPkgTable::changeStatus() shows the delete notify
144  retStat = S_Del;
145  }
146  else
147  {
148  retStat = S_NoInst;
149  }
150  break;
151  case '+':
152  if ( oldStatus == S_NoInst
153  || oldStatus == S_AutoInstall )
154  {
155  // if required, NCPkgTable::changeStatus() shows the notify message
156  retStat = S_Install;
157  }
158  else if ( oldStatus == S_Del
159  || oldStatus == S_AutoDel)
160  {
161  retStat = S_KeepInstalled;
162  }
163  else if ( oldStatus == S_AutoUpdate )
164  {
165  retStat = S_Update;
166  }
167  else
168  {
169  valid = false;
170  }
171  break;
172  case '>':
173  if ( oldStatus == S_KeepInstalled
174  || oldStatus == S_Del
175  || oldStatus == S_AutoDel )
176  {
177  if ( slbPtr->hasCandidateObj() )
178  {
179  retStat = S_Update;
180  }
181  }
182  else
183  {
184  valid = false;
185  }
186  break;
187  //this is the case for 'going back' i.e. S_Install -> S_NoInst, S_Update -> S_KeepInstalled
188  //not for S_Del, since '+' key does this
189  case '<':
190  if ( oldStatus == S_Install
191  || oldStatus == S_AutoInstall )
192  {
193  retStat = S_NoInst;
194  }
195  else if ( oldStatus == S_Update
196  || oldStatus == S_AutoUpdate )
197  {
198  retStat = S_KeepInstalled;
199  }
200  break;
201  case '!': // set S_Taboo
202  if ( !installed )
203  {
204  retStat = S_Taboo;
205  }
206  break;
207  case '*': // set S_Protected
208  if ( installed )
209  {
210  retStat = S_Protected;
211  }
212  break;
213  default:
214  yuiDebug() << "Key not valid" << endl;
215  valid = false;
216  }
217 
218  if ( valid )
219  newStat = retStat;
220 
221  return valid;
222 }
223 
224 
225 ///////////////////////////////////////////////////////////////////
226 //
227 // NCPkgStatusStrategy::toggleStatus()
228 //
229 // Returns the new status
230 //
232  ZyppObj objPtr,
233  ZyppStatus & newStat )
234 {
235  if ( !slbPtr )
236  return false;
237 
238  bool ok = true;
239 
240  ZyppStatus oldStatus = getPackageStatus( slbPtr, objPtr );
241  ZyppStatus newStatus = oldStatus;
242  ZyppPattern patPtr = tryCastToZyppPattern (objPtr);
243 
244  switch ( oldStatus )
245  {
246  case S_Del:
247  newStatus = S_KeepInstalled;
248  break;
249  case S_Install:
250  newStatus =S_NoInst ;
251  break;
252  case S_Update:
253  newStatus = S_Del;
254  break;
255  case S_KeepInstalled:
256  if ( patPtr )
257  newStatus = S_Install;
258 
259  else if ( slbPtr->hasCandidateObj() )
260  {
261  newStatus = S_Update;
262  }
263  else
264  {
265  newStatus = S_Del;
266  }
267  break;
268  case S_NoInst:
269  if ( slbPtr->hasCandidateObj() || patPtr )
270  {
271  newStatus = S_Install;
272  }
273  else
274  {
275  yuiWarning() << "No candidate object for " << slbPtr->theObj()->name().c_str() << endl;
276  newStatus = S_NoInst;
277  }
278  break;
279  case S_AutoInstall:
280  // this used to be taboo before, but now ZYpp supports
281  // saving weak locks (unselected packages)
282  newStatus = S_NoInst;
283  break;
284  case S_AutoDel:
285  newStatus = S_KeepInstalled;
286  break;
287  case S_AutoUpdate:
288  newStatus = S_KeepInstalled;
289  break;
290  case S_Taboo:
291  newStatus = S_NoInst;
292  break;
293  case S_Protected:
294  newStatus = S_KeepInstalled;
295  break;
296  }
297 
298  yuiMilestone() << "Status toogled: old " << oldStatus << ", new " << newStatus << endl;
299  newStat = newStatus;
300 
301  return ok;
302 }
303 
304 ///////////////////////////////////////////////////////////////////
305 //
306 // NCPkgStatusStrategy::solveResolvableCollections()
307 //
308 // Do a "small" solver run
309 //
311 {
312  zypp::Resolver_Ptr resolver = zypp::getZYpp()->resolver();
313  resolver->resolvePool();
314 }
315 
316 
317 
318 //------------------------------------------------------------
319 // Class for strategies to get status for packages
320 //------------------------------------------------------------
321 
322 //
323 // Constructor
324 //
325 PackageStatStrategy::PackageStatStrategy()
327 {
328 }
329 
330 
331 
332 
333 //------------------------------------------------------------
334 // Class for strategies to get status for patches
335 //------------------------------------------------------------
336 
337 //
338 // Constructor
339 //
340 PatchStatStrategy::PatchStatStrategy()
342 {
343 }
344 
345 
346 ///////////////////////////////////////////////////////////////////
347 //
348 // PatchStatStrategy::keyToStatus()
349 //
350 // Returns the corresponding status
351 //
352 bool PatchStatStrategy::keyToStatus( const int & key,
353  ZyppSel slbPtr,
354  ZyppObj objPtr,
355  ZyppStatus & newStat )
356 {
357  if ( !slbPtr || !slbPtr->hasCandidateObj() )
358  return false;
359 
360  bool valid = true;
361  ZyppStatus retStat = S_NoInst;
362  ZyppStatus oldStatus = getPackageStatus( slbPtr, objPtr );
363  bool toBeInst = slbPtr->candidateObj().status().isToBeInstalled();
364  bool isRelevant = slbPtr->candidateObj().isRelevant();
365  bool isBroken = slbPtr->candidateObj().isBroken();
366 
367  yuiMilestone() << slbPtr->name() << ": " << (toBeInst?"to be installed":"not to be installed,")
368  << " old status: " << oldStatus << endl;
369 
370  // get the new status
371  switch ( key )
372  {
373  case '-':
374  // To be installed includes S_Install and S_AutoInstall
375  if ( toBeInst )
376  {
377  retStat = S_NoInst;
378  }
379  else if ( oldStatus == S_Taboo )
380  {
381  if ( isBroken )
382  {
383  retStat = S_Install;
384  }
385  else
386  {
387  retStat = S_NoInst;
388  }
389  }
390  else // patches cannot be deleted
391  {
392  valid = false;
393  }
394  break;
395  case '+':
396  // only relevant patches can be installed
397  if ( isRelevant &&
398  ( oldStatus == S_NoInst ||
399  oldStatus == S_AutoInstall ||
400  oldStatus == S_KeepInstalled ) )
401  {
402  retStat = S_Install;
403  }
404  else
405  {
406  valid = false;
407  }
408  break;
409  case '!':
410  {
411  // For patches there isn't an installed object available (patches are not installed,
412  // they can be satisfied because required version/s of the patch package/s is/are
413  // installed). Therefore they only can be set to S_Taboo (not to S_Protected).
414  retStat = S_Taboo;
415  }
416  break;
417  default:
418  yuiDebug() << "Key not valid" << endl;
419  valid = false;
420  }
421 
422  if ( valid )
423  {
424  newStat = retStat;
425  }
426  yuiMilestone() << "New status: " << newStat << endl;
427 
428  return valid;
429 }
430 
431 ///////////////////////////////////////////////////////////////////
432 //
433 // PatchStatStrategy::toggleStatus()
434 //
435 // Returns the new status
436 //
437 bool PatchStatStrategy::toggleStatus( ZyppSel slbPtr,
438  ZyppObj objPtr,
439  ZyppStatus & newStat )
440 {
441  if ( !slbPtr || !slbPtr->hasCandidateObj() )
442  return false;
443 
444  bool ok = true;
445 
446  ZyppStatus oldStatus = getPackageStatus( slbPtr, objPtr );
447  bool isBroken = slbPtr->candidateObj().isBroken();
448  ZyppStatus newStatus = oldStatus;
449 
450  switch ( oldStatus )
451  {
452  case S_Install:
453  case S_AutoInstall:
454  newStatus = S_NoInst ;
455  break;
456  case S_KeepInstalled:
457  newStatus = S_Install;
458  break;
459  case S_NoInst:
460  newStatus = S_Install ;
461  break;
462  case S_Taboo:
463  if ( isBroken )
464  {
465  newStatus = S_Install;
466  }
467  else
468  {
469  newStatus = S_NoInst;
470  }
471  break;
472  default:
473  newStatus = oldStatus;
474  }
475  yuiMilestone() << "Status toogled: old " << oldStatus << ", new " << newStatus << endl;
476 
477  newStat = newStatus;
478 
479  return ok;
480 }
481 
482 
483 /////////////////////////////////////////////////////////////////
484 //
485 // PatchStatStrategy::setObjectStatus()
486 //
487 // Inform the package manager about the status change
488 // of the patch
489 //
490 bool PatchStatStrategy::setObjectStatus( ZyppStatus newstatus, ZyppSel slbPtr, ZyppObj objPtr )
491 {
492  bool ok = false;
493 
494  if ( !slbPtr )
495  {
496  yuiError() << "Invalid patch object" << endl;
497  return false;
498  }
499 
500  ok = slbPtr->setStatus( newstatus );
501  yuiMilestone() << "Set status of: " << slbPtr->name() << " to: "
502  << newstatus << " returns: " << (ok?"true":"false") << endl;
503 
504  // do a solver run
506 
507  return ok;
508 }
509 
510 //------------------------------------------------------------
511 // Class for strategies for selections
512 //------------------------------------------------------------
513 
514 //
515 // Constructor
516 //
517 SelectionStatStrategy::SelectionStatStrategy()
519 {
520 }
521 
522 /////////////////////////////////////////////////////////////////
523 //
524 // SelectionStatStrategy::setObjectStatus()
525 //
526 // Inform the package manager about the status change
527 // of the selection
528 //
529 bool SelectionStatStrategy::setObjectStatus( ZyppStatus newstatus, ZyppSel slbPtr, ZyppObj objPtr )
530 {
531  bool ok = false;
532 
533  if ( !slbPtr || !objPtr )
534  {
535  yuiError() << "Invalid selection" << endl;
536  return false;
537  }
538 
539  ok = slbPtr->setStatus( newstatus );
540  yuiMilestone() << "Set status of: " << slbPtr->name() << " to: "
541  << newstatus << " returns: " << (ok?"true":"false") << endl;
542 
543  // do a solver run -> solver runs in NCPkgTable::changeStatus()
544  // solveResolvableCollections();
545 
546  return ok;
547 }
548 
549 //------------------------------------------------------------
550 // Class for strategies for depndencies
551 //------------------------------------------------------------
552 
553 //
554 // Constructor
555 //
556 DependencyStatStrategy::DependencyStatStrategy()
558 {
559 }
560 
561 //------------------------------------------------------------
562 // Class for strategies to get status for available packages
563 //------------------------------------------------------------
564 
565 //
566 // Constructor
567 //
568 AvailableStatStrategy::AvailableStatStrategy()
570 {
571 }
572 
573 ///////////////////////////////////////////////////////////////////
574 //
575 // AvailableStatStrategy::setObjectStatus
576 //
577 // Informs the package manager about the new status (sets the candidate)
578 //
579 bool AvailableStatStrategy::setObjectStatus( ZyppStatus newstatus,
580  ZyppSel slbPtr, ZyppObj objPtr )
581 {
582  bool ok = false;
583 
584  if ( !slbPtr || !objPtr )
585  {
586  return false;
587  }
588 
589  ZyppObj newCandidate = objPtr;
590 
591  if ( newCandidate != slbPtr->candidateObj() )
592  {
593  yuiMilestone() << "CANDIDATE changed" << endl;
594 
595  // Change status of selectable
596  ZyppStatus status = slbPtr->status();
597 
598  if ( slbPtr->installedObj() &&
599  slbPtr->installedObj()->edition() == newCandidate->edition() &&
600  slbPtr->installedObj()->vendor() == newCandidate->vendor()
601  )
602  {
603  yuiMilestone() << "Identical package installed" << endl;
604  // Switch back to the original instance -
605  // the version that was previously installed
606  status = S_KeepInstalled;
607  }
608  else
609  {
610  switch ( status )
611  {
612  case S_KeepInstalled:
613  case S_Protected:
614  case S_AutoDel:
615  case S_AutoUpdate:
616  case S_Del:
617  case S_Update:
618 
619  status = S_Update;
620  break;
621 
622  case S_NoInst:
623  case S_Taboo:
624  case S_Install:
625  case S_AutoInstall:
626  status = S_Install;
627  break;
628  }
629  }
630 
631  // Set candidate
632  ok = bool( slbPtr->setCandidate( newCandidate ) );
633  yuiMilestone() << "Set user candidate returns: " << (ok?"true":"false") << endl;
634  if ( ok )
635  {
636  // Set status
637  ok = slbPtr->setStatus( status );
638  yuiMilestone() << "Set status of: " << slbPtr->name() << " to: "
639  << status << " returns: " << (ok?"true":"false") << endl;
640  }
641  }
642 
643  return ok;
644 }
645 
646 
647 //------------------------------------------------------------
648 // Class for strategies to get status for multi version packages
649 //------------------------------------------------------------
650 
651 //
652 // Constructor
653 //
654 MultiVersionStatStrategy::MultiVersionStatStrategy()
656 {
657 }
658 
659 ///////////////////////////////////////////////////////////////////
660 //
661 // MultiVersionStatStrategy::getPackageStatus()
662 //
663 // Gets status from package manager
664 //
666  ZyppObj objPtr )
667 {
668  if ( !slbPtr || !objPtr )
669  {
670  yuiError() << "Selectable pointer not valid" << endl;
671  return S_NoInst;
672  }
673 
674  zypp::PoolItem itemPtr ( objPtr->satSolvable() );
675  return slbPtr->pickStatus( itemPtr );
676 }
677 
678 ///////////////////////////////////////////////////////////////////
679 //
680 // MultiVersionStatStrategy::setObjectStatus
681 //
682 // Checking for multiversion and not-multiversion conflicts and
683 // informs the package manager about the new status.
684 //
685 bool MultiVersionStatStrategy::setObjectStatus( ZyppStatus newstatus,
686  ZyppSel slbPtr, ZyppObj objPtr )
687 {
688  bool ok = false;
689 
690  if ( !slbPtr || !objPtr )
691  {
692  return false;
693  }
694  zypp::PoolItem itemPtr ( objPtr->satSolvable() );
695 
696  bool multiVersion = itemPtr->multiversionInstall();
697  yuiMilestone() << "Selected: "
698  << ( multiVersion ? "Multiversion " : "Non-Multiversion " )
699  << itemPtr;
700 
701  if ( anyMultiVersionToInstall( slbPtr, !multiVersion ) )
702  {
703  yuiMilestone() << "Multiversion and non-multiversion conflict!" << endl;
704 
705  if ( mixedMultiVersionPopup( multiVersion ) )
706  {
707  ok = slbPtr->setPickStatus( itemPtr, newstatus );
708  yuiMilestone() << "Set new status of: "<< slbPtr->name() << ", " << objPtr->edition()
709  << " to: " << newstatus << " returns: " << (ok?"true":"false") << endl;
710  }
711  else
712  {
713  yuiMilestone() << "Selection canceled by the user.";
714  }
715  }
716  else
717  {
718  ok = slbPtr->setPickStatus( itemPtr, newstatus );
719  yuiMilestone() << "Set new status of: "<< slbPtr->name() << ", " << objPtr->edition()
720  << " to: " << newstatus << " returns: " << (ok?"true":"false") << endl;
721  }
722 
723  return ok;
724 }
725 
726 ///////////////////////////////////////////////////////////////////
727 //
728 // MultiVersionStatStrategy::anyMultiVersionToInstall
729 //
730 // Check if any package version is marked for installation where its
731 // 'multiversion' flag is set to 'multiversion'.
732 //
733 bool MultiVersionStatStrategy::anyMultiVersionToInstall( ZyppSel slbPtr, bool multiversion ) const
734 {
735  if ( ! slbPtr )
736  return false;
737 
738  zypp::ui::Selectable::available_iterator it = slbPtr->availableBegin();
739 
740  while ( it != slbPtr->availableEnd() )
741  {
742  if ( it->multiversionInstall() == multiversion )
743  {
744  switch ( slbPtr->pickStatus( *it ) )
745  {
746  case S_Install:
747  case S_AutoInstall:
748  yuiMilestone() << "Found " << ( multiversion ? "multiversion" : "non-multiversion" )
749  << " to install" << endl;
750  return true;
751  case S_KeepInstalled:
752  yuiMilestone() << "Found " << ( multiversion ? "multiversion" : "non-multiversion" )
753  << " wich is already installed" << endl;
754  return true;
755  default:
756  break;
757  }
758  }
759 
760  ++it;
761  }
762 
763  yuiMilestone() << "No " << ( multiversion ? "multiversion" : "non-multiversion" )
764  << " to install" << endl;
765  return false;
766 }
767 
768 ///////////////////////////////////////////////////////////////////
769 //
770 // MultiVersionStatStrategy::mixedMultiVersionPopup
771 //
772 // Ask user if he really wants to install incompatible package versions.
773 // Return 'true' if he hits [Continue], 'false' if [Cancel].
774 //
776 {
777  std::string msg = NCPkgStrings::MultiversionIntro();
778 
779  if ( multiversion )
780  {
781  msg += NCPkgStrings::MultiversionText();
782  }
783  else
784  {
785  msg += NCPkgStrings::NotMultiversionText();
786  }
787 
788  NCPopupInfo * cancelMsg = new NCPopupInfo( wpos( (NCurses::lines()-22)/2, (NCurses::cols()-45)/2 ),
790  msg,
793  );
794  cancelMsg->setPreferredSize( 60, 15 );
795  cancelMsg->focusCancelButton();
796  NCursesEvent input = cancelMsg->showInfoPopup( );
797 
798  YDialog::deleteTopmostDialog();
799 
800  return !(input == NCursesEvent::cancel);
801 }
802 
803 
804 
805 
806 //------------------------------------------------------------
807 // Class for strategies to get status for update packages
808 //------------------------------------------------------------
809 
810 //
811 // Constructor
812 //
813 UpdateStatStrategy::UpdateStatStrategy()
815 {
816 }
817 
818 
819 //------------------------------------------------------------
820 // Class for strategies to get status for patch packages
821 //------------------------------------------------------------
822 
823 //
824 // Constructor
825 //
826 PatchPkgStatStrategy::PatchPkgStatStrategy()
828 {
829 }
830 
831 bool PatchPkgStatStrategy::setObjectStatus( ZyppStatus newstatus,
832  ZyppSel slbPtr, ZyppObj objPtr )
833 {
834  // it is not possible to set the status of the packages belonging to a certain patch
835  return false;
836 }
virtual bool keyToStatus(const int &key, ZyppSel slbPtr, ZyppObj objPtr, ZyppStatus &newStat)
Returns the new status to the given key (respecting the old status of th eobject).
virtual bool anyMultiVersionToInstall(ZyppSel slbPtr, bool multiversion) const
Check if any package version is marked for installation where its &#39;multiversion&#39; flag is set to &#39;mult...
virtual bool toggleStatus(ZyppSel slbPtr, ZyppObj objPtr, ZyppStatus &newStat)
Toggles the package status (e.g.
virtual bool toggleStatus(ZyppSel slbPtr, ZyppObj objPtr, ZyppStatus &newStat)
Toggles the patch status (e.g.
virtual bool keyToStatus(const int &key, ZyppSel slbPtr, ZyppObj objPtr, ZyppStatus &newStat)
Returns the new status to the given key (respecting the old status of the patch). ...
virtual bool setObjectStatus(ZyppStatus newstatus, ZyppSel slbPtr, ZyppObj objPtr)
Informs the package manager about the new status.
virtual ZyppStatus getPackageStatus(ZyppSel slbPtr, ZyppObj objPtr)
Gets the status information from the package manager.
virtual bool setObjectStatus(ZyppStatus newstatus, ZyppSel slbPtr, ZyppObj objPtr)
It is not possible to std::set the package status for packages belonging to a patch, i.e.
virtual bool setObjectStatus(ZyppStatus newstatus, ZyppSel slbPtr, ZyppObj objPtr)
Informs the package manager about the new status and additionally sets the candidate object to the us...
virtual bool setObjectStatus(ZyppStatus newstatus, ZyppSel slbPtr, ZyppObj objPtr)
Sets the status of the patch AND the status of the patch packages.
static const std::string MultiversionHead()
Info about multiversion packages.
virtual bool setObjectStatus(ZyppStatus newstatus, ZyppSel slbPtr, ZyppObj objPtr)
Sets the status of the selection.
virtual ZyppStatus getPackageStatus(ZyppSel slbPtr, ZyppObj objPtr)
Gets the status information from the package manager.
virtual bool mixedMultiVersionPopup(bool multiversion) const
Ask user if he really wants to install incompatible package versions.
virtual bool setObjectStatus(ZyppStatus newstatus, ZyppSel slbPtr, ZyppObj objPtr)
Informs the package manager about the new status and additionally sets the candidate object to the us...
static const std::string ContinueLabel()
The label of the Continue button.
static const std::string CancelLabel()
The label of the Cancel button.
void solveResolvableCollections()
Do a "small" solver run for all "resolvable collections", i.e., for selections, patterns, languages, patches.