ygtkpkgmenubar.cc

/********************************************************************
 *           YaST2-GTK - http://en.opensuse.org/YaST2-GTK           *
 ********************************************************************/
/* YGtkPkgMenuBar, menu bar */
// check the header file for information about this widget

/*
  Textdomain "gtk-pkg"
 */

#include "YGi18n.h"
#include "config.h"
#include "YGDialog.h"
#include "YGUtils.h"
#include "ygtkpkgmenubar.h"
#include <gtk/gtk.h>
#include <glib/gstdio.h>
#include <stdio.h>
#include <gdk/gdkkeysyms.h>
#include "yzyppwrapper.h"
#include "YGPackageSelector.h"

// flags handling

#define YAST_GTK_SYSCONFIG "/etc/sysconfig/yast2-gtk"

struct Flags {
	Flags() {
		keys = g_key_file_new();
		g_key_file_load_from_file (keys, YAST_GTK_SYSCONFIG, G_KEY_FILE_NONE, NULL);
		modified = false;
	}

	~Flags() {
		if (modified)
			writeFile();
		g_key_file_free (keys);
	}

	bool hasKey (const char *variable) {
		return g_key_file_has_key (keys, "zypp", variable, NULL);
	}

	bool getBool (const char *variable) {
		return g_key_file_get_boolean (keys, "zypp", variable, NULL);
	}

	void setBool (const char *variable, bool value) {
		g_key_file_set_boolean (keys, "zypp", variable, value);
		modified = true;
	}

	private:
		void writeFile() {
			FILE *out = fopen (YAST_GTK_SYSCONFIG, "w"); 
			if (out) {
				gsize size;
				gchar *data = g_key_file_to_data (keys, &size, NULL);
				fwrite (data, sizeof (char), size, out);
				g_free (data);
				fclose (out);
			}
		}

		GKeyFile *keys;
		bool modified;
};

// utilities

static GtkWidget *append_menu_item (GtkWidget *menu, const char *_text,
	const char *stock, GCallback callback, gpointer callback_data)
{
	std::string text;
	if (_text)
		text = YGUtils::mapKBAccel (_text);
	GtkWidget *item;
	if (stock && _text) {
		GtkWidget *icon = gtk_image_new_from_stock (stock, GTK_ICON_SIZE_MENU);
		item = gtk_image_menu_item_new_with_mnemonic (text.c_str());
		gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), icon);
	}
	else if (_text)
		item = gtk_menu_item_new_with_mnemonic (text.c_str());
	else if (stock)
		item = gtk_image_menu_item_new_from_stock (stock, NULL);
	else
		item = gtk_separator_menu_item_new();
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	if (callback)
		g_signal_connect (G_OBJECT (item), "activate", callback, callback_data);
	return item;
}

static void errorMsg (const std::string &message)
{
	GtkWidget *dialog = gtk_message_dialog_new (YGDialog::currentWindow(),
		GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
		_("Error"));
	gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog),
		"%s", message.c_str());
	gtk_dialog_run (GTK_DIALOG (dialog));
	gtk_widget_destroy (dialog);
}

// callback implementations
// code from yast2-qt

#include <zypp/SysContent.h>
#include <zypp/ui/Status.h>
#include <zypp/ui/Selectable.h>
#include <zypp/ResPoolProxy.h>
#include <zypp/ZYppFactory.h>
#include <fstream>

using zypp::ui::S_Protected;
using zypp::ui::S_Taboo;
using zypp::ui::S_Del;
using zypp::ui::S_Update;
using zypp::ui::S_Install;
using zypp::ui::S_AutoDel;
using zypp::ui::S_AutoUpdate;
using zypp::ui::S_AutoInstall;
using zypp::ui::S_KeepInstalled;
using zypp::ui::S_NoInst;
typedef zypp::ui::Selectable::Ptr		ZyppSel;
typedef zypp::ui::Status			ZyppStatus;
typedef zypp::ResPoolProxy::const_iterator	ZyppPoolIterator;
typedef zypp::ResPoolProxy			ZyppPool;
//inline ZyppPool		zyppPool()		{ return zypp::getZYpp()->poolProxy();	}
template<class T> ZyppPoolIterator zyppBegin()	{ return zyppPool().byKindBegin<T>();	}
template<class T> ZyppPoolIterator zyppEnd()	{ return zyppPool().byKindEnd<T>();	}
inline ZyppPoolIterator zyppPkgBegin()		{ return zyppBegin<zypp::Package>();	}
inline ZyppPoolIterator zyppPkgEnd()		{ return zyppEnd<zypp::Package>();	}
inline ZyppPoolIterator zyppPatternsBegin()	{ return zyppBegin<zypp::Pattern>();	}
inline ZyppPoolIterator zyppPatternsEnd()	{ return zyppEnd<zypp::Pattern>();	}

#define DEFAULT_EXPORT_FILE_NAME "user-packages.xml"

static void
importSelectable( ZyppSel		selectable,
				     bool		isWanted,
				     const char * 	kind )
{
    ZyppStatus oldStatus = selectable->status();
    ZyppStatus newStatus = oldStatus;

    if ( isWanted )
    {
	//
	// Make sure this selectable does not get installed
	//

	switch ( oldStatus )
	{
	    case S_Install:
	    case S_AutoInstall:
	    case S_KeepInstalled:
	    case S_Protected:
	    case S_Update:
	    case S_AutoUpdate:
		newStatus = oldStatus;
		break;

	    case S_Del:
	    case S_AutoDel:
		newStatus = S_KeepInstalled;
		yuiDebug() << "Keeping " << kind << " " << selectable->name() << std::endl;
		break;

	    case S_NoInst:
	    case S_Taboo:

		if ( selectable->hasCandidateObj() )
		{
		    newStatus = S_Install;
		    yuiDebug() << "Adding " << kind << " " <<  selectable->name() << std::endl;
		}
		else
		{
		    yuiDebug() << "Can't add " << kind << " " << selectable->name()
			       << ": No candidate" << std::endl;
		}
		break;
	}
    }
    else // ! isWanted
    {
	//
	// Make sure this selectable does not get installed
	//

	switch ( oldStatus )
	{
	    case S_Install:
	    case S_AutoInstall:
	    case S_KeepInstalled:
	    case S_Protected:
	    case S_Update:
	    case S_AutoUpdate:
		newStatus = S_Del;
		yuiDebug() << "Deleting " << kind << " " << selectable->name() << std::endl;
		break;

	    case S_Del:
	    case S_AutoDel:
	    case S_NoInst:
	    case S_Taboo:
		newStatus = oldStatus;
		break;
	}
    }

    if ( oldStatus != newStatus )
	selectable->setStatus( newStatus );
}

static void import_file_cb (GtkMenuItem *item)
{
	GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Import from"),
		YGDialog::currentWindow(), GTK_FILE_CHOOSER_ACTION_OPEN,
		GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
		GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);

	GtkFileFilter *filter = gtk_file_filter_new();
	gtk_file_filter_set_name (filter, "*.xml");
	gtk_file_filter_add_pattern (filter, "*.xml");
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name (filter, "*");
	gtk_file_filter_add_pattern (filter, "*");
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);

	gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), DEFAULT_EXPORT_FILE_NAME);
	gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), TRUE);

	int ret = gtk_dialog_run (GTK_DIALOG (dialog));
    if ( ret == GTK_RESPONSE_ACCEPT )
    {
	char *filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
	yuiMilestone() << "Importing package list from " << filename << std::endl;

	try
	{
	    std::ifstream importFile( filename );
	    zypp::syscontent::Reader reader( importFile );

	    //
	    // Put reader contents into maps
	    //

	    typedef zypp::syscontent::Reader::Entry	ZyppReaderEntry;
	    typedef std::pair<std::string, ZyppReaderEntry>	ImportMapPair;

	    std::map<std::string, ZyppReaderEntry> importPkg;
	    std::map<std::string, ZyppReaderEntry> importPatterns;

	    for ( zypp::syscontent::Reader::const_iterator it = reader.begin();
		  it != reader.end();
		  ++ it )
	    {
		std::string kind = it->kind();

		if      ( kind == "package" ) 	importPkg.insert     ( ImportMapPair( it->name(), *it ) );
		else if ( kind == "pattern" )	importPatterns.insert( ImportMapPair( it->name(), *it ) );
	    }

	    yuiDebug() << "Found "        << importPkg.size()
		       <<" packages and " << importPatterns.size()
		       << " patterns in " << filename
		       << std::endl;


	    //
	    // Set status of all patterns and packages according to import map
	    //

	    for ( ZyppPoolIterator it = zyppPatternsBegin();
		  it != zyppPatternsEnd();
		  ++it )
	    {
		ZyppSel selectable = *it;
		importSelectable( *it, importPatterns.find( selectable->name() ) != importPatterns.end(), "pattern" );
	    }

	    for ( ZyppPoolIterator it = zyppPkgBegin();
		  it != zyppPkgEnd();
		  ++it )
	    {
		ZyppSel selectable = *it;
		importSelectable( *it, importPkg.find( selectable->name() ) != importPkg.end(), "package" );
	    }

		YGPackageSelector::get()->popupChanges();
	}
	catch (const zypp::Exception & exception)
	{
	    yuiWarning() << "Error reading package list from " << filename << std::endl;
	    std::string str (_("Could not open:"));
	    str += " "; str += filename;
		errorMsg (str);
	}

	g_free (filename);
	Ypp::runSolver();
    }

	gtk_widget_destroy (dialog);
}

static void export_file_cb (GtkMenuItem *item)
{
	GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Export to"),
		YGDialog::currentWindow(), GTK_FILE_CHOOSER_ACTION_SAVE,
		GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
		GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);

	GtkFileFilter *filter = gtk_file_filter_new();
	gtk_file_filter_set_name (filter, "*.xml");
	gtk_file_filter_add_pattern (filter, "*.xml");
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name (filter, "*");
	gtk_file_filter_add_pattern (filter, "*");
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);

	gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), DEFAULT_EXPORT_FILE_NAME);
	gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), TRUE);
	gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);

	int ret = gtk_dialog_run (GTK_DIALOG (dialog));
	if (ret == GTK_RESPONSE_ACCEPT) {
	char *filename;
	filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));

	zypp::syscontent::Writer writer;
	const zypp::ResPool & pool = zypp::getZYpp()->pool();

	// The ZYPP obfuscated C++ contest proudly presents:

	for_each( pool.begin(), pool.end(),
		  boost::bind( &zypp::syscontent::Writer::addIf,
			       boost::ref( writer ),
			       _1 ) );
	// Yuck. What a mess.
	//
	// Does anybody seriously believe this kind of thing is easier to read,
	// let alone use? Get real. This is an argument in favour of all C++
	// haters. And it's one that is really hard to counter.
	//
	// -sh 2006-12-13

	try
	{
	    std::ofstream exportFile( filename );
	    exportFile.exceptions( std::ios_base::badbit | std::ios_base::failbit );
	    exportFile << writer;

	    yuiMilestone() << "Package list exported to " << filename << std::endl;
	}
	catch ( std::exception & exception )
	{
	    yuiWarning() << "Error exporting package list to " << filename << std::endl;

	    // The export might have left over a partially written file.
	    // Try to delete it. Don't care if it doesn't exist and unlink() fails.
	    g_remove (filename);

	    // Post error popup
	    std::string str (_("Could not save to:"));
	    str += " "; str += filename;
		errorMsg (str);
	}

	g_free (filename);
   }

	gtk_widget_destroy (dialog);
}

static void create_solver_testcase_cb (GtkMenuItem *item)
{
	const char *dirname = "/var/log/YaST2/solverTestcase";
	std::string msg (_("Use this to generate extensive logs to help tracking "
		"down bugs in the dependencies resolver."));
	msg += "\n"; msg += _("The logs will be saved to the directory:");
	msg += " "; msg += dirname;

	GtkWidget *dialog = gtk_message_dialog_new (YGDialog::currentWindow(),
		GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK_CANCEL,
	// Translators: if there is no direct translation to Dependencies Resolver, then translate it to e.g. Dependencies Manager
		"%s", _("Generate Dependencies Resolver Testcase"));
	gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", msg.c_str());
	int ret = gtk_dialog_run (GTK_DIALOG (dialog));
	gtk_widget_destroy (dialog);

	if (ret == GTK_RESPONSE_OK) {
		bool success;
		yuiMilestone() << "Generating solver test case START" << std::endl;
		success = zypp::getZYpp()->resolver()->createSolverTestcase (dirname);
		yuiMilestone() << "Generating solver test case END" << std::endl;

	    if (success) {
			GtkWidget *dialog = gtk_message_dialog_new (YGDialog::currentWindow(),
				GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
				GTK_BUTTONS_YES_NO, "%s", _("Success"));
			msg = _("Dependencies resolver test case written to:");
			msg += " <tt>";
			msg += dirname;
			msg += "</tt>\n";
			msg += _("Also create a <tt>y2logs.tgz</tt> tar archive to attach to bugzilla?");
			gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog),
                                                                                "%s", msg.c_str());
			ret = gtk_dialog_run (GTK_DIALOG (dialog));
			gtk_widget_destroy (dialog);
			if (ret == GTK_RESPONSE_YES)
				YGUI::ui()->askSaveLogs();
	    }
	    else {
	    	msg = _("Failed to create dependencies resolver testcase.\n"
				"Please check disk space and permissions for:");
			msg += " <tt>"; msg += dirname; msg += "</tt>";
			errorMsg (msg.c_str());
	    }
	}
}

static void repoManager()
{
    yuiMilestone() << "Closing PackageSelector with \"RepoManager\"" << std::endl;
    YGUI::ui()->sendEvent( new YMenuEvent( "repo_mgr" ) );
}

static void onlineUpdateConfiguration()
{
    yuiMilestone() << "Closing PackageSelector with \"OnlineUpdateConfiguration\"" << std::endl;
    YGUI::ui()->sendEvent( new YMenuEvent( "online_update_configuration" ) );
}

static void manualResolvePackageDependencies()
{ Ypp::runSolver (true); }

// check menu item flags

struct CheckMenuFlag {
	CheckMenuFlag (GtkWidget *menu, const char *text) {
		std::string str (YGUtils::mapKBAccel(text));
		m_item = gtk_check_menu_item_new_with_mnemonic (str.c_str());
		g_object_set_data_full (G_OBJECT (m_item), "this", this, destructor);
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), m_item);
	}

	void init (Flags *flags) {
		bool check = getZyppValue();

		const char *var = variable();
		if (flags->hasKey (var)) {
			bool c = flags->getBool (var);
			if (c != check)
				setZyppValue (c);
			check = c;
		}

		gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (m_item), check);
		g_signal_connect_after (G_OBJECT (m_item), "toggled", G_CALLBACK (toggled_cb), this);
	}

	virtual const char *variable() = 0;
	virtual bool getZyppValue() = 0;
	virtual void setZyppValue (bool on) = 0;
	virtual void runtimeSync() {}

	void writeFile (bool on) {
		Flags flags;
		flags.setBool (variable(), on);
	}

	static void toggled_cb (GtkCheckMenuItem *item, CheckMenuFlag *pThis) {
		bool on = gtk_check_menu_item_get_active (item);
		pThis->setZyppValue (on);
		pThis->runtimeSync();
		pThis->writeFile (on);
	}

	static void destructor (gpointer data) {
		delete ((CheckMenuFlag *) data);
	}

	GtkWidget *m_item;
};

struct AutoCheckItem : public CheckMenuFlag {
	AutoCheckItem (GtkWidget *menu, const char *text, Flags *flags)
	: CheckMenuFlag (menu, text) { init (flags); }
	virtual const char *variable() { return "auto-check"; }
	virtual bool getZyppValue() { return Ypp::isSolverEnabled(); }
	virtual void setZyppValue (bool on) { Ypp::setEnableSolver (on); }
};

struct ShowDevelCheckItem : public CheckMenuFlag {
	ShowDevelCheckItem (GtkWidget *menu, const char *text, Flags *flags)
	: CheckMenuFlag (menu, text) { init (flags); }
	virtual const char *variable() { return "show-devel"; }
	virtual bool getZyppValue() { return true; }
	virtual void setZyppValue (bool on)
	{ YGPackageSelector::get()->filterPkgSuffix ("-devel", !on); }
};

struct ShowDebugCheckItem : public CheckMenuFlag {
	ShowDebugCheckItem (GtkWidget *menu, const char *text, Flags *flags)
	: CheckMenuFlag (menu, text) { init (flags); }
	virtual const char *variable() { return "show-debug"; }
	virtual bool getZyppValue() { return true; }
	virtual void setZyppValue (bool on) {
		YGPackageSelector::get()->filterPkgSuffix ("-debuginfo", !on);
		YGPackageSelector::get()->filterPkgSuffix ("-debugsource", !on);
	}
};

struct SystemVerificationCheckItem : public CheckMenuFlag {
	SystemVerificationCheckItem (GtkWidget *menu, const char *text, Flags *flags)
	: CheckMenuFlag (menu, text) { init (flags); }
	virtual const char *variable() { return "system-verification"; }
	virtual bool getZyppValue() {
		return zypp::getZYpp()->resolver()->systemVerification();
	}
	virtual void setZyppValue (bool on) {
		zypp::getZYpp()->resolver()->setSystemVerification (on);
	}
	virtual void runtimeSync() {}
};

struct IgnoreAlreadyRecommendedCheckItem : public CheckMenuFlag {
	IgnoreAlreadyRecommendedCheckItem (GtkWidget *menu, const char *text, Flags *flags)
	: CheckMenuFlag (menu, text) { init (flags); }
	virtual const char *variable() { return "ignore-already-recommended"; }
	virtual bool getZyppValue() {
		return zypp::getZYpp()->resolver()->ignoreAlreadyRecommended();
	}
	virtual void setZyppValue (bool on) {
		zypp::getZYpp()->resolver()->setIgnoreAlreadyRecommended(on);
	}
	virtual void runtimeSync() { Ypp::runSolver(); }
};

#if ZYPP_VERSION > 6031004

struct CleanupDepsCheckItem : public CheckMenuFlag {
	CleanupDepsCheckItem (GtkWidget *menu, const char *text, Flags *flags)
	: CheckMenuFlag (menu, text) { init (flags); }
	virtual const char *variable() { return "cleanup-deps"; }
	virtual bool getZyppValue() {
		return zypp::getZYpp()->resolver()->cleandepsOnRemove();
	}
	virtual void setZyppValue (bool on) {
		zypp::getZYpp()->resolver()->setCleandepsOnRemove( on );
	}
	virtual void runtimeSync() { Ypp::runSolver(); }
};

struct AllowVendorChangeCheckItem : public CheckMenuFlag {
	AllowVendorChangeCheckItem (GtkWidget *menu, const char *text, Flags *flags)
	: CheckMenuFlag (menu, text) { init (flags); }
	virtual const char *variable() { return "allow-vendor-change"; }
	virtual bool getZyppValue() {
		return zypp::getZYpp()->resolver()->allowVendorChange();
	}
	virtual void setZyppValue (bool on) {
		zypp::getZYpp()->resolver()->setAllowVendorChange( on );
	}
	virtual void runtimeSync() { Ypp::runSolver(); }
};

#endif

static void installSubPkgs (std::string suffix)
{
    // Find all matching packages and put them into a QMap

    std::map<std::string, ZyppSel> subPkgs;

    for ( ZyppPoolIterator it = zyppPkgBegin(); it != zyppPkgEnd(); ++it )
    {
	std::string name = (*it)->name();

	if (YGUtils::endsWith (name, suffix))
	{
	    subPkgs[ name ] = *it;
	    yuiDebug() << "Found subpackage: " << name << std::endl;
	}
    }


    // Now go through all packages and look if there is a corresponding subpackage in the QMap

    for ( ZyppPoolIterator it = zyppPkgBegin(); it != zyppPkgEnd(); ++it )
    {
	std::string name = (*it)->name();

    std::string subPkgName( name + suffix );
	if ( subPkgs.find( subPkgName ) != subPkgs.end() )
	{
	    ZyppSel subPkg = subPkgs[ subPkgName ];

	    switch ( (*it)->status() )
	    {
		case S_AutoDel:
		case S_NoInst:
		case S_Protected:
		case S_Taboo:
		case S_Del:
		    // Don't install the subpackage
		    yuiMilestone() << "Ignoring unwanted subpackage " << subPkgName << std::endl;
		    break;

		case S_AutoInstall:
		case S_Install:
		case S_KeepInstalled:

		    // Install the subpackage, but don't try to update it

		    if ( ! subPkg->installedObj() )
		    {
			subPkg->setStatus( S_Install );
			yuiMilestone() << "Installing subpackage " << subPkgName << std::endl;
		    }
		    break;


		case S_Update:
		case S_AutoUpdate:

		    // Install or update the subpackage

		    if ( ! subPkg->installedObj() )
		    {
			subPkg->setStatus( S_Install );
			yuiMilestone() << "Installing subpackage " << subPkgName << std::endl;
		    }
		    else
		    {
			subPkg->setStatus( S_Update );
			yuiMilestone() << "Updating subpackage " << subPkgName << std::endl;
		    }
		    break;

		    // Intentionally omitting 'default' branch so the compiler can
		    // catch unhandled enum states
	    }
	}
    }

	Ypp::runSolver();
	YGPackageSelector::get()->popupChanges();
}

static void install_all_devel_pkgs_cb()
{ installSubPkgs ("-devel"); }

static void install_all_debug_info_pkgs_cb()
{ installSubPkgs ("-debuginfo"); }

static void install_all_debug_source_pkgs_cb()
{ installSubPkgs ("-debugsource"); }

static void show_pkg_changes_cb()
{ YGPackageSelector::get()->popupChanges(); }

static void show_log_changes_cb()
{ YGPackageSelector::get()->showHistoryDialog(); }

#ifdef HAS_VESTIGIAL_DIALOG
static void show_vestigial_packages_cb()
{ YGPackageSelector::get()->showVestigialDialog(); }
#endif

static void reset_ignored_dependency_conflicts_cb()
{ zypp::getZYpp()->resolver()->undo(); }

#include "ygtkpkgproductdialog.h"

static void show_products_cb()
{
	YGtkPkgProductDialog dialog;
	dialog.popup();
}

static void accept_item_cb (GtkMenuItem *item, YGPackageSelector *selector)
{ selector->apply(); }

static void reject_item_cb (GtkMenuItem *item, YGPackageSelector *selector)
{ selector->cancel(); }

YGtkPkgMenuBar::YGtkPkgMenuBar()
{
	YGPackageSelector *selector = YGPackageSelector::get();
	m_menu = gtk_menu_bar_new();
	Flags flags;

	GtkWidget *menu_bar = m_menu, *item, *submenu;
	item = append_menu_item (menu_bar, _("F&ile"), NULL, NULL, NULL);
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), (submenu = gtk_menu_new()));
		append_menu_item (submenu, _("&Import..."), NULL,
			G_CALLBACK (import_file_cb), this);
		append_menu_item (submenu, _("&Export..."), NULL,
			G_CALLBACK (export_file_cb), this);
		append_menu_item (submenu, NULL, NULL, NULL, NULL);
		append_menu_item (submenu, NULL, GTK_STOCK_APPLY, G_CALLBACK (accept_item_cb), selector);
		append_menu_item (submenu, NULL, GTK_STOCK_QUIT, G_CALLBACK (reject_item_cb), selector);
	if (selector->repoMgrEnabled()) {
		item = append_menu_item (menu_bar, _("&Configuration"), NULL, NULL, NULL);
		gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), (submenu = gtk_menu_new()));
			append_menu_item (submenu, _("&Repositories..."), NULL,
				G_CALLBACK (repoManager), this);
			if (selector->onlineUpdateMode())
				append_menu_item (submenu, _("&Online Update..."), NULL,
					G_CALLBACK (onlineUpdateConfiguration), this);
	}
	item = append_menu_item (menu_bar, _("&Dependencies"), NULL, NULL, NULL);
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), (submenu = gtk_menu_new()));
		append_menu_item (submenu, _("&Check Now"), NULL,
			G_CALLBACK (manualResolvePackageDependencies), this);
		new AutoCheckItem (submenu, _("&Autocheck"), &flags);

	if (!selector->onlineUpdateMode()) {
		item = append_menu_item (menu_bar, _("&Options"), NULL, NULL, NULL);
		gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), (submenu = gtk_menu_new()));
			// Translators: don't translate the "-devel"
			new ShowDevelCheckItem (submenu, _("Show -de&vel Packages"), &flags);
			// Translators: don't translate the "-debuginfo/-debugsource" part
			new ShowDebugCheckItem (submenu, _("Show -&debuginfo/-debugsource Packages"), &flags);
			new SystemVerificationCheckItem (submenu, _("&System Verification Mode"), &flags);
			new IgnoreAlreadyRecommendedCheckItem (submenu, _("&Ignore recommended packages for already installed packages"), &flags);

#if ZYPP_VERSION > 6031004
			new CleanupDepsCheckItem (submenu, _("&Cleanup when deleting packages"), &flags);
			new AllowVendorChangeCheckItem (submenu, _("&Allow vendor change"), &flags);
#endif
	}

	item = append_menu_item (menu_bar, _("E&xtras"), NULL, NULL, NULL);
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), (submenu = gtk_menu_new()));
		append_menu_item (submenu, _("Show &Products"), NULL,
			G_CALLBACK (show_products_cb), this);
		append_menu_item (submenu, _("Show &Changes"), NULL,
			G_CALLBACK (show_pkg_changes_cb), this);
		if (!selector->onlineUpdateMode()) {
			append_menu_item (submenu, _("Show &History"), NULL,
				G_CALLBACK (show_log_changes_cb), this);
#ifdef HAS_VESTIGIAL_DIALOG
			append_menu_item (submenu, _("Show &Unneeded Dependencies"), NULL,
				G_CALLBACK (show_vestigial_packages_cb), this);
#endif
		}
		append_menu_item (submenu, NULL, NULL, NULL, NULL);
		// Translators: keep "-_devel" untranslated
		append_menu_item (submenu, _("Install All Matching -&devel Packages"), NULL,
			G_CALLBACK (install_all_devel_pkgs_cb), this);
		// Translators: keep "-debug-_info" untranslated
		append_menu_item (submenu, _("Install All Matching -debug-&info Packages"), NULL,
			G_CALLBACK (install_all_debug_info_pkgs_cb), this);
		// Translators: keep "-debug-_source" untranslated
		append_menu_item (submenu, _("Install All Matching -debug-&source Packages"), NULL,
			G_CALLBACK (install_all_debug_source_pkgs_cb), this);
		append_menu_item (submenu, NULL, NULL, NULL, NULL);
		append_menu_item (submenu, _("Generate Dependencies Resolver &Testcase"), NULL,
			G_CALLBACK (create_solver_testcase_cb), this);
		append_menu_item (submenu, _("Reset &Ignored Dependencies Conflicts"), NULL,
			G_CALLBACK (reset_ignored_dependency_conflicts_cb), this);

	//** TEMP: work-around global-menubar-applet: see bug 595560
	//**       will call show_all() at YGPackageSelector.cc
	//gtk_widget_show_all (m_menu);
}