Thu Aug 19 1999         

Kicker - a new framework for a KDE desktop panel
---------------------------------------

Matthias Ettrich <ettrich@kde.org>

Hi fellow developers, 

two days ago I started working on a new panel framework, dubbed
kicker. It's design is influenced by the former kpanel ( most
certainly) and by what the Corel engineers have done with it in Corel
Linux. Some similarities to the Gnome panel (which was also influenced
by kpanel) did also probably not happen by accident, I assume.

Kicker will move a bit away from the former design which was very
OS/2-WorkplaceShell and CDE oriented. In some ways it will be more
like recent MS-Windows versions and can for example provide a taskbar
_inside_ the panel (kpanel always had a separate taskbar).

Let me sketch the current early state in both design and
functionality. You'll find a sample screenshot on
http://ettrich.priv.no/kicker.gif
The screenshot uses Mosfet's gold-gradient scheme, btw.

- On both borders, you have the well-known hide/show buttons.

- If you press the mouse on the panel itself, you can drag it around
  to every border of the screen ( left, top, bottom, right ).

- On the left side you'll have the so-called "Item Area". It contains
  the panel buttons (that may be menu buttons or normal buttons) as
  well as applets. All items have a context menu and can be moved
  around freely (not implemented yet). The left button is painted
  raised, because it contained the mouse pointer at the time the shot
  was taken. The kicker/applets/example you find an example applet
  with the interesting name "exampleapplet". Simply run it. It will
  show up in kicker and provide a context menu to move or remove it.
  Kicker keeps track of the applets running and will restart them
  correctly (in either vertical or horizontal mode). Try it by
  dragging the panel to another location. Note: the applet register
  argv[0] as restart command, so you have to start it from either the
  path or with an absolute executable filename. This is no issue,
  since applets will be started from the K-menu anyway.

- The Item area is separated with a splitter from the integrated
  taskbar. With that splitter, every user can individually distribute
  the rare panel space. You can hide all buttons except the K-button
  and have a pure taskbar, for example. Or you can move the splitter
  to the very right and have no taskbar at all.

- If an area becomes too small (the item area or the taskbar), it
  provides two arrow buttons for scrolling. So everything remains
  accessable on all screen resolutions with any number of items or
  tasks.

- Right from the taskbar you'll find the "static" applet areas. The
  applets there are meant to be fix and always visible (on any
  resolution). Of course they can be customized and other applets
  might be added. Currently this area contains the docking applet (the
  screenshot shows knotes docked) and a simple date/time applet. It's
  interesting to know that whenever these applets grow or shrink (for
  example when new dock windows are added), the area will adjust its
  size and readjust the item area and the taskbar.


The biggest missing piece right now is a kpager applet. It is supposed
to be in the static applet area. Vektor (vektor@div8.net) is currently
working on that.

The next steps will be to integrate the great amount work done on
kpanel (mainly by Pietro). Some stuff can simply me moved into kicker,
for example the menu system and the amazing disk navigator. Pietro is
on vacation unfortunately, so if somebody feels like working on this,
go along.

Lots of other things can be done / should be done. Moving buttons and
applets around, for example. Context menus for the taskbar
buttons. DnD between the taskbar buttons and the pager applet. A mini
panel when the panel is hidden? AutoHide/AutoShow (might use some code
from kpanel). etc.

I will leave for a long summer vacation tomorrow, so I cannot
coordinate the efforts. I'll be back in about four weeks.

One more thing about the applets: Applets have a very simple API. It's
defined in libkdeui/kapplet.h.  It doesn't use any fancy CORBA or
dynamic loading stuff yet, but a simple X-communication protocol. This
is meant as an interim solution ( hey, it was only about ten minutes to write) until
we have something real, probably based on CORBA. The most important
things is that we have at least a common abstract class to write
applets with. This class might be ported to some more fancy
communication protocol later.

So you can start writing applets. Preston wants to write a RHAT ticker
applet, someone already has a tiny CD player. We could have an animated
konqi, a URL input window, a applet version of kbiff ..... whatever
you like.

Note that docking is still supported and for many applications the
better choice (like kppp, for example). Applets are great if something
only needs a tiny tiny GUI.

Another thing completely missing in kicker (yet) is support for
different sizes. It should be usable in a very tiny version as well,
similar to the old kpanel. 

So..... hope you like it and hope you keep the code clean. I'm really
looking forward to see how it looks like after my summer
vacation. Originally, I wanted to work on it, but since so many people
wanted to hack on it it as well, I dropped that idea (I won't have
internet access so I would get out of sync too soon ).


Have fun,

Matthias
