Attachment #1525 for bug #1664

By default, Bugzilla does not search the list of RESOLVED bugs.
You can force it to do so by putting the upper-case word ALL in front of your search query, e.g.: ALL tdelibs
We recommend searching for bugs this way, as you may discover that your bug has already been resolved and fixed in a later release. View | Details | Raw Unified | Return to bug 1664
Collapse All | Expand All




    begin                : 2004-04-20
    copyright            : (C) 2004 by Dominik Haumann
    email                : dhdev@gmx.de
    updated              : 2013-09-18 by Michele Calgaro
                           - added "close document on mouse middle click" feature
 ***************************************************************************/

/***************************************************************************

  }
}

TQObject* KatePluginFactory::createObject(TQObject *parent,
     const char *name, const char*, const TQStringList&)
{
  return new KatePluginTabBarExtension(parent, name);
}

KatePluginFactory::~KatePluginFactory()
{
  delete s_instance;
}

TQObject* KatePluginFactory::createObject(
    TQObject* parent, const char* name, const char*, const TQStringList & )
{
  return new KatePluginTabBarExtension( parent, name );
}

TDEInstance* KatePluginFactory::s_instance = 0L;

// BEGIN KatePluginTabBarExtension
KatePluginTabBarExtension::KatePluginTabBarExtension(TQObject *parent, const char *name)
  : Kate::Plugin((Kate::Application*)parent, name),
  : Kate::Plugin ( (Kate::Application*)parent, name ),
    pConfig(new TDEConfig("katetabbarextensionpluginrc"))
{
  pConfig->setGroup("global");

{
  while (m_views.count() > 0)
  {
    removeView(m_views.at(0)->win);
  }

  delete pConfig;

{
  PluginView *view = new PluginView ();

  bool bHoriz              = pConfig->readBoolEntry("horizontal orientation", true);
  bool bSort               = pConfig->readBoolEntry("sort", true);
  bool bCloseOnMiddleClick = pConfig->readBoolEntry("closeOnMiddleClick", false);

  view->tabbar = new KateTabBarExtension(application()->documentManager(),
                     win, bHoriz, bSort, bCloseOnMiddleClick, 0, "tabs_hbox");

  new KWidgetAction(view->tabbar, "tab_bar_widget",
      TDEShortcut::null(), 0, 0, view->actionCollection(), "tabbar_widget");

  TDEToolBar* toolbar = dynamic_cast<TDEToolBar*>
      (win->guiFactory()->container("tabbarExtensionToolBar", view));
  if (toolbar) {
    connect(toolbar, TQT_SIGNAL(orientationChanged(Qt::Orientation)),
        view->tabbar, TQT_SLOT(slotMoved(Qt::Orientation)));
  }
}


        pConfig->writeEntry("horizontal orientation",
            view->tabbar->orientation()==Qt::Horizontal?true:false);
        pConfig->writeEntry("sort", view->tabbar->sortByName());
        pConfig->writeEntry("closeOnMiddleClick", view->tabbar->closeOnMiddleClick());
        pConfig->sync();
      }


  return (Kate::PluginConfigPage*)p;
}

void KatePluginTabBarExtension::initConfigPage(KateTabBarExtensionConfigPage *p)
{
  p->pSortAlpha->setChecked(m_views.at(0)->tabbar->sortByName());
  p->pCloseOnMiddleClick->setChecked(m_views.at(0)->tabbar->closeOnMiddleClick());
}

void KatePluginTabBarExtension::applyConfig(KateTabBarExtensionConfigPage *p)
{
  m_views.at(0)->tabbar->setSortByName(p->pSortAlpha->isChecked());
  m_views.at(0)->tabbar->setCloseOnMiddleClick(p->pCloseOnMiddleClick->isChecked());
  // sync m_config in destructor
}
// END KatePluginTabBarExtension

  connect(this, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setOn(bool)));
}

KateTabBarButton::~KateTabBarButton() {}

uint KateTabBarButton::documentNumber()
{
  return myDocID;
}

void KateTabBarButton::setDirty(bool d)
{
  if (d) {

  }
}

void KateTabBarButton::mouseReleaseEvent(TQMouseEvent *e)
{
  // Only handle middle click events when no keyboard modifier is pressed
  if (e->button() == TQt::MidButton && !(e->state() & TQt::KeyButtonMask))
  {
    emit middleButtonPressed(this);
  }
  else
  {
    // Invoke parent handler for unwanted events
    TQPushButton::mouseReleaseEvent(e);
  }
}

TQString KateTabBarButton::fullName() const
{
  if (doc) {

// END KateTabBarButton

// BEGIN KateTabBarExtension
KateTabBarExtension::KateTabBarExtension(Kate::DocumentManager *pDocManager,
    Kate::MainWindow *win, bool bHorizOrientation, bool bSort,
    bool bCloseOnMiddleClick, TQWidget* parent, const char* name, WFlags f)
  : TQWidget(parent, name, f),
    pCurrentTab(0), m_win(win), m_docManager(pDocManager), m_sort(false)
{

      TQT_SLOT(slotDocumentDeleted(uint)));

  setSortByName(bSort);
  setCloseOnMiddleClick(bCloseOnMiddleClick);
}

KateTabBarExtension::~KateTabBarExtension() {}

void KateTabBarExtension::slotMoved(Qt::Orientation o)
{
  // the tabbar moved (top, right, bottom, left or fluently)

  m_orientation = o;
}

Qt::Orientation KateTabBarExtension::orientation() const
{
  return m_orientation;
}

bool KateTabBarExtension::sortByName() const
{
  return m_sort;
}

void KateTabBarExtension::setSortByName(bool sbn)
{
  if (m_sort != sbn) {

  KateTabBarButton* tab = new KateTabBarButton(m_win->viewManager(), doc, this);
  connect(tab, TQT_SIGNAL(myToggled(KateTabBarButton*)),
      TQT_SLOT(slotActivateView(KateTabBarButton*)));
  connect(tab, TQT_SIGNAL(middleButtonPressed(KateTabBarButton*)),
          TQT_SLOT(slotRequestDocClose(KateTabBarButton*)));
  connect(doc, TQT_SIGNAL(nameChanged(Kate::Document *)),
      TQT_SLOT(slotNameChanged(Kate::Document *)));
  connect(doc, TQT_SIGNAL(modStateChanged(Kate::Document *)),

    }
  }
}

void KateTabBarExtension::slotRequestDocClose(KateTabBarButton *tab)
{
  if (closeOnMiddleClick() && tab)
  {
    m_docManager->closeDocument(tab->document());
  }
}
// END KateTabBarExtension

// BEGIN KateTabBarExtensionConfigPage

  TQVBoxLayout* top = new TQVBoxLayout(this, 0,
      KDialogBase::spacingHint());

  TQGroupBox* gb = new TQGroupBox(1, Qt::Horizontal, i18n("Behavior options"),
                                  this, "tab_bar_extension_config_page_layout" );
  gb->setColumnLayout(1, Qt::Vertical);
  gb->setInsideSpacing(KDialogBase::spacingHint());
  pSortAlpha = new TQCheckBox(i18n("Sort files alphabetically"), gb);
  pCloseOnMiddleClick = new TQCheckBox(i18n("Close document on mouse middle click"), gb);

  top->add(gb);
  top->addStretch(1);
//  throw signal changed
  connect(pSortAlpha, TQT_SIGNAL(toggled(bool)), this, TQT_SIGNAL(changed()));
  connect(pCloseOnMiddleClick, TQT_SIGNAL(toggled(bool)), this, TQT_SIGNAL(changed()));

KateTabBarExtensionConfigPage::~KateTabBarExtensionConfigPage() {}

void KateTabBarExtensionConfigPage::apply()
{
    emit configPageApplyRequest( this );
}
// END KateTabBarExtensionConfigPage


Lines 4-10 Link Here

(-)original/tdeaddons/kate/tabbarextension/plugin_katetabbarextension.h (-24 / +62 lines)
4	begin : 2004-04-20	4	begin : 2004-04-20
5	copyright : (C) 2004 by Dominik Haumann	5	copyright : (C) 2004 by Dominik Haumann
6	email : dhdev@gmx.de	6	email : dhdev@gmx.de
7	***************************************************************************/	7	updated : 2013-09-18 by Michele Calgaro
		8	- added "close document on mouse middle click" feature
		9	***************************************************************************/
8		10
9	/***************************************************************************	11	/***************************************************************************
10	This program is free software; you can redistribute it and/or	12	This program is free software; you can redistribute it and/or
Lines 48-54 Link Here
48	class KateTabBarButton;	50	class KateTabBarButton;
49		51
50	/**	52	/**
51	* Same as TQPtrList. Only difference is: overwrite comapreItems() for sorting reason.	53	* Same as TQPtrList. Only difference is: overwrite compareItems() for sorting reason.
52	*/	54	*/
53	class MyPtrList : public TQPtrList <KateTabBarButton>	55	class MyPtrList : public TQPtrList <KateTabBarButton>
54	{	56	{
Lines 61-74 Link Here
61	class KatePluginFactory : public KLibFactory	63	class KatePluginFactory : public KLibFactory
62	{	64	{
63	Q_OBJECT	65	Q_OBJECT
64		66
65		67
66	public:	68	public:
67	KatePluginFactory();	69	KatePluginFactory() { s_instance = new TDEInstance( "kate" ); }
68	virtual ~KatePluginFactory();	70	virtual ~KatePluginFactory() { delete s_instance; }
69		71
70	virtual TQObject* createObject( TQObject* parent = 0, const char* pname = 0,	72	virtual TQObject* createObject(TQObject parent = 0, const char pname = 0,
71	const char* name = TQOBJECT_OBJECT_NAME_STRING, const TQStringList &args = TQStringList() );	73	const char *name = TQOBJECT_OBJECT_NAME_STRING, const TQStringList &args = TQStringList());
72		74
73	private:	75	private:
74	static TDEInstance* s_instance;	76	static TDEInstance* s_instance;
Lines 97-108 Link Here
97	/**	99	/**
98	* standard destructor (emtpy)	100	* standard destructor (emtpy)
99	*/	101	*/
100	~KateTabBarButton();	102	~KateTabBarButton() {}
101		103
102	/**	104	/**
103	* @return the unique document ID	105	* @return the unique document ID
104	*/	106	*/
105	uint documentNumber();	107	uint documentNumber() { return myDocID; }
		108
		109	/**
		110	* @return the document pointer
		111	*/
		112	Kate::Document* document() { return doc; }
106		113
107	/**	114	/**
108	* get the document's full name (eg. main.cpp), used for comparison	115	* get the document's full name (eg. main.cpp), used for comparison
Lines 126-132 Link Here
126	* set text for this tab	133	* set text for this tab
127	* @param newText new text	134	* @param newText new text
128	*/	135	*/
129	virtual void setText( const TQString& newText);	136	virtual void setText(const TQString& newText);
		137
		138	/**
		139	* mouse release event handler to provide middle click functionality
		140	* @param e the mouse event
		141	*/
		142	virtual void mouseReleaseEvent(TQMouseEvent *e);
130		143
131	signals:	144	signals:
132	/**	145	/**
Lines 135-140 Link Here
135	*/	148	*/
136	void myToggled(KateTabBarButton* tab);	149	void myToggled(KateTabBarButton* tab);
137		150
		151	/**
		152	* signal emitted when the middle button is pressed
		153	* @param tab pointer to the button that emitted the signal
		154	*/
		155	void middleButtonPressed(KateTabBarButton* tab);
		156
138	public slots:	157	public slots:
139	/**	158	/**
140	* control the ToggleButton	159	* control the ToggleButton
Lines 168-189 Link Here
168	* @param name name of widget	187	* @param name name of widget
169	* @param f widget flags	188	* @param f widget flags
170	*/	189	*/
171	KateTabBarExtension( Kate::DocumentManager *pDocManager,	190	KateTabBarExtension(Kate::DocumentManager *pDocManager,
172	Kate::MainWindow *win, bool bHorizOrientation, bool bSort,	191	Kate::MainWindow *win, bool bHorizOrientation, bool bSort,
173	TQWidget * parent = 0, const char * name = 0, WFlags f = 0 );	192	bool bCloseOnMiddleClick, TQWidget *parent = 0,
		193	const char *name = 0, WFlags f = 0);
174		194
175	/** standard destructor */	195	/** standard destructor */
176	~KateTabBarExtension();	196	~KateTabBarExtension() {}
177		197
178	/**	198	/**
179	* @return the tabbar's orientation	199	* @return the tabbar's orientation
180	*/	200	*/
181	Qt::Orientation orientation() const;	201	Qt::Orientation orientation() const { return m_orientation; }
182		202
183	/**	203	/**
184	* @return true, when sorting is alphabetically	204	* @return true, when sorting is alphabetically
185	*/	205	*/
186	bool sortByName() const;	206	bool sortByName() const { return m_sort; }
187		207
188	/**	208	/**
189	* set sorting type	209	* set sorting type
Lines 196-201 Link Here
196	*/	216	*/
197	void updateSort();	217	void updateSort();
198		218
		219	/**
		220	* @return true when closing a document with mouse middle click is allowed
		221	*/
		222	bool closeOnMiddleClick() const { return m_closeOnMiddleClick; }
		223
		224	/**
		225	* set flag to enable/disable "close document on mouse middle click" feature
		226	* @param cmc true -> enabled, false -> disabled
		227	*/
		228	void setCloseOnMiddleClick(bool cmc) { m_closeOnMiddleClick = cmc; }
		229
199	public slots:	230	public slots:
200	/**	231	/**
201	* called when a new document is created/loaded	232	* called when a new document is created/loaded
Lines 246-260 Link Here
246	*/	277	*/
247	void slotMoved(Qt::Orientation o);	278	void slotMoved(Qt::Orientation o);
248		279
		280	/**
		281	* called when we want to close the document associated with the tab
		282	* @param tab pointer to the button that represents the active view
		283	*/
		284	void slotRequestDocClose(KateTabBarButton *tab);
		285
249	private:	286	private:
250	KateTabBarButton* pCurrentTab; ///< pointer to the current tab	287	KateTabBarButton* pCurrentTab; ///< pointer to the current tab
251	TQBoxLayout* top; ///< layout that contains all tabs	288	TQBoxLayout* top; ///< layout that contains all tabs
252	Kate::MainWindow* m_win; ///< pointer to the main window	289	Kate::MainWindow* m_win; ///< pointer to the main window
253	Kate::DocumentManager* m_docManager; ///< pointer to the document manager	290	Kate::DocumentManager* m_docManager; ///< pointer to the document manager
254	// TQPtrList <KateTabBarButton> m_tabs; ///< list containing all tabs	291	// TQPtrList <KateTabBarButton> m_tabs; ///< list containing all tabs
255	MyPtrList m_tabs; ///< list containing all tabs	292	MyPtrList m_tabs; ///< list containing all tabs
256	Qt::Orientation m_orientation; ///< save tabbar's orientation	293	Qt::Orientation m_orientation; ///< save tabbar's orientation
257	bool m_sort; ///< how to sort	294	bool m_sort; ///< how to sort
		295	bool m_closeOnMiddleClick; ///< Enable/disable "close document on mouse middle click" feature
258	};	296	};
259		297
260	/**	298	/**
Lines 268-284 Link Here
268	friend class KatePluginTabBarExtension;	306	friend class KatePluginTabBarExtension;
269		307
270	public:	308	public:
271	KateTabBarExtensionConfigPage (TQObject* parent = 0L, TQWidget *parentWidget = 0L);	309	KateTabBarExtensionConfigPage(TQObject* parent = 0L, TQWidget *parentWidget = 0L);
272	~KateTabBarExtensionConfigPage ();	310	~KateTabBarExtensionConfigPage() {}
273		311
274	/**	312	/**
275	* Reimplemented from Kate::PluginConfigPage	313	* Reimplemented from Kate::PluginConfigPage
276	* just emits configPageApplyRequest( this ).	314	* just emits configPageApplyRequest( this ).
277	*/	315	*/
278	virtual void apply();	316	virtual void apply() { emit configPageApplyRequest(this); }
279		317	virtual void reset() {}
280	virtual void reset () { ; }	318	virtual void defaults() {}
281	virtual void defaults () { ; }
282		319
283	signals:	320	signals:
284	/**	321	/**
Lines 293-298 Link Here
293		330
294	private:	331	private:
295	TQCheckBox* pSortAlpha;	332	TQCheckBox* pSortAlpha;
		333	TQCheckBox* pCloseOnMiddleClick;
296	};	334	};
297		335
298	class KatePluginTabBarExtension : public Kate::Plugin, Kate::PluginViewInterface, Kate::PluginConfigInterfaceExtension	336	class KatePluginTabBarExtension : public Kate::Plugin, Kate::PluginViewInterface, Kate::PluginConfigInterfaceExtension
Lines 301-307 Link Here
301		339
302		340
303	public:	341	public:
304	KatePluginTabBarExtension( TQObject* parent = 0, const char* name = 0 );	342	KatePluginTabBarExtension(TQObject* parent = 0, const char* name = 0);
305	virtual ~KatePluginTabBarExtension();	343	virtual ~KatePluginTabBarExtension();
306		344
307	void addView (Kate::MainWindow *win);	345	void addView (Kate::MainWindow *win);
Lines 311-317 Link Here
311	Kate::PluginConfigPage configPage (uint , TQWidget w, const char *name=0);	349	Kate::PluginConfigPage configPage (uint , TQWidget w, const char *name=0);
312	TQString configPageName(uint) const { return i18n("Tab Bar Extension"); }	350	TQString configPageName(uint) const { return i18n("Tab Bar Extension"); }
313	TQString configPageFullName(uint) const { return i18n("Configure Tab Bar Extension"); }	351	TQString configPageFullName(uint) const { return i18n("Configure Tab Bar Extension"); }
314	TQPixmap configPagePixmap (uint number = 0, int size = TDEIcon::SizeSmall) const { return 0L; }	352	TQPixmap configPagePixmap (uint = 0, int = TDEIcon::SizeSmall) const { return 0L; }
315		353
316	public slots:	354	public slots:
317	void applyConfig( KateTabBarExtensionConfigPage* );	355	void applyConfig( KateTabBarExtensionConfigPage* );

Return to bug 1664