/* This file is part of the KDE libraries
Copyright (C) 1997, 1998 Stephan Kulow (coolo@kde.org)
(C) 1997, 1998 Sven Radej (radej@kde.org)
(C) 1997, 1998 Mark Donohoe (donohoe@kde.org)
(C) 1997, 1998 Matthias Ettrich (ettrich@kde.org)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
// $Id: ktoolbar-h.html.in,v 1.1.1.1 2000/02/09 22:28:12 tasin Exp $
// $Log: ktoolbar-h.html.in,v $
// Revision 1.1.1.1 2000/02/09 22:28:12 tasin
// initial import
//
// Revision 1.46.4.1 1999/04/18 18:36:25 radej
// sven: Docs.
//
// Revision 1.46 1998/11/25 13:22:00 radej
// sven: Someone made some private things protected (was it me?).
//
// Revision 1.45 1998/11/21 19:27:20 radej
// sven: doubleClicked signal for buttons.
//
// Revision 1.44 1998/11/11 14:32:11 radej
// sven: *Bars can be made flat by MMB (Like in Netscape, but this works)
//
// Revision 1.43 1998/11/09 00:28:43 radej
// sven: Docs update (more to come)
//
// Revision 1.42 1998/11/06 12:54:54 radej
// sven: radioGroup is in. handle changed again (broken in vertical mode)
//
// Revision 1.41 1998/10/09 12:42:21 radej
// sven: New: (un) highlight sugnals, Autorepeat buttons, button down when
// pressed. kdetest/kwindowtest updated. This is Binary COMPATIBLE.
//
// Revision 1.40 1998/09/15 05:56:47 antlarr
// I've added a setIconText function to change the state of a variable
// in KToolBar
//
// Revision 1.39 1998/09/01 20:22:24 kulow
// I renamed all old qt header files to the new versions. I think, this looks
// nicer (and gives the change in configure a sense :)
//
// Revision 1.38 1998/08/09 14:01:19 radej
// sven: reintroduced makeDisabledPixmap code, and dumped QIconSet. Fixed a bug
// with paletteChange too.
//
// Revision 1.37 1998/08/06 15:39:03 radej
// sven: Popups & delayedPopups. Uses QIconSet. Needs Qt-1.4x
//
// Revision 1.36 1998/06/20 10:57:00 radej
// sven: mispelled something...
//
// Revision 1.35 1998/06/19 13:09:31 radej
// sven: Docs.
//
// Revision 1.34 1998/05/04 16:38:36 radej
// Bugfixes for moving + opaque moving
//
// Revision 1.33 1998/04/28 09:17:49 radej
// New moving and docking BINARY INCOMPATIBLE
//
#ifndef _KTOOLBAR_H
#define _KTOOLBAR_H
#include <qlist.h>
#include <qframe.h>
#include <qpixmap.h>
#include <qpopupmenu.h>
#include <qbutton.h>
#include <qfont.h>
#include <qsize.h>
#include <qintdict.h>
//#include <qiconset.h>
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "kcombo.h"
#include "klined.h"
class KToolBar;
class KToolBoxManager;
#define Item QWidget
enum itemType {
ITEM_LINED = 0,
ITEM_BUTTON = 1,
ITEM_COMBO = 2,
ITEM_FRAME = 3,
ITEM_TOGGLE = 4,
ITEM_ANYWIDGET=5
};
class KToolBarItem
{
public:
KToolBarItem (Item *_item, itemType _type, int _id,
bool _myItem=true);
~KToolBarItem ();
void resize (int w, int h) { item->resize(w, h); };
void move(int x, int y) { item->move(x, y); };
void show () { item->show(); };
void hide () { item->hide(); };
void setEnabled (bool enable) { item->setEnabled(enable); };
bool isEnabled () { return item->isEnabled(); };
int ID() { return id; };
bool isRight () { return right; };
void alignRight (bool flag) { right = flag; };
void autoSize (bool flag) { autoSized = flag; };
bool isAuto () { return autoSized; };
int width() { return item->width(); };
int height() { return item->height(); };
int x() { return item->x(); };
int y() { return item->y(); };
int winId () { return item->winId(); };
Item *getItem() { return item; };
private:
int id;
bool right;
bool autoSized;
Item *item;
itemType type;
bool myItem;
};
/**
* This is internal button for use in KToolBar and...
*/
class KToolBarButton : public QButton
{
Q_OBJECT
public:
KToolBarButton(const QPixmap& pixmap, int id, QWidget *parent,
const char *name=0L, int item_size = 26, const char *txt=0,
bool _mb = false);
KToolBarButton(QWidget *parent=0L, const char *name=0L);
~KToolBarButton() {};
void setEnabled(bool enable);
virtual void setPixmap( const QPixmap & );
virtual void setText ( const char *text);
void on(bool flag);
void toggle();
void beToggle(bool);
bool ImASeparator () {return sep;};
void youreSeparator () {sep = true;};
QPopupMenu *popup () {return myPopup;};
void setPopup (QPopupMenu *p);
void setDelayedPopup (QPopupMenu *p);
void setRadio(bool f);
public slots:
void modeChange();
protected:
void paletteChange(const QPalette &);
void leaveEvent(QEvent *e);
void enterEvent(QEvent *e);
void drawButton(QPainter *p);
bool eventFilter (QObject *o, QEvent *e);
void showMenu();
//void setIconSet (const QPixmap &);
void makeDisabledPixmap();
private:
bool toolBarButton;
bool sep;
QPixmap enabledPixmap;
QPixmap disabledPixmap;
int icontext;
int highlight;
bool raised;
int id;
int _size;
KToolBar *parentWidget;
QString btext;
QFont buttonFont;
QPopupMenu *myPopup;
bool delayPopup;
QTimer *delayTimer;
bool radio;
protected slots:
void ButtonClicked();
void ButtonPressed();
void ButtonReleased();
void ButtonToggled();
void slotDelayTimeout();
signals:
void clicked(int);
void doubleClicked(int);
void pressed(int);
void released(int);
void toggled(int);
void highlighted (int, bool);
};
/**
* KToolBar is a self resizing, floatable widget.
* It is usually managed from KTopLevelWidget, but can be
* used even if you don't use KTopLevelWidget. If you want
* to handle this without KTopLevelWidget, see updateRects .<BR>
* KToolBar can contain buttons Line inputs Combo Boxes, frames, and
* custom widgets.
* Combos, Frames and Lineds, and Widgets can be autosized to full width.
* Any Item can be right aligned, and buttons can be toggle buttons. Item
* height, type of buttons (icon or icon+text), and option for highlighting
* is adjustable on constructor invocation by reading config file.
* Toolbar will reread config-file when it recieves signal
* Kapplication:appearanceChanged.
* Toolbar can float, be dragged from and docked back to parent window.
* It autoresizes itself. This may lead to
* some flickering, but there is no way to solve it (as far as I
* know). <BR>
* You can bind popups and delayed popups to buttons. <BR>
* You normaly use toolbar from subclassed KTopLevelWidget. When
* you create toolbar object, insert items that you want to be in it.
* Items can be inserted or removed ( removeItem() ) later, when toolbar
* is displayed. It will update itself.
* Then set their propperties ( alignItemRight , setItemAutoSized ,
* setToggle ...) After that set the toolbar itself, enable ,setBarPos ...).
* Then simply do addToolbar (toolbar),
* and you're on. See how it's done in kwindowtest.
* @short KDE Toolbar widget
* @author Stephan Kulow <coolo@kde.org> Maintained by Sven Radej <radej@kde.org>
*/
class KToolBar : public QFrame
{
Q_OBJECT
friend class KToolBarButton;
friend class KRadioGroup;
public:
enum BarStatus{Toggle, Show, Hide};
enum BarPosition{Top, Left, Bottom, Right, Floating, Flat};
/**
* Constructor.
* Toolbar will read global-config file for item Size higlight
* option and button type. However, you can pass desired height.
* If you specify height here, config value has no effect.
* Exception is if you set Icontext mode to 3 (icons under text) whic sets
* size to minimum 40 pixels. For setting IconText mode, see
* @ref #setIconText .
* Setting size in constructor is not recomended.
*/
KToolBar(QWidget *parent=0L, const char *name=0L, int _item_size = -1);
/**
* Destructor. If toolbar is floating it will cleanup itself.
*/
virtual ~KToolBar();
/**
* Inserts KButton with pixmap. You should connect to one or more signals in
* KToolBar: @ref #clicked , @ref #pressed , @ref #released ,
* @ref highlighted and
* if toolbar is toggle button (@ref #setToggle ) @ref #toggled . Those
* signals have id of a button that caused the signal.
* If you want to bound an popup to button, see @ref #setButton
* @param index the position of the button. (-1 = at end).
* @return Returns item index
*/
int insertButton(const QPixmap& pixmap, int ID, bool enabled = true,
const char *ToolTipText = 0L, int index=-1 );
/**
* This is the same as above, but with specified signals and
* slots to which this button will be connected. Button emits
* signals pressed, clicked and released, and
* if toolbar is toggle button ( @ref #setToggle ) @ref #toggled .
* You can add more signals with @ref #addConnection .
* @return Returns item index
*/
int insertButton(const QPixmap& pixmap, int ID, const char *signal,
const QObject *receiver, const char *slot,
bool enabled = true,
const char *tooltiptext = 0L, int index=-1 );
/**
* This inserts a button with popupmenu. Button will have small
* trialngle. You have to connect to popup's signals. The
* signals pressed, released, clikced or doubleClicked are NOT emmited by
* this button (see @ref #setDelayedPopup for that).
* You can add custom popups which inherit @ref QPopupMenu to get popups
* with tables, drawings etc. Just don't fiddle with events there.
*/
int insertButton(const QPixmap& pixmap, int id, QPopupMenu *popup,
bool enabled, const char *_text, int index=-1);
/**
* Inserts a KLined. You have to specify signals and slots to
* which KLined will be connected. KLined has all slots QLineEdit
* has, plus signals @ref KLined::completion and @ref KLined::rotation
* KLined can be set to autoresize itself to full free width
* in toolbar, that is to last right aligned item. For that,
* toolbar must be set to full width (which it is by default).
* @see #setFullWidth
* @see #setItemAutoSized
* @see KLined
* @return Returns item index
*/
int insertLined (const char *text, int ID,
const char *signal,
const QObject *receiver, const char *slot,
bool enabled = true,
const char *toolTipText = 0L, int size = 70, int index =-1);
/**
* Inserts KComboBox with list. Can be writable, but cannot contain pixmaps. By
* default inserting policy is AtBottom, i.e. typed items are placed at the bottom
* of the list. Can be autosized
* KCombo is almost the same thing as QComboBox.
* @see #setFullWidth
* @see #setItemAutoSized
* @see KCombo
* @return Returns item index
*/
int insertCombo (QStrList *list, int id, bool writable,
const char *signal, QObject *recevier,
const char *slot, bool enabled=true,
const char *tooltiptext=0L,
int size=70, int index=-1,
KCombo::Policy policy = KCombo::AtBottom);
/**
* Inserts KCombo with text. The rest is the same as above.
* @see #setItemAutoSized
* @see KCombo
* @return Returns item index
*/
int insertCombo (const char *text, int id, bool writable,
const char *signal, QObject *recevier,
const char *slot, bool enabled=true,
const char *tooltiptext=0L,
int size=70, int index=-1,
KCombo::Policy policy = KCombo::AtBottom);
/**
* Insert separator
*/
int insertSeparator(int index=-1);
/**
* This function is deprecated and will be removed. Use @ref #insertWidget
* to insert anything.
* Inserts frame with specified width. You can get
* pointer to this frame with @ref #getFrame
* Frame can be autosized to full width.
* @see #setItemAutoSized
* @return Returns item index
*/
int insertFrame(int id, int width, int index =-1);
/**
* Insert a user defined widget. Widget must have a QWidget for
* base class.
* Widget can be autosized to full width. If you forget about it, you
* can get pointer to this widget with @ref #getWidget .
* @see #setItemAutoSized
* @return Returns item index
*/
int insertWidget(int id, int width, QWidget *_widget, int index=-1);
/**
* This adds connection to items. Therefore it is important that you
* know id of particular item. Nothing happens if you miss id.
*/
void addConnection (int id, const char *signal,
const QObject *receiver, const char *slot);
/**
* Enables/disables item.
*/
void setItemEnabled( int id, bool enabled );
/**
* Sets button pixmap.
* Can be used while button is visible.
*/
void setButtonPixmap( int id, const QPixmap& _pixmap );
/**
* Sets delayed popup to a button. Delayed popup is what you see in
* netscape's Previous&next buttons: if you click them you go back,
* or forth. If you press them long enough, you get a history-menu.
* This is exactly what we do here. <BR>
* You will insert normal button with connection (or use signals from
* toolbar):
* <pre>
* bar->insertButton(pixmap, id, const SIGNAL(clicked ()), this,
* SLOT (slotClick()), true, "click or wait for popup");
* </pre> And then add a delayed popup:
* <pre>
* bar->setDelayedPopup (id, historyPopup); </pre>
*
* Don't add delayed popups to buttons which have normal popups.
*
* You may add popups wich are derived from QPopupMenu. You may
* add popups that are already in menu bar or are submenus of other popups.
*/
void setDelayedPopup (int id , QPopupMenu *_popup);
/**
* Makes a button autorepeat button. Toggle, buttons with menu or
* delayed menu cannot be autorepeat. More, you can and will receive
* only signals clicked, and not pressed or released.
* When user presses this buton, you will receive signal clicked,
* and if button is still pressed after some time, more clicks
* in some interval. Since this uses @ref QButton::setAutoRepeat ,
* I don't know how much is 'some'.
*/
void setAutoRepeat (int id, bool flag=true);
/**
* Makes button a toggle button if flag is true
*/
void setToggle (int id, bool flag = true);
/**
* If button is toggle (@ref #setToggle must be called first)
* button state will be toggled. This will also cause toolbar to
* emit signal @ref #toggled wit parameter id. You must connect to
* this signal, or use @ref #addConnection to connect directly to
* button-signal toggled.
*/
void toggleButton (int id);
/**
* If button is toggle (@ref #setToggle must be called first)
* this will set him to state flag. This will also emit signal
* #ref toggled . <BR>
* @see #setToggle
*/
void setButton (int id, bool flag);
/**
* Returns true if button is on, false if button is off.
* If button is not a toggle button returns false
* @see #setToggle
*/
bool isButtonOn (int id);
/**
* Sets text in Lined.
* Cursor is set at end of text.
*/
void setLinedText (int id, const char *text);
/**
* Returns Lined text.
* If you want to store this text, you have to deep-copy it somwhere.
*/
const char *getLinedText (int id);
/**
* Inserts text in combo id with at position index.
*/
void insertComboItem (int id, const char *text, int index);
/**
* Inserts list in combo id at position index
*/
void insertComboList (int id, QStrList *list, int index);
/**
* Removes item index from Combo id.
*/
void removeComboItem (int id, int index);
/**
* Sets item index to be current item in Combo id.
*/
void setCurrentComboItem (int id, int index);
/**
* Changes item index in Combo id to text.
* index = -1 means current item (one displayed in the button).
*/
void changeComboItem (int id, const char *text, int index=-1);
/**
* Clears combo id.
* Does not delete it or hide it.
*/
void clearCombo (int id);
/**
* Returns text of item index from Combo id.
* index = -1 means current item
*/
const char *getComboItem (int id, int index=-1);
/**
* This returns pointer to Combo. Example:
* <pre>
* KCombo *combo = toolbar->getCombo(combo_id);
* </pre>
* That way you can get access to other public methods
* that @ref KCombo provides. @ref KCombo is KDE enhancement
* of @ref QComboBox . KCombo inherits QComboBox, so you can
* use pointer to QComboBox too.
*/
KCombo * getCombo(int id);
/**
* This returns pointer to KToolBarLined. Example:
* <pre>
* KLined * lined = toolbar->getKTollBarLined(lined_id);
* </pre>
* That way you can get access to other public methods
* that @ref KLined provides. @ref KLined is the same thing
* as @ref QLineEdit plus completion signals.
*/
KLined * getLined (int id);
/**
* This returns a pointer to KToolBarButton. Example:
* <pre>
* KToolBarButton * button = toolbar->getButton(button_id);
* </pre>
* That way you can get access to other public methods
* that @ref KToolBarButton provides. Using of this method is not
* recomended.
*/
KToolBarButton * getButton (int id);
/**
* Alignes item right.
* This works only if toolbar is set to full width.
* @see #setFullWidth
*/
void alignItemRight (int id, bool right = true);
/**
* This function is deprecated and might be removed. Use @ref #insertWidget
* and @ref #getWidget instead.<br>
* Returns pointer to inserted frame. Wrong ids are not tested.
* Example:
* <pre>
* QFrame *frame = toolbar->getframe (frameid);
* </pre>
* You can do with this frame whatever you want,
* except change its height (hardcoded). If you change its width
* you will probbably have to call toolbar->@ref #updateRects (true)
* @see QFrame
* @see #updateRects
*/
QFrame * getFrame (int id);
/**
* Returns pointer to inserted widget. Wrong ids are not tested.
* You can do with this whatever you want,
* except change its height (hardcoded). If you change its width
* you will probbably have to call toolbar->@ref #updateRects (true)
* @see QWidget
* @see #updateRects
*/
QWidget *getWidget (int id);
/**
* Sets item autosized. This works only if toolbar is set to full width.
* ONLY ONE item can be autosized, and it has to be
* the last left-aligned item. Items that come after this must be right
* aligned. Items that can be right aligned are Lineds, Frames, Widgets and
* Combos. Auto sized item will resize itself whenever toolbar geometry
* changes, to last right-aligned item (or till end of toolbar if there
* are no right aligned items
* @see #setFullWidth
* @see #alignItemRight
*/
void setItemAutoSized (int id, bool yes = true);
/**
* Removes item id.
* Item is deleted. Toolbar is redrawn after it.
*/
void removeItem (int id);
/**
* Hides item.
*/
void hideItem (int id);
/**
* shows item.
*/
void showItem (int id);
/**
* Sets toolbar to full parent width (or to value set by setMaxWidth).
* You have to call this function if you want to have right aligned items or
* autosized item. <BR>
* The toolbar is set to full width by default.
* @see #alignItemRight
* @see #setItemAutoSized
*/
void setFullWidth(bool flag = true); // Top and Bottom pos only
/**
* Enables or disables moving of toolbar.
*/
void enableMoving(bool flag = true);
/**
* Sets position of toolbar. This cannot be used to set toolbar flat. For
* That, use @ref setFlat .
* @see #BarPosition
*/
void setBarPos (BarPosition bpos);
/**
* Returns position of toolbar
*/
BarPosition barPos() {return position;};
/**
* This shows, hides, or toggles toolbar. If toolbar floats,
* hiding means minimizing. Warning: kwm will not show minimized toolbar
* on taskbar. Therefore hiding means hiding.
* @see #BarStatus
*/
bool enable(BarStatus stat);
/**
* Sets maximal height of vertical (Right or Left) toolbar. You normaly
* do not have to call it, since it's called from
* @ref KTopLevelWidget#updateRects
* If you reimplement @ref KTopLevelWidget#resizeEvent or
* KTopLevelWidget#updateRects,
* be sure to call this function with maximal height toolbar can have.
* In 0xFE cases out of 0xFF you don't need to use this function.
* @see #updateRects
*/
void setMaxHeight (int h); // Set max height for vertical toolbars
/**
* Sets maximal width of horizontal (top or bottom) toolbar. This works
* only for horizontal toolbars (at Top or Bottom), and has no effect
* otherwise. Has no effect when toolbar is floating.
*/
void setMaxWidth (int dw);
/**
* Sets title for toolbar when it floats. Titles are however not (yet)
* visible. You can't change toolbar's title while it's floating.
*/
void setTitle (const char *_title) {title = _title;};
/**
* Enables or disables floating.
* Floating is enabled by default.
* This only disables menu entry Floating in popup menu, so
* toolbar can still be moved by @ref #setBarPos or by dragging.
* This function is obsolete and do not use it. If you want to make
* toolbar static use @ref enableMoving
*/
void enableFloating (bool arrrrrrgh);
/**
* Sets the kind of painting for buttons between : 0 (only icons),
* 1 (icon and text, text is left from icons), 2 (only text),
* and 3 (icons and text, text is under icons).
*/
void setIconText(int it);
/**
* Redraw toolbar and resize it if resize is true.
* You normaly don't have to call it, since it's called from
* @ref KTopLevelWidget#updateRects or from resizeEvent. You can call it
* if you manualy change width of inserted frame, or if you wish to force
* toolbar to recalculate itself. <BR>
* You don't want to fiddle with this.
* @ref KtopLevelWidget works closely with toolbar. If you want to
* subclass KTopLevelWidget to change its resize policy, hear this: <BR>
* <BR>
* resizeEvent() in KTopLevelWidget just calls updateRects, which handles
* children sizes. Call updateRects when you're done with your things. <BR>
* <BR>
* If you want to handle everything yourself:<BR>
* <BR>
* KToolBar manages itself by calling toolbar->@ref #updateRects (true).
* It will autosize itself, but won't move itself.
* You have to do the moving. <BR>
* First setup & move anything that is above toolbars (menus...). Then
* setup statusbars and other horizontal things on bottom. Then loop through
* all HORIZONTAL toolbars, call their updateRects(true), _then_ take their
* size, an move them (note that they size themselves according to parent
* width()). After you have looped through HORIZONTAL toolbars, calculate
* the maximum height that vertical toolbars may have (this is your free
* area height). Then loop through vertical toolbars,
* @ref #setMaxHeight (calculated_max_height) on them,
* call their updateRects(true), and _then_ move them to their locations.
* In 0xFE cases out of 0xFF you don't need to use this function.
* @see KtopLevelWidget#updateRects
*/
void updateRects(bool resize = false);
/**
* Returns minimal width for top-level window, so that toolbar
* has only one row.
*/
QSize sizeHint();
/**
* This method switches flat/unflat mode. Carefull: might not work
* If toolbar is floating.
*/
void setFlat (bool flag);
signals:
/**
* Emits when button id is clicked.
*/
void clicked(int id);
/**
* Emits when button id is double clicked. Note: you will always
* recive two @ref #clicked , @ref #pressed and @ref #released signals.
* There is no way to avoid it - at least no easy way.
* If you need to resolve this all you can do is set up timers
* which waits for @ref QApplication::doubleClickInterval to expire.
* if in that time you don't get this signal, you may belive that
* button was only clicked.
* And please note that butons with popup menus do not emit this signal,
* but those with delayed popup do.
*/
void doubleClicked (int id);
/**
* Emits when button id is pressed.
*/
void pressed(int);
/**
* Emits when button id is released.
*/
void released(int);
/**
* Emits when toggle button changes state
* Emits also if you change state
* with @ref #setButton or @ref #toggleButton
* If you make a button normal again, with
* @ref #setToggle (false), this signal won't
* be emited.
*/
void toggled(int);
/**
* This signal is emmited when item id gets highlighted/unhighlighted
* (i.e when mouse enters/exits). Note that this signal is emited from
* all buttons (normal, disabled and toggle) even when there is no visible
* change in buttons (meaning, buttons do not raise when mouse enters).
* Parameter isHighlighted is true when mouse enters and false when
* mouse exits.
*/
void highlighted(int id, bool isHighlighted);
/**
* Emits when toolbar changes its position, or when
* item is removed from toolbar. This is normaly connected to
* @ref KTopLevelWidget::updateRects.
* If you subclass @ref KTopLevelWidget and reimplement
* @ref KTopLevelWidget::resizeEvent or
* @ref KTopLevelWidget::updateRects, be sure to connect to
* this signal. You can connect this signal to slot that
* doesn't take parameter.
* @see #updateRects
*/
void moved( BarPosition );
/**
* Internal. This signal is emited when toolbar detects changing of
* following parameters:
* highlighting, button-size, button-mode. This signal is
* internal, aimed to buttons.
*/
void modechange ();
private:
QList<KToolBarItem> items;
const char *title;
bool fullWidth;
BarPosition position;
bool moving;
QWidget *Parent;
int toolbarWidth;
int toolbarHeight;
int oldX;
int oldY;
int oldWFlags;
int max_width;
int max_height;
BarPosition lastPosition; // Where was I last time I was?
BarPosition movePos; // Where was I moved to?
bool mouseEntered; // Did the mouse touch the cheese?
bool horizontal; // Do I stand tall?
bool localResize; // Am I trying to understand recursion?
bool wasFullWidth; // Was I loong when I was?
bool haveAutoSized; // Do I have a problem?
KToolBoxManager *mgr;
protected:
QPopupMenu *context;
void drawContents ( QPainter *);
void resizeEvent(QResizeEvent*);
void paintEvent(QPaintEvent*);
void closeEvent (QCloseEvent *);
void mousePressEvent ( QMouseEvent *);
void init();
void layoutVertical ();
void layoutHorizontal ();
void leaveEvent (QEvent *e);
private slots:
void ButtonClicked(int);
void ButtonDblClicked( int id );
void ButtonPressed(int);
void ButtonReleased(int);
void ButtonToggled(int);
void ButtonHighlighted(int,bool);
void ContextCallback(int);
void slotReadConfig ();
void slotHotSpot (int i);
protected:
void mouseMoveEvent(QMouseEvent*);
void mouseReleaseEvent ( QMouseEvent *);
private:
QPoint pointerOffset;
QPoint parentOffset;
int item_size; // normal: 26
int icon_text; // 1 = icon+text, 0 icon+tooltip
bool highlight; // yes/no
QSize szh; // Size for sizeHint
bool fixed_size; // do not change the toolbar size
bool transparent; // type of moving
};
/*************************************************************************
* KRadioGroup *
*************************************************************************/
/**
* KRadioGroup is class for group of radio butons in toolbar.
* Take toggle buttons which you already inserted into toolbar,
* create KRadioGroup instance and add them here.
* All buttons will emit signals toggled (bool) (or you can
* use sitgnal @ref #toggled (int id) from toolbar). When one button is set
* down, all others are unset. All buttons emit signals - those who
* "go down" and those who "go up".
*
* @author Sven Radej <radej@kde.org>
* @short Class for group of radio butons in toolbar.
*/
class KRadioGroup : public QObject
{
Q_OBJECT
public:
/**
* Constructor. Parent must be @ref KToolBar .
*/
KRadioGroup (QWidget *_parent, const char *_name=0);
/**
* Destructor.
*/
~KRadioGroup () {};
/**
* Adds button to group. Button cannot be unset by mouse clicks (you
* must press some other button tounset this one)
*/
void addButton (int id);
/**
* Removes button from group, making it again toggle button (i.e.
* You can unset it with mouse).
*/
void removeButton (int id);
public slots:
/**
* Internal - nothing for you here.
*/
void slotToggled (int);
private:
QIntDict<KToolBarButton> buttons;
KToolBar *tb;
};
#endif
Documentation generated by tasin@cd1 on Die Nov 30 17:32:00 CET 1999