Attachment #251487 for bug #342007

View | Details | Raw Unified | Return to bug 342007
Collapse All | Expand All

Lines 238-243 Link Here

(-)a/scripts/kconfig/Makefile (+1 lines)
238	@set -e; echo " CHECK qt"; dir=""; pkg=""; \	238	@set -e; echo " CHECK qt"; dir=""; pkg=""; \
239	pkg-config --exists qt 2> /dev/null && pkg=qt; \	239	pkg-config --exists qt 2> /dev/null && pkg=qt; \
240	pkg-config --exists qt-mt 2> /dev/null && pkg=qt-mt; \	240	pkg-config --exists qt-mt 2> /dev/null && pkg=qt-mt; \
		241	pkg-config --exists Qt3Support 2> /dev/null && pkg=Qt3Support; \
241	if [ -n "$$pkg" ]; then \	242	if [ -n "$$pkg" ]; then \
242	cflags="\$$(shell pkg-config $$pkg --cflags)"; \	243	cflags="\$$(shell pkg-config $$pkg --cflags)"; \
243	libs="\$$(shell pkg-config $$pkg --libs)"; \	244	libs="\$$(shell pkg-config $$pkg --libs)"; \




 * Released under the terms of the GNU GPL v2.0.
 */

#include <q3listview.h>
#if QT_VERSION >= 300
#include <qsettings.h>
//Added by qt3to4:
#include <QContextMenuEvent>
#include <QCloseEvent>
#include <QFocusEvent>
#include <Q3ValueList>
#include <QPixmap>
#include <QMouseEvent>
#include <Q3PopupMenu>
#include <QKeyEvent>
#else
class QSettings {
public:


class ConfigSettings : public QSettings {
public:
	Q3ValueList<int> readSizes(const QString& key, bool *ok);
	bool writeSizes(const QString& key, const Q3ValueList<int>& value);
};

enum colIdx {

	normalOpt = 0, allOpt, promptOpt
};

class ConfigList : public Q3ListView {
	Q_OBJECT
	typedef class Q3ListView Parent;
public:
	ConfigList(ConfigView* p, const char *name = 0);
	void reinit(void);

	{
		return (ConfigView*)Parent::parent();
	}
	ConfigItem* findConfigItem(KCMenu *);

protected:
	void keyPressEvent(QKeyEvent *e);

	void contextMenuEvent(QContextMenuEvent *e);

public slots:
	void setRootMenu(KCMenu *menu);

	void updateList(ConfigItem *item);
	void setValue(ConfigItem* item, tristate val);

	void updateSelection(void);
	void saveSettings(void);
signals:
	void menuChanged(KCMenu *menu);
	void menuSelected(KCMenu *menu);
	void parentSelected(void);
	void gotFocus(KCMenu *);

public:
	void updateListAll(void)

	bool menuSkip(struct menu *);

	template <class P>
	void updateMenuList(P*, KCMenu*);

	bool updateAll;


	bool showName, showRange, showData;
	enum listMode mode;
	enum optionMode optMode;
	KCMenu *rootEntry;
	QColorGroup disabledColorGroup;
	QColorGroup inactivedColorGroup;
	Q3PopupMenu* headerPopup;

private:
	int colMap[colNr];
	int colRevMap[colNr];
};

class ConfigItem : public Q3ListViewItem {
	typedef class Q3ListViewItem Parent;
public:
	ConfigItem(Q3ListView *parent, ConfigItem *after, KCMenu *m, bool v)
	: Parent(parent, after), menu(m), visible(v), goParent(false)
	{
		init();
	}
	ConfigItem(ConfigItem *parent, ConfigItem *after, KCMenu *m, bool v)
	: Parent(parent, after), menu(m), visible(v), goParent(false)
	{
		init();
	}
	ConfigItem(Q3ListView *parent, ConfigItem *after, bool v)
	: Parent(parent, after), menu(0), visible(v), goParent(true)
	{
		init();

	void paintCell(QPainter* p, const QColorGroup& cg, int column, int width, int align);

	ConfigItem* nextItem;
	KCMenu *menu;
	bool visible;
	bool goParent;
};

	ConfigItem *item;
};

class ConfigView : public Q3VBox {
	Q_OBJECT
	typedef class Q3VBox Parent;
public:
	ConfigView(QWidget* parent, const char *name = 0);
	~ConfigView(void);

	static QAction *showPromptAction;
};

class ConfigInfoView : public Q3TextBrowser {
	Q_OBJECT
	typedef class Q3TextBrowser Parent;
public:
	ConfigInfoView(QWidget* parent, const char *name = 0);
	bool showDebug(void) const { return _showDebug; }

public slots:
	void setInfo(KCMenu *menu);
	void saveSettings(void);
	void setShowDebug(bool);

signals:
	void showDebugChanged(bool);
	void menuSelected(KCMenu *);

protected:
	void symbolInfo(void);

	QString debug_info(struct symbol *sym);
	static QString print_filter(const QString &str);
	static void expr_print_help(void *data, struct symbol *sym, const char *str);
	Q3PopupMenu* createPopupMenu(const QPoint& pos);
	void contentsContextMenuEvent(QContextMenuEvent *e);

	struct symbol *sym;
	KCMenu *menu;
	bool _showDebug;
};


	struct symbol **result;
};

class ConfigMainWindow : public Q3MainWindow {
	Q_OBJECT

	static QAction *saveAction;

public:
	ConfigMainWindow(void);
public slots:
	void changeMenu(KCMenu *);
	void setMenuLink(KCMenu *);
	void listFocusChanged(void);
	void goBack(void);
	void loadConfig(void);

	ConfigView *configView;
	ConfigList *configList;
	ConfigInfoView *helpText;
	Q3ToolBar *toolBar;
	QAction *backAction;
	QSplitter* split1;
	QSplitter* split2;




 */

#include <qapplication.h>
#include <q3mainwindow.h>
#include <qdesktopwidget.h>
#include <q3toolbar.h>
#include <qlayout.h>
#include <q3vbox.h>
#include <qsplitter.h>
#include <q3listview.h>
#include <q3textbrowser.h>
#include <qlineedit.h>
#include <qlabel.h>
#include <qpushbutton.h>
#include <qmenubar.h>
#include <qmessagebox.h>
#include <qaction.h>
#include <q3header.h>
#include <q3filedialog.h>
#include <q3dragobject.h>
#include <qregexp.h>
//Added by qt3to4:
#include <QContextMenuEvent>
#include <QPixmap>
#include <QFocusEvent>
#include <QMouseEvent>
#include <QCloseEvent>
#include <Q3ValueList>
#include <QKeyEvent>
#include <Q3HBoxLayout>
#include <Q3VBoxLayout>
#include <Q3PopupMenu>

#include <stdlib.h>


/**
 * Reads a list of integer values from the application settings.
 */
Q3ValueList<int> ConfigSettings::readSizes(const QString& key, bool *ok)
{
	Q3ValueList<int> result;
	QStringList entryList = readListEntry(key, ok);
	QStringList::Iterator it;


/**
 * Writes a list of integer values to the application settings.
 */
bool ConfigSettings::writeSizes(const QString& key, const Q3ValueList<int>& value)
{
	QStringList stringList;
	Q3ValueList<int>::ConstIterator it;

	for (it = value.begin(); it != value.end(); ++it)
		stringList.push_back(QString::number(*it));

	}
}

ConfigItem* ConfigList::findConfigItem(KCMenu *menu)
{
	ConfigItem* item = (ConfigItem*)menu->data;



void ConfigList::updateSelection(void)
{
	KCMenu *menu;
	enum prop_type type;

	ConfigItem* item = (ConfigItem*)selectedItem();

	if (!rootEntry) {
		if (mode != listMode)
			goto update;
		Q3ListViewItemIterator it(this);
		ConfigItem* item;

		for (; it.current(); ++it) {

void ConfigList::changeValue(ConfigItem* item)
{
	struct symbol* sym;
	KCMenu* menu;
	int type, oldexpr, newexpr;

	menu = item->menu;

	}
}

void ConfigList::setRootMenu(KCMenu *menu)
{
	enum prop_type type;


void ConfigList::setParentMenu(void)
{
	ConfigItem* item;
	KCMenu *oldroot;

	oldroot = rootEntry;
	if (rootEntry == &rootmenu)
		return;
	setRootMenu(menu_get_parent_menu(rootEntry->parent));

	Q3ListViewItemIterator it(this);
	for (; (item = (ConfigItem*)it.current()); it++) {
		if (item->menu == oldroot) {
			setCurrentItem(item);

 * menu: entry to be updated
 */
template <class P>
void ConfigList::updateMenuList(P* parent, KCMenu* menu)
{
	KCMenu* child;
	ConfigItem* item;
	ConfigItem* last;
	bool visible;


void ConfigList::keyPressEvent(QKeyEvent* ev)
{
	Q3ListViewItem* i = currentItem();
	ConfigItem* item;
	KCMenu *menu;
	enum prop_type type;

	if (ev->key() == Qt::Key_Escape && mode != fullMode && mode != listMode) {

{
	QPoint p(contentsToViewport(e->pos()));
	ConfigItem* item = (ConfigItem*)itemAt(p);
	KCMenu *menu;
	enum prop_type ptype;
	const QPixmap* pm;
	int idx, x;

{
	QPoint p(contentsToViewport(e->pos()));
	ConfigItem* item = (ConfigItem*)itemAt(p);
	KCMenu *menu;
	enum prop_type ptype;

	if (!item)


void ConfigList::focusInEvent(QFocusEvent *e)
{
	KCMenu *menu = NULL;

	Parent::focusInEvent(e);


		if (!headerPopup) {
			QAction *action;

			headerPopup = new Q3PopupMenu(this);
			action = new QAction(_("Show Name"), this);
			  action->setToggleAction(TRUE);
			  connect(action, SIGNAL(toggled(bool)),
				  parent(), SLOT(setShowName(bool)));

				  action, SLOT(setOn(bool)));
			  action->setOn(showName);
			  action->addTo(headerPopup);
			action = new QAction(_("Show Range"), this);
			  action->setToggleAction(TRUE);
			  connect(action, SIGNAL(toggled(bool)),
				  parent(), SLOT(setShowRange(bool)));

				  action, SLOT(setOn(bool)));
			  action->setOn(showRange);
			  action->addTo(headerPopup);
			action = new QAction(_("Show Data"), this);
			  action->setToggleAction(TRUE);
			  connect(action, SIGNAL(toggled(bool)),
				  parent(), SLOT(setShowData(bool)));


void ConfigList::setAllOpen(bool open)
{
	Q3ListViewItemIterator it(this);

	for (; it.current(); it++)
		it.current()->setOpen(open);

	}
}

void ConfigInfoView::setInfo(KCMenu *m)
{
	if (menu == m)
		return;

		*text += str2;
}

Q3PopupMenu* ConfigInfoView::createPopupMenu(const QPoint& pos)
{
	Q3PopupMenu* popup = Parent::createPopupMenu(pos);
	QAction* action = new QAction(_("Show Debug Info"), popup);
	  action->setToggleAction(TRUE);
	  connect(action, SIGNAL(toggled(bool)), SLOT(setShowDebug(bool)));
	  connect(this, SIGNAL(showDebugChanged(bool)), action, SLOT(setOn(bool)));

{
	setCaption("Search Config");

	Q3VBoxLayout* layout1 = new Q3VBoxLayout(this, 11, 6);
	Q3HBoxLayout* layout2 = new Q3HBoxLayout(0, 0, 6);
	layout2->addWidget(new QLabel(_("Find:"), this));
	editField = new QLineEdit(this);
	connect(editField, SIGNAL(returnPressed()), SLOT(search()));

	list = new ConfigView(split, name);
	list->list->mode = listMode;
	info = new ConfigInfoView(split, name);
	connect(list->list, SIGNAL(menuChanged(KCMenu *)),
		info, SLOT(setInfo(KCMenu *)));
	connect(list->list, SIGNAL(menuChanged(KCMenu *)),
		parent, SLOT(setMenuLink(KCMenu *)));

	layout1->addWidget(split);


			y = configSettings->readNumEntry("/window y", 0, &ok);
		if (ok)
			move(x, y);
		Q3ValueList<int> sizes = configSettings->readSizes("/split", &ok);
		if (ok)
			split->setSizes(sizes);
		configSettings->endGroup();

	configList->setFocus();

	menu = menuBar();
	toolBar = new Q3ToolBar("Tools", this);

	backAction = new QAction(QPixmap(xpm_back), _("Back"), this);
	  connect(backAction, SIGNAL(activated()), SLOT(goBack()));
	  backAction->setEnabled(FALSE);
	QAction *quitAction = new QAction(_("&Quit"), Qt::CTRL + Qt::Key_Q, this, 0);
	  connect(quitAction, SIGNAL(activated()), SLOT(close()));
	QAction *loadAction = new QAction(QPixmap(xpm_load), _("&Load"), Qt::CTRL + Qt::Key_L, this, 0);
	  connect(loadAction, SIGNAL(activated()), SLOT(loadConfig()));
	saveAction = new QAction(QPixmap(xpm_save), _("&Save"), Qt::CTRL + Qt::Key_S, this, 0);
	  connect(saveAction, SIGNAL(activated()), SLOT(saveConfig()));
	conf_set_changed_callback(conf_changed);
	// Set saveAction's initial state
	conf_changed();
	QAction *saveAsAction = new QAction(_("Save &As..."), 0, this, "Save As...");
	  connect(saveAsAction, SIGNAL(activated()), SLOT(saveConfigAs()));
	QAction *searchAction = new QAction(_("&Find"), Qt::CTRL + Qt::Key_F, this, "Find");
	  connect(searchAction, SIGNAL(activated()), SLOT(searchConfig()));
	QAction *singleViewAction = new QAction(QPixmap(xpm_single_view), _("Single View"), 0, this, "Single View");
	  connect(singleViewAction, SIGNAL(activated()), SLOT(showSingleView()));
	QAction *splitViewAction = new QAction(QPixmap(xpm_split_view), _("Split View"), 0, this, "Split View");
	  connect(splitViewAction, SIGNAL(activated()), SLOT(showSplitView()));
	QAction *fullViewAction = new QAction(QPixmap(xpm_tree_view), _("Full View"), 0, this, "Full View");
	  connect(fullViewAction, SIGNAL(activated()), SLOT(showFullView()));

	QAction *showNameAction = new QAction(_("Show Name"), 0, this, 0);
	  showNameAction->setToggleAction(TRUE);
	  connect(showNameAction, SIGNAL(toggled(bool)), configView, SLOT(setShowName(bool)));
	  connect(configView, SIGNAL(showNameChanged(bool)), showNameAction, SLOT(setOn(bool)));
	  showNameAction->setOn(configView->showName());
	QAction *showRangeAction = new QAction(_("Show Range"), 0, this, 0);
	  showRangeAction->setToggleAction(TRUE);
	  connect(showRangeAction, SIGNAL(toggled(bool)), configView, SLOT(setShowRange(bool)));
	  connect(configView, SIGNAL(showRangeChanged(bool)), showRangeAction, SLOT(setOn(bool)));
	  showRangeAction->setOn(configList->showRange);
	QAction *showDataAction = new QAction(_("Show Data"), 0, this, 0);
	  showDataAction->setToggleAction(TRUE);
	  connect(showDataAction, SIGNAL(toggled(bool)), configView, SLOT(setShowData(bool)));
	  connect(configView, SIGNAL(showDataChanged(bool)), showDataAction, SLOT(setOn(bool)));

	connect(optGroup, SIGNAL(selected(QAction *)), menuView,
		SLOT(setOptionMode(QAction *)));

	configView->showNormalAction = new QAction(_("Show Normal Options"), 0, optGroup, 0);
	configView->showAllAction = new QAction(_("Show All Options"), 0, optGroup, 0);
	configView->showPromptAction = new QAction(_("Show Prompt Options"), 0, optGroup, 0);
	configView->showNormalAction->setToggleAction(TRUE);
	configView->showNormalAction->setOn(configList->optMode == normalOpt);
	configView->showAllAction->setToggleAction(TRUE);

	configView->showPromptAction->setToggleAction(TRUE);
	configView->showPromptAction->setOn(configList->optMode == promptOpt);

	QAction *showDebugAction = new QAction(_("Show Debug Info"), 0, this, 0);
	  showDebugAction->setToggleAction(TRUE);
	  connect(showDebugAction, SIGNAL(toggled(bool)), helpText, SLOT(setShowDebug(bool)));
	  connect(helpText, SIGNAL(showDebugChanged(bool)), showDebugAction, SLOT(setOn(bool)));
	  showDebugAction->setOn(helpText->showDebug());

	QAction *showIntroAction = new QAction(_("Introduction"), 0, this, 0);
	  connect(showIntroAction, SIGNAL(activated()), SLOT(showIntro()));
	QAction *showAboutAction = new QAction(_("About"), 0, this, 0);
	  connect(showAboutAction, SIGNAL(activated()), SLOT(showAbout()));

	// init tool bar

	fullViewAction->addTo(toolBar);

	// create config menu
	Q3PopupMenu* config = new Q3PopupMenu(this);
	menu->insertItem(_("&File"), config);
	loadAction->addTo(config);
	saveAction->addTo(config);

	quitAction->addTo(config);

	// create edit menu
	Q3PopupMenu* editMenu = new Q3PopupMenu(this);
	menu->insertItem(_("&Edit"), editMenu);
	searchAction->addTo(editMenu);

	// create options menu
	Q3PopupMenu* optionMenu = new Q3PopupMenu(this);
	menu->insertItem(_("&Option"), optionMenu);
	showNameAction->addTo(optionMenu);
	showRangeAction->addTo(optionMenu);

	showDebugAction->addTo(optionMenu);

	// create help menu
	Q3PopupMenu* helpMenu = new Q3PopupMenu(this);
	menu->insertSeparator();
	menu->insertItem(_("&Help"), helpMenu);
	showIntroAction->addTo(helpMenu);
	showAboutAction->addTo(helpMenu);

	connect(configList, SIGNAL(menuChanged(KCMenu *)),
		helpText, SLOT(setInfo(KCMenu *)));
	connect(configList, SIGNAL(menuSelected(KCMenu *)),
		SLOT(changeMenu(KCMenu *)));
	connect(configList, SIGNAL(parentSelected()),
		SLOT(goBack()));
	connect(menuList, SIGNAL(menuChanged(KCMenu *)),
		helpText, SLOT(setInfo(KCMenu *)));
	connect(menuList, SIGNAL(menuSelected(KCMenu *)),
		SLOT(changeMenu(KCMenu *)));

	connect(configList, SIGNAL(gotFocus(KCMenu *)),
		helpText, SLOT(setInfo(KCMenu *)));
	connect(menuList, SIGNAL(gotFocus(KCMenu *)),
		helpText, SLOT(setInfo(KCMenu *)));
	connect(menuList, SIGNAL(gotFocus(KCMenu *)),
		SLOT(listFocusChanged(void)));
	connect(helpText, SIGNAL(menuSelected(KCMenu *)),
		SLOT(setMenuLink(KCMenu *)));

	QString listMode = configSettings->readEntry("/listMode", "symbol");
	if (listMode == "single")

		showSplitView();

	// UI setup done, restore splitter positions
	Q3ValueList<int> sizes = configSettings->readSizes("/split1", &ok);
	if (ok)
		split1->setSizes(sizes);



void ConfigMainWindow::loadConfig(void)
{
	QString s = Q3FileDialog::getOpenFileName(conf_get_configname(), NULL, this);
	if (s.isNull())
		return;
	if (conf_read(QFile::encodeName(s)))


void ConfigMainWindow::saveConfigAs(void)
{
	QString s = Q3FileDialog::getSaveFileName(conf_get_configname(), NULL, this);
	if (s.isNull())
		return;
	if (conf_write(QFile::encodeName(s)))

	searchWindow->show();
}

void ConfigMainWindow::changeMenu(KCMenu *menu)
{
	configList->setRootMenu(menu);
	if (configList->rootEntry->parent == &rootmenu)

		backAction->setEnabled(TRUE);
}

void ConfigMainWindow::setMenuLink(KCMenu *menu)
{
	KCMenu *parent;
	ConfigList* list = NULL;
	ConfigItem* item;


		saveAction->setEnabled(conf_get_changed());
}

void fixup_rootmenu(KCMenu *menu)
{
	KCMenu *child;
	static int menu_cnt = 0;

	menu->flags |= MENU_ROOT;

Return to bug 342007

Lines 3-11 Link Here

(-)a/scripts/kconfig/qconf.h (-31 / +40 lines)
3	* Released under the terms of the GNU GPL v2.0.	3	* Released under the terms of the GNU GPL v2.0.
4	*/	4	*/
5		5
6	#include <qlistview.h>	6	#include <q3listview.h>
7	#if QT_VERSION >= 300	7	#if QT_VERSION >= 300
8	#include <qsettings.h>	8	#include <qsettings.h>
		9	//Added by qt3to4:
		10	#include <QContextMenuEvent>
		11	#include <QCloseEvent>
		12	#include <QFocusEvent>
		13	#include <Q3ValueList>
		14	#include <QPixmap>
		15	#include <QMouseEvent>
		16	#include <Q3PopupMenu>
		17	#include <QKeyEvent>
9	#else	18	#else
10	class QSettings {	19	class QSettings {
11	public:	20	public:
Lines 34-41 Link Here
34		43
35	class ConfigSettings : public QSettings {	44	class ConfigSettings : public QSettings {
36	public:	45	public:
37	QValueList<int> readSizes(const QString& key, bool *ok);	46	Q3ValueList<int> readSizes(const QString& key, bool *ok);
38	bool writeSizes(const QString& key, const QValueList<int>& value);	47	bool writeSizes(const QString& key, const Q3ValueList<int>& value);
39	};	48	};
40		49
41	enum colIdx {	50	enum colIdx {
Lines 48-56 Link Here
48	normalOpt = 0, allOpt, promptOpt	57	normalOpt = 0, allOpt, promptOpt
49	};	58	};
50		59
51	class ConfigList : public QListView {	60	class ConfigList : public Q3ListView {
52	Q_OBJECT	61	Q_OBJECT
53	typedef class QListView Parent;	62	typedef class Q3ListView Parent;
54	public:	63	public:
55	ConfigList(ConfigView* p, const char *name = 0);	64	ConfigList(ConfigView* p, const char *name = 0);
56	void reinit(void);	65	void reinit(void);
Lines 58-64 Link Here
58	{	67	{
59	return (ConfigView*)Parent::parent();	68	return (ConfigView*)Parent::parent();
60	}	69	}
61	ConfigItem* findConfigItem(struct menu *);	70	ConfigItem* findConfigItem(KCMenu *);
62		71
63	protected:	72	protected:
64	void keyPressEvent(QKeyEvent *e);	73	void keyPressEvent(QKeyEvent *e);
Lines 70-76 Link Here
70	void contextMenuEvent(QContextMenuEvent *e);	79	void contextMenuEvent(QContextMenuEvent *e);
71		80
72	public slots:	81	public slots:
73	void setRootMenu(struct menu *menu);	82	void setRootMenu(KCMenu *menu);
74		83
75	void updateList(ConfigItem *item);	84	void updateList(ConfigItem *item);
76	void setValue(ConfigItem* item, tristate val);	85	void setValue(ConfigItem* item, tristate val);
Lines 78-87 Link Here
78	void updateSelection(void);	87	void updateSelection(void);
79	void saveSettings(void);	88	void saveSettings(void);
80	signals:	89	signals:
81	void menuChanged(struct menu *menu);	90	void menuChanged(KCMenu *menu);
82	void menuSelected(struct menu *menu);	91	void menuSelected(KCMenu *menu);
83	void parentSelected(void);	92	void parentSelected(void);
84	void gotFocus(struct menu *);	93	void gotFocus(KCMenu *);
85		94
86	public:	95	public:
87	void updateListAll(void)	96	void updateListAll(void)
Lines 121-127 Link Here
121	bool menuSkip(struct menu *);	130	bool menuSkip(struct menu *);
122		131
123	template <class P>	132	template <class P>
124	void updateMenuList(P, struct menu);	133	void updateMenuList(P, KCMenu);
125		134
126	bool updateAll;	135	bool updateAll;
127		136
Lines 132-161 Link Here
132	bool showName, showRange, showData;	141	bool showName, showRange, showData;
133	enum listMode mode;	142	enum listMode mode;
134	enum optionMode optMode;	143	enum optionMode optMode;
135	struct menu *rootEntry;	144	KCMenu *rootEntry;
136	QColorGroup disabledColorGroup;	145	QColorGroup disabledColorGroup;
137	QColorGroup inactivedColorGroup;	146	QColorGroup inactivedColorGroup;
138	QPopupMenu* headerPopup;	147	Q3PopupMenu* headerPopup;
139		148
140	private:	149	private:
141	int colMap[colNr];	150	int colMap[colNr];
142	int colRevMap[colNr];	151	int colRevMap[colNr];
143	};	152	};
144		153
145	class ConfigItem : public QListViewItem {	154	class ConfigItem : public Q3ListViewItem {
146	typedef class QListViewItem Parent;	155	typedef class Q3ListViewItem Parent;
147	public:	156	public:
148	ConfigItem(QListView parent, ConfigItem after, struct menu *m, bool v)	157	ConfigItem(Q3ListView parent, ConfigItem after, KCMenu *m, bool v)
149	: Parent(parent, after), menu(m), visible(v), goParent(false)	158	: Parent(parent, after), menu(m), visible(v), goParent(false)
150	{	159	{
151	init();	160	init();
152	}	161	}
153	ConfigItem(ConfigItem parent, ConfigItem after, struct menu *m, bool v)	162	ConfigItem(ConfigItem parent, ConfigItem after, KCMenu *m, bool v)
154	: Parent(parent, after), menu(m), visible(v), goParent(false)	163	: Parent(parent, after), menu(m), visible(v), goParent(false)
155	{	164	{
156	init();	165	init();
157	}	166	}
158	ConfigItem(QListView parent, ConfigItem after, bool v)	167	ConfigItem(Q3ListView parent, ConfigItem after, bool v)
159	: Parent(parent, after), menu(0), visible(v), goParent(true)	168	: Parent(parent, after), menu(0), visible(v), goParent(true)
160	{	169	{
161	init();	170	init();
Lines 198-204 Link Here
198	void paintCell(QPainter* p, const QColorGroup& cg, int column, int width, int align);	207	void paintCell(QPainter* p, const QColorGroup& cg, int column, int width, int align);
199		208
200	ConfigItem* nextItem;	209	ConfigItem* nextItem;
201	struct menu *menu;	210	KCMenu *menu;
202	bool visible;	211	bool visible;
203	bool goParent;	212	bool goParent;
204	};	213	};
Lines 219-227 Link Here
219	ConfigItem *item;	228	ConfigItem *item;
220	};	229	};
221		230
222	class ConfigView : public QVBox {	231	class ConfigView : public Q3VBox {
223	Q_OBJECT	232	Q_OBJECT
224	typedef class QVBox Parent;	233	typedef class Q3VBox Parent;
225	public:	234	public:
226	ConfigView(QWidget* parent, const char *name = 0);	235	ConfigView(QWidget* parent, const char *name = 0);
227	~ConfigView(void);	236	~ConfigView(void);
Lines 252-272 Link Here
252	static QAction *showPromptAction;	261	static QAction *showPromptAction;
253	};	262	};
254		263
255	class ConfigInfoView : public QTextBrowser {	264	class ConfigInfoView : public Q3TextBrowser {
256	Q_OBJECT	265	Q_OBJECT
257	typedef class QTextBrowser Parent;	266	typedef class Q3TextBrowser Parent;
258	public:	267	public:
259	ConfigInfoView(QWidget* parent, const char *name = 0);	268	ConfigInfoView(QWidget* parent, const char *name = 0);
260	bool showDebug(void) const { return _showDebug; }	269	bool showDebug(void) const { return _showDebug; }
261		270
262	public slots:	271	public slots:
263	void setInfo(struct menu *menu);	272	void setInfo(KCMenu *menu);
264	void saveSettings(void);	273	void saveSettings(void);
265	void setShowDebug(bool);	274	void setShowDebug(bool);
266		275
267	signals:	276	signals:
268	void showDebugChanged(bool);	277	void showDebugChanged(bool);
269	void menuSelected(struct menu *);	278	void menuSelected(KCMenu *);
270		279
271	protected:	280	protected:
272	void symbolInfo(void);	281	void symbolInfo(void);
Lines 274-284 Link Here
274	QString debug_info(struct symbol *sym);	283	QString debug_info(struct symbol *sym);
275	static QString print_filter(const QString &str);	284	static QString print_filter(const QString &str);
276	static void expr_print_help(void data, struct symbol sym, const char *str);	285	static void expr_print_help(void data, struct symbol sym, const char *str);
277	QPopupMenu* createPopupMenu(const QPoint& pos);	286	Q3PopupMenu* createPopupMenu(const QPoint& pos);
278	void contentsContextMenuEvent(QContextMenuEvent *e);	287	void contentsContextMenuEvent(QContextMenuEvent *e);
279		288
280	struct symbol *sym;	289	struct symbol *sym;
281	struct menu *menu;	290	KCMenu *menu;
282	bool _showDebug;	291	bool _showDebug;
283	};	292	};
284		293
Lines 302-308 Link Here
302	struct symbol **result;	311	struct symbol **result;
303	};	312	};
304		313
305	class ConfigMainWindow : public QMainWindow {	314	class ConfigMainWindow : public Q3MainWindow {
306	Q_OBJECT	315	Q_OBJECT
307		316
308	static QAction *saveAction;	317	static QAction *saveAction;
Lines 310-317 Link Here
310	public:	319	public:
311	ConfigMainWindow(void);	320	ConfigMainWindow(void);
312	public slots:	321	public slots:
313	void changeMenu(struct menu *);	322	void changeMenu(KCMenu *);
314	void setMenuLink(struct menu *);	323	void setMenuLink(KCMenu *);
315	void listFocusChanged(void);	324	void listFocusChanged(void);
316	void goBack(void);	325	void goBack(void);
317	void loadConfig(void);	326	void loadConfig(void);
Lines 334-340 Link Here
334	ConfigView *configView;	343	ConfigView *configView;
335	ConfigList *configList;	344	ConfigList *configList;
336	ConfigInfoView *helpText;	345	ConfigInfoView *helpText;
337	QToolBar *toolBar;	346	Q3ToolBar *toolBar;
338	QAction *backAction;	347	QAction *backAction;
339	QSplitter* split1;	348	QSplitter* split1;
340	QSplitter* split2;	349	QSplitter* split2;