Source Code (Use browser search to find items of interest.)

kiconedit'KIconEdit (./kdegraphics/kiconedit/kiconedit.h:119)

class KIconEdit : public KTMainWindow
{
    Q_OBJECT
public:
  KIconEdit( const QString &xpm = QString::null, const char *name = "kiconedit");
  KIconEdit( const QImage image, const char *name = "kiconedit");
  ~KIconEdit();

  virtual QSize sizeHint() const;

signals:

public slots:
  virtual void saveProperties(KConfig*);
  virtual void readProperties(KConfig*);
  void saveGoingDownStatus();
  void unsaved(bool flag);

protected slots:
  void addColors(uint, uint*);
  void addColor(uint);
  void slotNewWin();
  void slotNewWin(const char *url = 0);
  void slotNew();
  void slotOpen();
  void slotClose();
  void slotQuit();
  void slotSave();
  void slotSaveAs();
  void slotPrint();
  void slotView(int);
  void slotCopy();
  void slotCut();
  void slotPaste();
  void slotClear();
  void slotImage(int id);
  void slotSaved();
  void slotSelectAll();
  void slotOpenRecent(int id);
  void slotConfigure(int);
  void slotTools(int);

  void slotUpdateStatusColors(uint);
  void slotUpdateStatusColors(uint, uint*);
  void slotUpdateStatusPos(int, int);
  void slotUpdateStatusSize(int, int);
  void slotClearStatusMessage();
  void slotUpdateStatusMessage(const char *);
  void slotUpdateStatusName(const char *);
  void slotUpdateStatusScaling(int, bool);
  void slotUpdatePaste(bool);
  void slotUpdateCopy(bool);
  void slotOpenBlank(const QSize);

  void slotQDropEvent( QDropEvent* );
  void slotQDragLeaveEvent( QDragLeaveEvent* );
  void slotQDragEnterEvent( QDragEnterEvent* );

protected:
  void init();
  bool setupMenuBar();
  bool setupToolBar();
  bool setupDrawToolBar();
  bool setupPaletteToolBar();
  bool setupStatusBar();
  bool setupWhatsThis();
  virtual bool queryClose();
  virtual void resizeEvent(QResizeEvent*);
  void writeConfig();
  void toggleTool(int id);
  void addRecent(const char *file);
  void updateMenuAccel();

  KIconTemplateContainer *icontemplates;

  QLabel *syslabel, *customlabel;
  Preview *preview;
  KSysColors *syscolors;
  KCustomColors *customcolors;;

  KMenuBar *menubar;
  KToolBar *toolbar, *drawtoolbar, *palettetoolbar;
  KStatusBar *statusbar;
  QPopupMenu *edit, *file, *view, *image, *help, *tools, *options, *zoom, *recent, *select;
  KIconEditGrid *grid;
  QTimer *msgtimer;
  KGridView *gridview;
  KIconEditIcon *icon;
  KDropSite *dropsite;
  KDragSource *dragbutton;
  KIconEditProperties *kiprops;
  QWhatsThis *what;
  QImage img;
  QPrinter *printer;
};

kiconedit'KIconEdit::KIconEdit() (./kdegraphics/kiconedit/kiconedit.cpp:34)

KIconEdit::KIconEdit(const QImage image, const char *name)
 : KTMainWindow(name)
{
  init();
  img = image;
  img.detach();
  grid->load(&img);
  preview->setPixmap(grid->pixmap());
}

kiconedit'KIconEdit::KIconEdit() (./kdegraphics/kiconedit/kiconedit.cpp:44)

KIconEdit::KIconEdit(const QString &xpm, const char *name)
 : KTMainWindow(name)
{
  init();
  icon->open(&img, xpm);
  preview->setPixmap(grid->pixmap());
}

kiconedit'KIconEdit::init() (./kdegraphics/kiconedit/kiconedit.cpp:52)

void KIconEdit::init()
{
  setCaption(kapp->caption());

  printer = new QPrinter;
  CHECK_PTR(printer);

  kiprops = new KIconEditProperties(this);
  CHECK_PTR(kiprops);
  Properties *pprops = props(this);

  menubar = 0L;
  toolbar = 0L;
  drawtoolbar = 0L;
  palettetoolbar = 0L;
  statusbar = 0L;
  what = 0L;

  msgtimer = new QTimer(this);
  CHECK_PTR(msgtimer);
  connect( msgtimer, SIGNAL(timeout()), SLOT(slotClearStatusMessage()));

  icontemplates = new KIconTemplateContainer;
  CHECK_PTR(icontemplates);

  gridview = new KGridView(&img, this); //viewport->viewport()); //KIconEditView(this);
  CHECK_PTR(gridview);
  gridview->setShowRulers(pprops->showrulers);

  grid = gridview->grid();

  grid->setGrid(pprops->showgrid);
  grid->setCellSize(pprops->gridscaling);

  icon = new KIconEditIcon(this, &grid->image());
  CHECK_PTR(icon);

  setAcceptDrops(true);

  dropsite = new KDropSite( grid );
  CHECK_PTR(dropsite);
  connect( dropsite, SIGNAL( dropAction( QDropEvent*) ), 
    this, SLOT( slotQDropEvent( QDropEvent*) ) );

  connect( dropsite, SIGNAL( dragLeave( QDragLeaveEvent*) ), 
    this, SLOT( slotQDragLeaveEvent( QDragLeaveEvent*) ) );

  connect( dropsite, SIGNAL( dragEnter( QDragEnterEvent*) ), 
    this, SLOT( slotQDragEnterEvent( QDragEnterEvent*) ) );

  setupStatusBar();
  setupMenuBar();
  setupToolBar();
  setupDrawToolBar();
  setupPaletteToolBar();
  setupWhatsThis();

  connect( icon, SIGNAL( saved()),
           SLOT(slotSaved()));
  connect( icon, SIGNAL( loaded(QImage *)),
     grid, SLOT(load(QImage *)));
  connect( icon, SIGNAL(opennewwin(const char *)),
           SLOT(slotNewWin(const char *)));
  connect(icon, SIGNAL(newname(const char *)),
           SLOT( slotUpdateStatusName(const char *)));
  connect(icon, SIGNAL(newmessage(const char *)),
           SLOT( slotUpdateStatusMessage(const char *)));

  connect( syscolors, SIGNAL( newcolor(uint)),
     grid, SLOT(setColorSelection(uint)));
  connect( customcolors, SIGNAL( newcolor(uint)),
     grid, SLOT(setColorSelection(uint)));

  connect( grid, SIGNAL( changed(const QPixmap &)),
    preview, SLOT(setPixmap(const QPixmap &)));
  connect( grid, SIGNAL( addingcolor(uint) ),
           SLOT(addColor(uint)));
  connect( grid, SIGNAL( colorschanged(uint, uint*) ),
           SLOT(addColors(uint, uint*)));

  connect(grid, SIGNAL(sizechanged(int, int)),
           SLOT( slotUpdateStatusSize(int, int)));
  connect(grid, SIGNAL(poschanged(int, int)),
           SLOT( slotUpdateStatusPos(int, int)));
  connect(grid, SIGNAL(scalingchanged(int, bool)),
           SLOT( slotUpdateStatusScaling(int, bool)));
  connect( grid, SIGNAL( addingcolor(uint) ),
           SLOT(slotUpdateStatusColors(uint)));
  connect(grid, SIGNAL(colorschanged(uint, uint*)),
           SLOT( slotUpdateStatusColors(uint, uint*)));
  connect(grid, SIGNAL(newmessage(const char *)),
           SLOT( slotUpdateStatusMessage(const char *)));
  connect(grid, SIGNAL(clipboarddata(bool)),
           SLOT( slotUpdatePaste(bool)));
  connect(grid, SIGNAL(selecteddata(bool)),
           SLOT( slotUpdateCopy(bool)));

  debug("Setting tool");
  slotTools(ID_DRAW_FIND);
  debug("Updating statusbar");
  slotUpdateStatusSize(grid->cols(), grid->rows());
  slotUpdateStatusScaling(grid->scaling(), true);
  if(icon->url().length())
    slotUpdateStatusName(icon->url().data());
  slotUpdateCopy(false);
  uint *c = 0, n = 0;
  n = grid->getColors(c);
  slotUpdateStatusColors(n, c);
  setView(gridview);

  if((pprops->winwidth > 0) && (pprops->winheight > 0))
    resize( pprops->winwidth, pprops->winheight );

  debug("Showing");
  show();
}

kiconedit'KIconEdit::~KIconEdit() (./kdegraphics/kiconedit/kiconedit.cpp:169)

KIconEdit::~KIconEdit()
{
/*  the following should be destructed by the QObject/QWidget destructor
    if(l)
      delete l;
    l = 0L; 
    if(grid)
      delete grid;
    grid = 0L; 
    if(toolsw)
      delete toolsw;
    toolsw = 0L; 
    if(newicon)
      delete newicon;
    newicon = 0L; 
*/
    if(printer)
      delete printer;
    if(what)
      delete what;
    what = 0L;
    if(toolbar)
      delete toolbar;
    toolbar = 0L; 
    if(drawtoolbar)
      delete drawtoolbar;
    drawtoolbar = 0L; 
    if(menubar)
      delete menubar;
    menubar = 0L; 
    if(statusbar)
      delete statusbar;
    statusbar = 0L; 
    if(icontemplates)
      delete icontemplates;
    icontemplates = 0L;
    delete file;
    delete edit;
    delete view;
    delete tools;
    delete options;
    delete help;
    delete select;
    delete recent;
    delete zoom;
}

kiconedit'KIconEdit::queryClose() (./kdegraphics/kiconedit/kiconedit.cpp:216)

bool KIconEdit::queryClose()
{
  bool cancel = false;
  if (grid->isModified()) 
  {
    //KWM::activate(winId());
    int r = KMessageBox::warningYesNoCancel(this,
		i18n("The current file has been modified.\nDo you want to save it?"));
    switch(r)
    {
      case 0:
        icon->save(&grid->image());
        //grid->save(grid->drawPath());
        break;
      case 1:
        break;
      case 2:
        cancel = true;
        break;
      default:
        break;
    }
  }
  if(!cancel)
  {
    writeConfig();
    icon->cleanup();
  }
  return (!cancel);
}

kiconedit'KIconEdit::resizeEvent() (./kdegraphics/kiconedit/kiconedit.cpp:247)

void KIconEdit::resizeEvent( QResizeEvent * )
{
  // save size of the application window
  //debug("KIconEdit::resizeEvent()");
  props(this)->winwidth = geometry().width();
  props(this)->winheight = geometry().height();

  updateRects();
  //viewport->updateScrollBars();
}

kiconedit'KIconEdit::unsaved() (./kdegraphics/kiconedit/kiconedit.cpp:258)

void KIconEdit::unsaved( bool /*flag*/ )
{
#warning fix session management
    //setUnsavedData(flag);
}

kiconedit'KIconEdit::saveGoingDownStatus() (./kdegraphics/kiconedit/kiconedit.cpp:264)

void KIconEdit::saveGoingDownStatus()
{
  debug("KIconEdit::saveGoingDownStatus");
  if( grid->isModified() )
  {
    debug("Saving backup for modified file %s", icon->url().data());
    icon->saveBackup(&grid->image());
  }
  else
    icon->cleanup();
  debug("KIconEdit::saveGoingDownStatus - done");
}

// this is for exit by request of the session manager

kiconedit'KIconEdit::saveProperties() (./kdegraphics/kiconedit/kiconedit.cpp:278)

void KIconEdit::saveProperties(KConfig *config )
{
  debug("KIconEdit::saveProperties");
  config->writeEntry("Name", icon->url());
  saveGoingDownStatus();
}

// this is for instances opened by the session manager

kiconedit'KIconEdit::readProperties() (./kdegraphics/kiconedit/kiconedit.cpp:286)

void KIconEdit::readProperties(KConfig *config)
{
  debug("KIconEdit::readProperties");
  QString entry = config->readEntry("Name", ""); // no default
  if (entry.isEmpty())
    return;
  icon->open(&grid->image(), entry.data());
}

// this is for normal exits or request from "Options->Save options".

kiconedit'KIconEdit::writeConfig() (./kdegraphics/kiconedit/kiconedit.cpp:296)

void KIconEdit::writeConfig()
{
/*
  Properties *pprops = props(this);
  
  pprops->maintoolbarstat = toolbar->isVisible();
  pprops->drawtoolbarstat = drawtoolbar->isVisible();
  pprops->statusbarstat = statusbar->isVisible();

  pprops->maintoolbarpos = toolbar->barPos();
  pprops->drawtoolbarpos = drawtoolbar->barPos();

  //pprops->showgrid = grid->hasGrid();
  //pprops->gridscaling = grid->cellSize();
*/
  KIconEditProperties::saveProperties(this);

}

kiconedit'KIconEdit::sizeHint() (./kdegraphics/kiconedit/kiconedit.cpp:315)

QSize KIconEdit::sizeHint() const
{
  if(gridview)
    return gridview->sizeHint();
  else
    return QSize(-1, -1);
}

kiconedit'KIconEdit::setupMenuBar() (./kdegraphics/kiconedit/kiconedit.cpp:323)

bool KIconEdit::setupMenuBar()
{
  debug("setupMenuBar");

  Properties *pprops = props(this);

  if(!menubar)
  {
    menubar = new KMenuBar(this);
    CHECK_PTR(menubar);
    setMenu(menubar);
    pprops->menubar = menubar;
  }

  KAccel *keys = pprops->keys; // = new KAccel( this ); 
  CHECK_PTR(keys);

  keys->connectItem( KStdAccel::New, this, SLOT(slotNew()) );
  keys->connectItem( KStdAccel::Save , this, SLOT(slotSave()) );
  keys->connectItem( KStdAccel::Quit, this, SLOT(slotQuit()) );
  keys->connectItem( KStdAccel::Cut , this, SLOT(slotCut()) );
  keys->connectItem( KStdAccel::Copy , this, SLOT(slotCopy()) );
  keys->connectItem( KStdAccel::Paste , this, SLOT(slotPaste()) );
  keys->connectItem( KStdAccel::Open , this, SLOT(slotOpen()) );
  keys->connectItem( KStdAccel::Close , this, SLOT(slotClose()) );
  keys->connectItem( KStdAccel::Print , this, SLOT(slotPrint()) );
  keys->insertItem(i18n("Select All"),   "Select All",   CTRL+Key_A);
  keys->connectItem( "Select All", this, SLOT(slotSelectAll()) );
  keys->readSettings();

  debug("setupMenuBar - read settings");


  recent = new QPopupMenu;
  CHECK_PTR(recent);
  connect( recent, SIGNAL(activated(int)), SLOT(slotOpenRecent(int)));
  for(uint i = 0; i < pprops->recentlist->count(); i++)
    recent->insertItem(pprops->recentlist->at(i));

  int id;

  file = new QPopupMenu;
  CHECK_PTR(file);

  file->insertItem(BarIcon("newwin"), i18n("New &Window"), ID_FILE_NEWWIN);
  file->connectItem(ID_FILE_NEWWIN, this, SLOT(slotNewWin()));

  file->insertSeparator();

  id = file->insertItem(BarIcon("filenew"), i18n("&New..."), ID_FILE_NEWFILE);
  file->connectItem(ID_FILE_NEWFILE, this, SLOT(slotNew()));

  id = file->insertItem(BarIcon("fileopen"), i18n("&Open..."), ID_FILE_OPEN);
  file->connectItem(ID_FILE_OPEN, this, SLOT(slotOpen()));

  file->insertItem(i18n("Open recent"), recent, ID_FILE_RECENT);
  //file->setItemEnabled(ID_FILE_RECENT, false);

  file->insertSeparator();

  id = file->insertItem(BarIcon("filefloppy"), i18n("&Save"), ID_FILE_SAVE);
  file->connectItem(ID_FILE_SAVE, this, SLOT(slotSave()));

  file->insertItem(i18n("S&ave as..."), ID_FILE_SAVEAS);
  file->connectItem(ID_FILE_SAVEAS, this, SLOT(slotSaveAs()));

  file->insertSeparator();

  id = file->insertItem(BarIcon("fileprint"), i18n("&Print..."), ID_FILE_PRINT);
  file->connectItem(ID_FILE_PRINT, this, SLOT(slotPrint()));

  file->insertSeparator();

  id = file->insertItem(BarIcon("fileclose"), i18n("&Close"), ID_FILE_CLOSE);
  file->connectItem(ID_FILE_CLOSE, this, SLOT(slotClose()));

  id = file->insertItem(i18n("&Exit"), ID_FILE_QUIT);
  file->connectItem(ID_FILE_QUIT, this, SLOT(slotQuit()));

  menubar->insertItem(i18n("&File"), file);

  edit = new QPopupMenu;
  CHECK_PTR(edit);

  id = edit->insertItem(BarIcon("editcut"), i18n("Cu&t"), ID_EDIT_CUT);
  edit->connectItem(ID_EDIT_CUT, this, SLOT(slotCut()));

  id = edit->insertItem(BarIcon("editcopy"), i18n("&Copy"), ID_EDIT_COPY);
  edit->connectItem(ID_EDIT_COPY, this, SLOT(slotCopy()));

  id = edit->insertItem(BarIcon("editpaste"), i18n("&Paste"), ID_EDIT_PASTE);
  edit->connectItem(ID_EDIT_PASTE, this, SLOT(slotPaste()));

  id = edit->insertItem(i18n("Paste as &new"), ID_EDIT_PASTE_AS_NEW);
  edit->connectItem(ID_EDIT_PASTE_AS_NEW, grid, SLOT(editPasteAsNew()));

  id = edit->insertItem(i18n("Clea&r"),  this, SLOT(slotClear()));

  edit->insertSeparator();

  id = edit->insertItem(i18n("Select &all"), ID_EDIT_SELECT_ALL);
  edit->connectItem(ID_EDIT_SELECT_ALL, this, SLOT(slotSelectAll()));

  menubar->insertItem(i18n("&Edit"), edit);

  zoom = new QPopupMenu;
  CHECK_PTR(zoom);
  id = zoom->insertItem(i18n("1:1"), ID_VIEW_ZOOM_1TO1);
  id = zoom->insertItem(i18n("1:5"), ID_VIEW_ZOOM_1TO5);
  id = zoom->insertItem(i18n("1:10"), ID_VIEW_ZOOM_1TO10);
  connect( zoom, SIGNAL(activated(int)), SLOT(slotView(int)));

  view = new QPopupMenu;
  CHECK_PTR(view);
  id = view->insertItem(BarIcon("viewmag+"), i18n("Zoom &in"), ID_VIEW_ZOOM_IN);
  id = view->insertItem(BarIcon("viewmag-"), i18n("Zoom &out"), ID_VIEW_ZOOM_OUT);
  id = view->insertItem(BarIcon("viewmag"), i18n("Zoom factor"), zoom);
  connect( view, SIGNAL(activated(int)), SLOT(slotView(int)));
  menubar->insertItem(i18n("&View"), view);

  image = new QPopupMenu;
  CHECK_PTR(image);
#if QT_VERSION >= 140
  id = image->insertItem(BarIcon("transform"), i18n("&Resize"), ID_IMAGE_RESIZE);
#endif
  id = image->insertItem(BarIcon("grayscale"), i18n("&GrayScale"), ID_IMAGE_GRAYSCALE);
  
  //id = image->insertItem(BarIcon("kdepalette"), i18n("&Map to KDE palette"), ID_IMAGE_MAPTOKDE);
  
  connect( image, SIGNAL(activated(int)), SLOT(slotImage(int)));
  menubar->insertItem(i18n("&Icon"), image);

  tools = new QPopupMenu;
  CHECK_PTR(tools);
  tools->insertItem(BarIcon("paintbrush"), i18n("Freehand"), ID_DRAW_FREEHAND);
  tools->insertItem(BarIcon("rectangle"), i18n("Rectangle"), ID_DRAW_RECT);
  tools->insertItem(BarIcon("filledrectangle"), i18n("Filled rectangle"), ID_DRAW_RECT_FILL);
  tools->insertItem(BarIcon("circle"), i18n("Circle"), ID_DRAW_CIRCLE);
  tools->insertItem(BarIcon("filledcircle"), i18n("Filled circle"), ID_DRAW_CIRCLE_FILL);
  tools->insertItem(BarIcon("ellipse"), i18n("Ellipse"), ID_DRAW_ELLIPSE);
  tools->insertItem(BarIcon("filledellipse"), i18n("Filled ellipse"), ID_DRAW_ELLIPSE_FILL);
  tools->insertItem(BarIcon("spraycan"), i18n("Spray"), ID_DRAW_SPRAY);
  tools->insertItem(BarIcon("flood"), i18n("Flood fill"), ID_DRAW_FILL);
  tools->insertItem(BarIcon("line"), i18n("Line"), ID_DRAW_LINE);
  tools->insertItem(BarIcon("eraser"), i18n("Eraser (Transparent)"), ID_DRAW_ERASE);
  //tools->insertSeparator();
  connect( tools, SIGNAL(activated(int)), SLOT(slotTools(int)));
  menubar->insertItem(i18n("&Tools"), tools);

  options = new QPopupMenu;
  CHECK_PTR(options);
  id = options->insertItem(i18n("&Configure"), ID_OPTIONS_CONFIGURE);
  options->insertSeparator();
  options->insertItem(i18n("Toggle &Grid"), ID_OPTIONS_TOGGLE_GRID);
  if(pprops->showgrid)
    options->setItemChecked(ID_OPTIONS_TOGGLE_GRID, true);
  options->insertItem(i18n("Toggle &toolbar"), ID_OPTIONS_TOGGLE_TOOL1);
  if(pprops->maintoolbarstat)
    options->setItemChecked(ID_OPTIONS_TOGGLE_TOOL1, true);
  options->insertItem(i18n("Toggle &drawing tools"), ID_OPTIONS_TOGGLE_TOOL2);
  if(pprops->drawtoolbarstat)
    options->setItemChecked(ID_OPTIONS_TOGGLE_TOOL2, true);
  options->insertItem(i18n("Toggle &statusbar"), ID_OPTIONS_TOGGLE_STATS);
  if(pprops->statusbarstat)
    options->setItemChecked(ID_OPTIONS_TOGGLE_STATS, true);
  options->insertSeparator();
  options->insertItem(BarIcon("filefloppy"), i18n("&Save options"), ID_OPTIONS_SAVE);
  connect( options, SIGNAL(activated(int)), SLOT(slotConfigure(int)));
  menubar->insertItem(i18n("&Options"), options);

  menubar->insertSeparator();

  QString about;
  about.sprintf(i18n("KDE Icon Editor\n\n"
                     "A graphics drawing program for creating\n"
                     "icons using the KDE icon palette\n\n"
                     "Copyright 1998 by Thomas Tanghus\n"
                     "tanghus@kde.org\n"
                     "http://w1.1358.telia.com/~u135800018"));

  help = helpMenu(about.data());
  menubar->insertItem(i18n("&Help"), help);

  updateMenuAccel();
  menubar->show();
  //connect( menubar, SIGNAL(activated(int)), SLOT(slotActions(int)));

  debug("setupMenuBar - done");
  return true;
}

kiconedit'KIconEdit::updateMenuAccel() (./kdegraphics/kiconedit/kiconedit.cpp:514)

void KIconEdit::updateMenuAccel()
{
  KAccel *keys = props(this)->keys; // = new KAccel( this ); 
  CHECK_PTR(keys);

  keys->changeMenuAccel(file, ID_FILE_NEWFILE, KStdAccel::New); 
  keys->changeMenuAccel(file, ID_FILE_OPEN, KStdAccel::Open); 
  keys->changeMenuAccel(file, ID_FILE_SAVE, KStdAccel::Save); 
  keys->changeMenuAccel(file, ID_FILE_PRINT, KStdAccel::Print); 
  keys->changeMenuAccel(file, ID_FILE_CLOSE, KStdAccel::Close); 
  keys->changeMenuAccel(file, ID_FILE_QUIT, KStdAccel::Quit); 

  keys->changeMenuAccel(edit, ID_EDIT_CUT, KStdAccel::Cut); 
  keys->changeMenuAccel(edit, ID_EDIT_COPY, KStdAccel::Copy); 
  keys->changeMenuAccel(edit, ID_EDIT_PASTE, KStdAccel::Paste); 
  keys->changeMenuAccel(edit, ID_EDIT_SELECT_ALL, "Select All"); 

}

kiconedit'KIconEdit::setupToolBar() (./kdegraphics/kiconedit/kiconedit.cpp:533)

bool KIconEdit::setupToolBar()
{
  Properties *pprops = props(this);
  debug("setupToolBar");

  toolbar = new KToolBar(this);
  CHECK_PTR(toolbar);
  addToolBar(toolbar);
  pprops->maintoolbar = toolbar;

  QWidget *btwhat = (QWidget*)what->whatsThisButton(toolbar);
  what = new QWhatsThis(btwhat);
  QToolTip::add(btwhat, i18n("What is ...?"));

  dragbutton = new KDragSource("image/x-xpm", grid, SLOT(getImage(QImage*)), toolbar);
  dragbutton->setPixmap(BarIcon("image"));
  QToolTip::add(dragbutton, i18n("Drag source"));

  toolbar->insertWidget(-1, 22, dragbutton);
  toolbar->insertSeparator();
  toolbar->insertButton(BarIcon("filenew"), ID_FILE_NEWFILE,
         SIGNAL(clicked()), this, SLOT(slotNew()), TRUE, i18n("New File"));
  toolbar->insertButton(BarIcon("fileopen"),ID_FILE_OPEN,
         SIGNAL(clicked()), this, SLOT(slotOpen()), TRUE, i18n("Open a file"));
  toolbar->insertButton(BarIcon("filefloppy"), ID_FILE_SAVE,
         SIGNAL(clicked()), this, SLOT(slotSave()), TRUE, i18n("Save the file"));
  toolbar->insertSeparator();
  toolbar->insertButton(BarIcon("fileprint"),ID_FILE_PRINT,
         SIGNAL(clicked()), this, SLOT(slotPrint()), TRUE, i18n("Print icon"));
  toolbar->insertSeparator();
  toolbar->insertButton(BarIcon("editcut"),ID_EDIT_CUT,
         SIGNAL(clicked()), this, SLOT(slotCut()), TRUE, i18n("Cut"));
  toolbar->insertButton(BarIcon("editcopy"),ID_EDIT_COPY,
         SIGNAL(clicked()), this, SLOT(slotCopy()), TRUE, i18n("Copy"));
  toolbar->insertButton(BarIcon("editpaste"),ID_EDIT_PASTE,
         SIGNAL(clicked()), this, SLOT(slotPaste()), TRUE, i18n("Paste"));

  select = new QPopupMenu;
  CHECK_PTR(select);
  select->insertItem(BarIcon("selectrect"), ID_SELECT_RECT);
  select->insertItem(BarIcon("selectcircle"), ID_SELECT_CIRCLE);
  connect( select, SIGNAL(activated(int)), SLOT(slotTools(int)));

  toolbar->insertButton(BarIcon("areaselect"), ID_SELECT, select, true, i18n("Select area"));
  //drawtoolbar->setToggle(ID_DRAW_SELECT, true);

  toolbar->insertSeparator();
#if QT_VERSION >= 140
  toolbar->insertButton(BarIcon("transform"),ID_IMAGE_RESIZE, TRUE, 
			  i18n("Resize"));
#endif
  toolbar->insertButton(BarIcon("grayscale"),ID_IMAGE_GRAYSCALE, TRUE, 
			  i18n("GrayScale"));
/*
  toolbar->insertButton(BarIcon("kdepalette"),ID_IMAGE_MAPTOKDE, TRUE, 
			  i18n("To KDE palette"));
*/
  toolbar->insertSeparator();
  toolbar->insertButton(BarIcon("viewmag-"),ID_VIEW_ZOOM_OUT, TRUE, 
			  i18n("Zoom out"));
  toolbar->setDelayedPopup(ID_VIEW_ZOOM_OUT, zoom);
  toolbar->insertButton(BarIcon("viewmag+"),ID_VIEW_ZOOM_IN, TRUE, 
			  i18n("Zoom in"));
  toolbar->setDelayedPopup(ID_VIEW_ZOOM_IN, zoom);
  toolbar->insertSeparator();
  toolbar->insertButton(BarIcon("grid"),ID_OPTIONS_TOGGLE_GRID, TRUE, 
			  i18n("Toggle grid"));
  toolbar->setToggle(ID_OPTIONS_TOGGLE_GRID, true);
  if(pprops->showgrid)
    ((KToolBarButton*)toolbar->getButton(ID_OPTIONS_TOGGLE_GRID))->on(true);

  toolbar->insertSeparator();

  toolbar->insertWidget(ID_HELP_WHATSTHIS, btwhat->sizeHint().width(), btwhat);

  toolbar->insertButton(BarIcon("newwin"),ID_FILE_NEWWIN,
         SIGNAL(clicked()), this, SLOT(slotNewWin()), TRUE,
                          i18n("New Window"));
  toolbar->alignItemRight( ID_FILE_NEWWIN, true);
    
  toolbar->setIconText((KToolBar::IconText) pprops->maintoolbartext);
  toolbar->setBarPos(pprops->maintoolbarpos);
  if(pprops->maintoolbarstat)
    toolbar->enable(KToolBar::Show);
  else
    toolbar->enable(KToolBar::Hide);
  //toolbar->show();
  connect( toolbar, SIGNAL(clicked(int)), SLOT(slotView(int)));
  connect( toolbar, SIGNAL(clicked(int)), SLOT(slotImage(int)));
  connect( toolbar, SIGNAL(clicked(int)), SLOT(slotConfigure(int)));

  debug("setupToolBar - done");
  return true;
}

kiconedit'KIconEdit::setupDrawToolBar() (./kdegraphics/kiconedit/kiconedit.cpp:628)

bool KIconEdit::setupDrawToolBar()
{
  debug("setupDrawToolBar");
  Properties *pprops = props(this);
  drawtoolbar = new KToolBar(this);
  CHECK_PTR(drawtoolbar);
  addToolBar(drawtoolbar);
  pprops->drawtoolbar = drawtoolbar;
  drawtoolbar->setFullWidth();

  drawtoolbar->insertButton(BarIcon("pointer"), ID_DRAW_FIND, TRUE, i18n("Find pixel"));
  drawtoolbar->setToggle(ID_DRAW_FIND, true);
  drawtoolbar->insertButton(BarIcon("paintbrush"), ID_DRAW_FREEHAND, TRUE, i18n("Draw freehand"));
  drawtoolbar->setToggle(ID_DRAW_FREEHAND, true);

  drawtoolbar->insertButton(BarIcon("line"), ID_DRAW_LINE, TRUE, i18n("Draw line"));
  drawtoolbar->setToggle(ID_DRAW_LINE, true);
  drawtoolbar->insertButton(BarIcon("rectangle"),ID_DRAW_RECT, TRUE, i18n("Draw rectangle"));
  drawtoolbar->setToggle(ID_DRAW_RECT, true);
  drawtoolbar->insertButton(BarIcon("filledrectangle"),ID_DRAW_RECT_FILL, TRUE, i18n("Draw filled rectangle"));
  drawtoolbar->setToggle(ID_DRAW_RECT_FILL, true);
  drawtoolbar->insertButton(BarIcon("circle"),ID_DRAW_CIRCLE, TRUE, i18n("Draw circle"));
  drawtoolbar->setToggle(ID_DRAW_CIRCLE, true);
  drawtoolbar->insertButton(BarIcon("filledcircle"),ID_DRAW_CIRCLE_FILL, TRUE, i18n("Draw filled circle"));
  drawtoolbar->setToggle(ID_DRAW_CIRCLE_FILL, true);
  drawtoolbar->insertButton(BarIcon("ellipse"),ID_DRAW_ELLIPSE, TRUE, i18n("Draw ellipse"));
  drawtoolbar->setToggle(ID_DRAW_ELLIPSE, true);
  drawtoolbar->insertButton(BarIcon("filledellipse"),ID_DRAW_ELLIPSE_FILL, TRUE, i18n("Draw filled ellipse"));
  drawtoolbar->setToggle(ID_DRAW_ELLIPSE_FILL, true);
  drawtoolbar->insertButton(BarIcon("spraycan"),ID_DRAW_SPRAY, TRUE, i18n("Spray"));
  drawtoolbar->setToggle(ID_DRAW_SPRAY, true);
  drawtoolbar->insertButton(BarIcon("flood"),ID_DRAW_FILL, TRUE, i18n("Flood fill"));
  drawtoolbar->setToggle(ID_DRAW_FILL, true);
  drawtoolbar->setToggle(ID_DRAW_SPRAY, true);
  drawtoolbar->insertButton(BarIcon("eraser"),ID_DRAW_ERASE, TRUE, i18n("Erase"));
  drawtoolbar->setToggle(ID_DRAW_ERASE, true);
    
  drawtoolbar->setIconText((KToolBar::IconText) pprops->drawtoolbartext);
  drawtoolbar->setBarPos(pprops->drawtoolbarpos);
  if(pprops->drawtoolbarstat)
    drawtoolbar->enable(KToolBar::Show);
  else
    drawtoolbar->enable(KToolBar::Hide);
  //drawtoolbar->show();
  connect( drawtoolbar, SIGNAL(clicked(int)), SLOT(slotTools(int)));

  debug("setupDrawToolBar - done");
  return true;
}

kiconedit'KIconEdit::setupPaletteToolBar() (./kdegraphics/kiconedit/kiconedit.cpp:678)

bool KIconEdit::setupPaletteToolBar()
{
  //Properties *pprops = props(this);

  QWidget *w = new QWidget(this);
  QBoxLayout *ml = new QVBoxLayout(w);
  QLabel *l = new QLabel(i18n("System Colors"), w);
  //l->setFixedSize(l->sizeHint());
  syscolors = new KSysColors(w);
  //syscolors->setFixedSize(syscolors->width(), syscolors->height());
  ml->addWidget(l);
  ml->addWidget(syscolors);

  int ow = w->sizeHint().width();
  int iw = syscolors->width();

  palettetoolbar = new KToolBar(this, 0, ow+8);
  CHECK_PTR(palettetoolbar);
  addToolBar(palettetoolbar);
  palettetoolbar->enable(KToolBar::Show);
  palettetoolbar->setBarPos(KToolBar::Right);

  w->recreate(palettetoolbar, 0, QPoint(0, 0));

  preview = new Preview(palettetoolbar);
  preview->setFrameStyle(QFrame::Panel|QFrame::Sunken);
  //preview->setFixedSize(iw, 60);

  palettetoolbar->insertWidget(ID_PREVIEW, iw, preview);
  palettetoolbar->insertSeparator();
  palettetoolbar->insertWidget(ID_SYSTEM_COLORS, iw, w);
  palettetoolbar->insertSeparator();

  w = new QWidget(palettetoolbar);
  ml = new QVBoxLayout(w);
  l = new QLabel(i18n("Custom Colors"), w);
  //l->setFixedSize(l->sizeHint());
  customcolors = new KCustomColors(w);
  //customcolors->setFixedSize(iw, customcolors->height());
  ml->addWidget(l);
  ml->addWidget(customcolors);

  palettetoolbar->insertWidget(ID_CUSTOM_COLORS, iw, w);

  return true;
}

kiconedit'KIconEdit::setupStatusBar() (./kdegraphics/kiconedit/kiconedit.cpp:725)

bool KIconEdit::setupStatusBar()
{
  Properties *pprops = props(this);
  statusbar = new KStatusBar(this);
  CHECK_PTR(statusbar);
  setStatusBar(statusbar);
  pprops->statusbar = statusbar;

  statusbar->insertItem("    -1, -1    ", 0);
  statusbar->insertItem("   32 x 32   ", 1);
  statusbar->insertItem(" 1:1000 ", 2);
  statusbar->insertItem("Colors:       ", 3);
  statusbar->insertItem("", 4);

  if(pprops->statusbarstat)
    statusbar->show();
  else
    statusbar->hide();
  return true;
}

kiconedit'KIconEdit::setupWhatsThis() (./kdegraphics/kiconedit/kiconedit.cpp:746)

bool KIconEdit::setupWhatsThis()
{ // QWhatsThis *what is created in setupToolbar

  debug("setupWhatsThis");

  // Create help for the custom widgets

  QString str = i18n("Icon draw grid\n\nThe icon grid is the area where you draw the icons.\n"
                 "You can zoom in and out using the magnifying glasses on the toolbar.\n"
                 "(Tip: Hold the magnify button down for a few seconds to zoom to a predefined scale");
  what->add(grid, str);

  str = i18n("Rulers\n\nThis is a visual represantation of the current cursor position");
  what->add(gridview->hruler(), str.data());
  what->add(gridview->vruler(), str.data());

  str = i18n("Statusbar\n\nThe statusbar gives information of the status "
             "of the current icon. The fields are:\n\n"
             "\t- Cursor position\n"
             "\t- Size\n"
             "\t- Zoom factor\n"
             "\t- Number of colors\n"
             "\t- Application messages");
  what->add(statusbar, str.data());

  str = i18n("Preview\n\nThis is a 1:1 preview of the current icon");
  what->add(preview, str.data());

  str = i18n("System colors\n\nHere you can select colors from the KDE Icon Palette.");
  what->add(syscolors, str.data());

  str = i18n("Custom colors\n\nHere you can build a palette of custom colors.\n"
             "Just double-click on a box to edit the color");
  what->add(customcolors, str.data());

  // Create help for the main toolbar

  str = i18n("New\n\nCreate a new icon either from a template or by specifying the size");
  what->add(toolbar->getButton(ID_FILE_NEWFILE), str.data());

  str = i18n("Open\n\nOpen an existing icon");
  what->add(toolbar->getButton(ID_FILE_OPEN), str.data());

  str = i18n("Save\n\nSave the current icon");
  what->add(toolbar->getButton(ID_FILE_SAVE), str.data());

  str = i18n("Print\n\nOpens a print dialog to let you print the current icon."
             " (Doesn't realy work as expected");
  what->add(toolbar->getButton(ID_FILE_PRINT), str.data());

  str = i18n("Cut\n\nCut the current selection out of the icon\n\n"
             "(Tip: You can make both rectangular and circular selections)");
  what->add(toolbar->getButton(ID_EDIT_CUT), str.data());

  str = i18n("Copy\n\nCopy the current selection out of the icon\n\n"
             "(Tip: You can make both rectangular and circular selections)");
  what->add(toolbar->getButton(ID_EDIT_COPY), str.data());

  str = i18n("Paste\n\nPaste the contents of the clipboard into the current icon.\n\n"
             "If the contents is larger than the current icon you can paste it"
             " in a new window.\n\n"
             "(Tip: Select \"Paste transparent pixels\" in the configuration dialog"
             " if you also want to paste transparent)");
  what->add(toolbar->getButton(ID_EDIT_PASTE), str.data());

  str = i18n("Select\n\nSelect a section of the icon using the mouse.\n\n"
             "(Tip: You can make both rectangular and circular selections)");
  what->add(toolbar->getButton(ID_SELECT), str.data());

  str = i18n("Resize\n\nSmoothly resizes the icon while trying to preserve the contents");
  what->add(toolbar->getButton(ID_IMAGE_RESIZE), str.data());

  str = i18n("Gray scale\n\nGray scale the current icon.\n"
             "(Warning: The result is likely to contain colors not in the icon palette");
  what->add(toolbar->getButton(ID_IMAGE_GRAYSCALE), str.data());

  str = i18n("Zoom out\n\nZoom out by one.\n\n"
             "(Tip: Hold the button down for a few seconds to zoom to a predefined scale");
  what->add(toolbar->getButton(ID_VIEW_ZOOM_OUT), str.data());

  str = i18n("Zoom in\n\nZoom in by one.\n\n"
             "(Tip: Hold the button down for a few seconds to zoom to a predefined scale");
  what->add(toolbar->getButton(ID_VIEW_ZOOM_IN), str.data());

  str = i18n("Toggle grid\n\nToggles the grid in the icon edit grid on/off");
  what->add(toolbar->getButton(ID_OPTIONS_TOGGLE_GRID), str.data());

  str = i18n("New window\n\nOpens a new Icon Editor window.");
  what->add(toolbar->getButton(ID_FILE_NEWWIN), str.data());

  str = i18n("Whats is...?\n\nWell since you're reading this I guess you found out ;-)");
  what->add(toolbar->getButton(ID_HELP_WHATSTHIS), str.data());

  str = i18n("Drag source\n\nFrom this button you can drag out a copy of the current icon"
             " and drop it on a drop enabled window, eg. another Icon Editor.\n\n"
             "(Note: The drag source uses the QT XDND protocol which is not"
             " yet standard in KDE)");
  what->add(dragbutton, str.data());

  // Setup help for the tools toolbar

  str = i18n("Free hand\n\nDraw non-linear lines");
  what->add(drawtoolbar->getButton(ID_DRAW_FREEHAND), str.data());

  str = i18n("Flood fill\n\nFill adjoining pixels with the same color with the current color");
  what->add(drawtoolbar->getButton(ID_DRAW_FILL), str.data());

  str = i18n("Rectangle\n\nDraw a rectangle");
  what->add(drawtoolbar->getButton(ID_DRAW_RECT), str.data());

  str = i18n("Filled rectangle\n\nDraw a filled rectangle");
  what->add(drawtoolbar->getButton(ID_DRAW_RECT_FILL), str.data());

  str = i18n("Circle\n\nDraw a circle");
  what->add(drawtoolbar->getButton(ID_DRAW_CIRCLE), str.data());

  str = i18n("Filled circle\n\nDraw a filled circle");
  what->add(drawtoolbar->getButton(ID_DRAW_CIRCLE_FILL), str.data());

  str = i18n("Ellipse\n\nDraw an ellipse");
  what->add(drawtoolbar->getButton(ID_DRAW_ELLIPSE), str.data());

  str = i18n("Filled ellipse\n\nDraw a filled ellipse");
  what->add(drawtoolbar->getButton(ID_DRAW_ELLIPSE_FILL), str.data());

  str = i18n("Line\n\nDraw a straight line vertically, horizontically or in 45 dgr. angles");
  what->add(drawtoolbar->getButton(ID_DRAW_LINE), str.data());

  str = i18n("Spray\n\nDraw scattered pixels in the current color");
  what->add(drawtoolbar->getButton(ID_DRAW_SPRAY), str.data());

  str = i18n("Find\n\nThe color of the pixel clicked on will be the current drawcolor");
  what->add(drawtoolbar->getButton(ID_DRAW_FIND), str.data());

  str = i18n("Erase\n\nErase pixels. Set the pixels to be transparent\n\n"
             "(Tip: If you want to draw transparent with a different tool"
             " then first click on \"Erase\" then on the tool you want to use)");
  what->add(drawtoolbar->getButton(ID_DRAW_ERASE), str.data());

  debug("setupWhatsThis - done");
  return true;
}

kiconedit'KIconEdit::addRecent() (./kdegraphics/kiconedit/kiconedit.cpp:889)

void KIconEdit::addRecent(const char *filename)
{
  QString str = filename;
  //debug("addRecent - checking %s", filename);
  Properties *pprops = props(this);
  if(str.isEmpty() || pprops->recentlist->contains(filename))
    return;
  //debug("addRecent - adding %s", filename);

  if( pprops->recentlist->count() < 5)
    pprops->recentlist->insert(0,filename);
  else
  {
    pprops->recentlist->remove(4);
    pprops->recentlist->insert(0,filename);
  }

  recent->clear();

  for ( int i = 0 ;i < (int)pprops->recentlist->count(); i++)
    recent->insertItem(pprops->recentlist->at(i));

  file->setItemEnabled(ID_FILE_RECENT, true);
  //debug("addRecent - done");
}

kiconedit'KIconEdit::toggleTool() (./kdegraphics/kiconedit/kiconedit.cpp:915)

void KIconEdit::toggleTool(int id)
{
  for(int i = ID_DRAW_FREEHAND; i <= ID_DRAW_ERASE; i++)
  {
    if(i != id)
    {
      if(tools->isItemChecked(i))
        tools->setItemChecked(i, false);
      if(drawtoolbar->isButtonOn(i));
        drawtoolbar->setButton(i, false);
        //((KToolBarButton*)drawtoolbar->getButton(i))->on(false);
    }
    else
    {
      tools->setItemChecked(i, true);
      if(!drawtoolbar->isButtonOn(i));
        //((KToolBarButton*)drawtoolbar->getButton(i))->on(true);
        drawtoolbar->setButton(i, true);
    }
  }
}

kiconedit'KIconEdit::addColors() (./kdegraphics/kiconedit/kiconeditslots.cpp:37)

void KIconEdit::addColors(uint n, uint *c)
{
  //debug("KIconTools::addColors()");
  customcolors->clear();
  for(uint i = 0; i < n; i++)
    addColor(c[i]);
}

kiconedit'KIconEdit::addColor() (./kdegraphics/kiconedit/kiconeditslots.cpp:45)

void KIconEdit::addColor(uint color)
{
  //debug("KIconTools::addColor()");
  if(!syscolors->contains(color))
    customcolors->addColor(color);
}

kiconedit'KIconEdit::slotNewWin() (./kdegraphics/kiconedit/kiconeditslots.cpp:52)

void KIconEdit::slotNewWin()
{
  slotNewWin((const char*)0);
}

kiconedit'KIconEdit::slotNewWin() (./kdegraphics/kiconedit/kiconeditslots.cpp:57)

void KIconEdit::slotNewWin(const char *url)
{
  debug("KIconEdit::openNewWin() - %s", url);
  KIconEdit *w = new KIconEdit(url, "kiconedit");
  CHECK_PTR(w);
}

kiconedit'KIconEdit::slotNew() (./kdegraphics/kiconedit/kiconeditslots.cpp:64)

void KIconEdit::slotNew()
{
  bool cancel = false;
  if (grid->isModified()) 
  {
    int r = KMessageBox::warningYesNoCancel(this, 
      i18n("The current file has been modified.\nDo you want to save it?"));
    switch(r)
    {
      case 0:
        icon->save(&grid->image());
        break;
      case 1:
        break;
      case 2:
        cancel = true;
        break;
      default:
        break;
    }
  }
  if(!cancel)
  {
    KNewIcon newicon(this);
    if(newicon.exec())
    {
      int r = newicon.openStyle();
      if(r == KNewIcon::Blank)
      {
        grid->editClear();
        const QSize s = newicon.templateSize();
        debug("Size: %d x %d", s.width(), s.height());
        grid->setSize(s);
        grid->setModified(false);
        icon->cleanup();
      }
      else if(r == KNewIcon::Template)
      {
        QString str = newicon.templatePath();
        icon->open(&grid->image(), str.data());
        icon->cleanup();
      }
    }
  }
}

kiconedit'KIconEdit::slotOpen() (./kdegraphics/kiconedit/kiconeditslots.cpp:110)

void KIconEdit::slotOpen()
{
  bool cancel = false;
  
  if( grid->isModified() ) 
  {
    int r = KMessageBox::warningYesNoCancel(this, i18n("The current file has been modified.\nDo you want to save it?"));
    switch( r )
    {
      case 0:
        icon->save( &grid->image() );
        break;
      case 1:
        break;
      case 2:
        cancel = true;
        break;
      default:
        break;
    }
  }
  if( !cancel )
    icon->promptForFile( &grid->image() );
}

kiconedit'KIconEdit::slotClose() (./kdegraphics/kiconedit/kiconeditslots.cpp:135)

void KIconEdit::slotClose()
{
  close();
}

kiconedit'KIconEdit::slotQuit() (./kdegraphics/kiconedit/kiconeditslots.cpp:140)

void KIconEdit::slotQuit()
{
  debug("KIconEdit: Closing %u windows", memberList->count());
  KIconEdit *ki = 0L;
  while((ki = (KIconEdit*)memberList->getFirst()) != 0)
  {
    CHECK_PTR(ki);
    memberList->getFirst()->close();
  }
}

kiconedit'KIconEdit::slotSave() (./kdegraphics/kiconedit/kiconeditslots.cpp:151)

void KIconEdit::slotSave()
{
  debug("KIconEdit: Saving %s", icon->url().data());
  icon->save(&grid->image());
}

kiconedit'KIconEdit::slotSaveAs() (./kdegraphics/kiconedit/kiconeditslots.cpp:157)

void KIconEdit::slotSaveAs()
{
  debug("KIconEdit: Saving %s", icon->url().data());
  icon->saveAs(&grid->image());
}

kiconedit'KIconEdit::slotPrint() (./kdegraphics/kiconedit/kiconeditslots.cpp:163)

void KIconEdit::slotPrint()
{
  file->setItemEnabled(ID_FILE_PRINT, false);
  toolbar->setItemEnabled(ID_FILE_PRINT, false);

  if ( QPrintDialog::getPrinterSetup(printer) )
  {
    int margin = 10, yPos = 0;
    printer->setCreator("KDE Icon Editor");
    QPainter p;
    p.begin( printer );
    QFontMetrics fm = p.fontMetrics();
    QPaintDeviceMetrics metrics( printer ); // need width/height

    p.drawText( margin, margin + yPos, metrics.width(), fm.lineSpacing(),
                        ExpandTabs | DontClip, icon->url().data() );
    yPos = yPos + fm.lineSpacing();
    p.drawPixmap( margin, margin + yPos, grid->pixmap() );
    p.end();
  }
  file->setItemEnabled(ID_FILE_PRINT, true);
  toolbar->setItemEnabled(ID_FILE_PRINT, true);
}

kiconedit'KIconEdit::slotView() (./kdegraphics/kiconedit/kiconeditslots.cpp:187)

void KIconEdit::slotView( int id )
{
  switch(id)
  {
    case ID_VIEW_ZOOM_1TO1:
      //slotUpdateStatusScaling(1, false);
      grid->zoomTo(1);
      //slotUpdateStatusScaling(1, true);
      toolbar->setItemEnabled(ID_VIEW_ZOOM_OUT, false);
      view->setItemEnabled(ID_VIEW_ZOOM_OUT, false);
      break;
    case ID_VIEW_ZOOM_1TO5:
      //slotUpdateStatusScaling(5, false);
      grid->zoomTo(5);
      //slotUpdateStatusScaling(5, true);
      break;
    case ID_VIEW_ZOOM_1TO10:
      //slotUpdateStatusScaling(10, false);
      grid->zoomTo(10);
      //slotUpdateStatusScaling(10, true);
      break;
    case ID_VIEW_ZOOM_OUT:
      if(!grid->zoom(Out))
      {
        toolbar->setItemEnabled(ID_VIEW_ZOOM_OUT, false);
        view->setItemEnabled(ID_VIEW_ZOOM_OUT, false);
      }
      break;
    case ID_VIEW_ZOOM_IN:
      grid->zoom(In);
      toolbar->setItemEnabled(ID_VIEW_ZOOM_OUT, true);
      view->setItemEnabled(ID_VIEW_ZOOM_OUT, true);
      break;
    default:
      break;
  }
}

kiconedit'KIconEdit::slotCopy() (./kdegraphics/kiconedit/kiconeditslots.cpp:225)

void KIconEdit::slotCopy()
{
  grid->editCopy();
}

kiconedit'KIconEdit::slotCut() (./kdegraphics/kiconedit/kiconeditslots.cpp:230)

void KIconEdit::slotCut()
{
  grid->editCopy(true);
}

kiconedit'KIconEdit::slotPaste() (./kdegraphics/kiconedit/kiconeditslots.cpp:235)

void KIconEdit::slotPaste()
{
  toggleTool(ID_DRAW_FIND);
  grid->setTool(KIconEditGrid::Find);
  grid->editPaste();
}

kiconedit'KIconEdit::slotClear() (./kdegraphics/kiconedit/kiconeditslots.cpp:242)

void KIconEdit::slotClear()
{
  grid->editClear();
}

kiconedit'KIconEdit::slotSelectAll() (./kdegraphics/kiconedit/kiconeditslots.cpp:247)

void KIconEdit::slotSelectAll()
{
  //toggleTool(ID_DRAW_SELECT);
  grid->setTool(KIconEditGrid::SelectRect);
  grid->editSelectAll();
}

kiconedit'KIconEdit::slotOpenRecent() (./kdegraphics/kiconedit/kiconeditslots.cpp:254)

void KIconEdit::slotOpenRecent(int id)
{
  debug("Opening recent file: %d", id);
  Properties *pprops = props(this);
  debug("Recent: %s", pprops->recentlist->at((uint)id));
  icon->open(&grid->image(), pprops->recentlist->at(id));
}

kiconedit'KIconEdit::slotConfigure() (./kdegraphics/kiconedit/kiconeditslots.cpp:262)

void KIconEdit::slotConfigure(int id)
{
  switch(id)
  {
    case ID_OPTIONS_CONFIGURE:
    {
      KIconConfig c(this);
      if(c.exec())
      {
        Properties *pprops = props(this);
        updateMenuAccel();
        gridview->setShowRulers(pprops->showrulers);
        if(pprops->backgroundmode == QWidget::FixedPixmap)
        {
          QPixmap pix(pprops->backgroundpixmap.data());
          if(pix.isNull())
          {
            QPixmap pmlogo((const char**)logo);
            pix = pmlogo;
          }
          //viewport->viewport()->setBackgroundPixmap(pix);
        }
        //else
          //viewport->viewport()->setBackgroundColor(pprops->backgroundcolor);
      }
      //KKeyDialog::configureKeys( keys );
      break;
    }
    case ID_OPTIONS_TOGGLE_GRID:
      if(options->isItemChecked(ID_OPTIONS_TOGGLE_GRID))
      {
        options->setItemChecked(ID_OPTIONS_TOGGLE_GRID, false);
        ((KToolBarButton*)toolbar->getButton(ID_OPTIONS_TOGGLE_GRID))->on(false);
        //toolbar->setButton(ID_OPTIONS_TOGGLE_GRID, false);
        props(this)->showgrid = false;
        grid->setGrid(false);
      }
      else
      {
        options->setItemChecked(ID_OPTIONS_TOGGLE_GRID, true);
        ((KToolBarButton*)toolbar->getButton(ID_OPTIONS_TOGGLE_GRID))->on(true);
        //toolbar->setButton(ID_OPTIONS_TOGGLE_GRID, true);
        props(this)->showgrid = true;
        grid->setGrid(true);
      }
      break;
    case ID_OPTIONS_TOGGLE_TOOL1:
      if(options->isItemChecked(ID_OPTIONS_TOGGLE_TOOL1))
        options->setItemChecked(ID_OPTIONS_TOGGLE_TOOL1, false);
      else
        options->setItemChecked(ID_OPTIONS_TOGGLE_TOOL1, true);
      enableToolBar(KToolBar::Toggle, 0);
      break;
    case ID_OPTIONS_TOGGLE_TOOL2:
      if(options->isItemChecked(ID_OPTIONS_TOGGLE_TOOL2))
        options->setItemChecked(ID_OPTIONS_TOGGLE_TOOL2, false);
      else
        options->setItemChecked(ID_OPTIONS_TOGGLE_TOOL2, true);
      enableToolBar(KToolBar::Toggle, 1);
      break;
    case ID_OPTIONS_TOGGLE_STATS:
      if(options->isItemChecked(ID_OPTIONS_TOGGLE_STATS))
        options->setItemChecked(ID_OPTIONS_TOGGLE_STATS, false);
      else
        options->setItemChecked(ID_OPTIONS_TOGGLE_STATS, true);
      enableStatusBar();
      break;
    case ID_OPTIONS_SAVE:
      writeConfig();
      break;
    default:
      break;
  }
}

kiconedit'KIconEdit::slotTools() (./kdegraphics/kiconedit/kiconeditslots.cpp:337)

void KIconEdit::slotTools( int id )
{
  switch(id)
  {
    case ID_SELECT_RECT:
      grid->setTool(KIconEditGrid::SelectRect);
      break;
    case ID_SELECT_CIRCLE:
      grid->setTool(KIconEditGrid::SelectCircle);
      break;
    case ID_DRAW_FREEHAND:
      toggleTool(id);
      grid->setTool(KIconEditGrid::Freehand);
      break;
    case ID_DRAW_ELLIPSE:
      toggleTool(id);
      grid->setTool(KIconEditGrid::Ellipse);
      break;
    case ID_DRAW_ELLIPSE_FILL:
      toggleTool(id);
      grid->setTool(KIconEditGrid::FilledEllipse);
      break;
    case ID_DRAW_CIRCLE:
      toggleTool(id);
      grid->setTool(KIconEditGrid::Circle);
      break;
    case ID_DRAW_CIRCLE_FILL:
      toggleTool(id);
      grid->setTool(KIconEditGrid::FilledCircle);
      break;
    case ID_DRAW_RECT:
      toggleTool(id);
      grid->setTool(KIconEditGrid::Rect);
      break;
    case ID_DRAW_RECT_FILL:
      toggleTool(id);
      grid->setTool(KIconEditGrid::FilledRect);
      break;
    case ID_DRAW_ERASE:
      toggleTool(id);
      grid->setTool(KIconEditGrid::Eraser);
      break;
    case ID_DRAW_LINE:
      toggleTool(id);
      grid->setTool(KIconEditGrid::Line);
      break;
    case ID_DRAW_FIND:
      toggleTool(id);
      grid->setTool(KIconEditGrid::Find);
      break;
    case ID_DRAW_FILL:
      toggleTool(id);
      grid->setTool(KIconEditGrid::FloodFill);
      break;
    //case ID_DRAW_SELECT:
    case ID_DRAW_SPRAY:
      toggleTool(id);
      grid->setTool(KIconEditGrid::Spray);
      break;
    default:
        if(id >= 500 && id <= 600)
          KMessageBox::sorry(this, i18n("Sorry - not implemented."));
      break;
  }
}

kiconedit'KIconEdit::slotImage() (./kdegraphics/kiconedit/kiconeditslots.cpp:403)

void KIconEdit::slotImage( int id )
{
  switch(id)
  {
#if QT_VERSION >= 140
    case ID_IMAGE_RESIZE:
      grid->editResize();
      break;
#endif
    case ID_IMAGE_GRAYSCALE:
      grid->grayScale();
      break;
    case ID_IMAGE_MAPTOKDE:
      grid->mapToKDEPalette();
      break;
    default:
      break;
  }
}

kiconedit'KIconEdit::slotSaved() (./kdegraphics/kiconedit/kiconeditslots.cpp:423)

void KIconEdit::slotSaved()
{
  grid->setModified(false);
}

kiconedit'KIconEdit::slotUpdateStatusPos() (./kdegraphics/kiconedit/kiconeditslots.cpp:428)

void KIconEdit::slotUpdateStatusPos(int x, int y)
{
  QString str;
  str.sprintf("%d, %d", x, y);
  statusbar->changeItem( str.data(), 0);
}

kiconedit'KIconEdit::slotUpdateStatusSize() (./kdegraphics/kiconedit/kiconeditslots.cpp:435)

void KIconEdit::slotUpdateStatusSize(int x, int y)
{
  QString str;
  str.sprintf("%d x %d", x, y);
  statusbar->changeItem( str.data(), 1);
  //viewport->updateScrollBars();
}

kiconedit'KIconEdit::slotUpdateStatusScaling() (./kdegraphics/kiconedit/kiconeditslots.cpp:443)

void KIconEdit::slotUpdateStatusScaling(int s, bool show)
{
  props(this)->gridscaling = s;
  QString str;
  if(show)
  {
    toolbar->setItemEnabled(ID_VIEW_ZOOM_IN, true);
    toolbar->setItemEnabled(ID_VIEW_ZOOM_OUT, true);
  }
  else
  {
    toolbar->setItemEnabled(ID_VIEW_ZOOM_IN, false);
    toolbar->setItemEnabled(ID_VIEW_ZOOM_OUT, false);
  }

  str.sprintf("1:%d", s);
  statusbar->changeItem( str.data(), 2);
  //viewport->updateScrollBars();
}

kiconedit'KIconEdit::slotUpdateStatusColors() (./kdegraphics/kiconedit/kiconeditslots.cpp:463)

void KIconEdit::slotUpdateStatusColors(uint)
{
  QString str;
  str.sprintf(i18n("Colors: %u"), grid->numColors());
  statusbar->changeItem( str.data(), 3);
}

kiconedit'KIconEdit::slotUpdateStatusColors() (./kdegraphics/kiconedit/kiconeditslots.cpp:470)

void KIconEdit::slotUpdateStatusColors(uint n, uint *)
{
  QString str;
  str.sprintf(i18n("Colors: %u"), n);
  statusbar->changeItem( str.data(), 3);
}

kiconedit'KIconEdit::slotUpdateStatusMessage() (./kdegraphics/kiconedit/kiconeditslots.cpp:477)

void KIconEdit::slotUpdateStatusMessage(const char *msg)
{
  msgtimer->start(10000, true);
  statusbar->changeItem( msg, 4);
}

kiconedit'KIconEdit::slotClearStatusMessage() (./kdegraphics/kiconedit/kiconeditslots.cpp:483)

void KIconEdit::slotClearStatusMessage()
{
  statusbar->changeItem( "", 4);
}

kiconedit'KIconEdit::slotUpdateStatusName() (./kdegraphics/kiconedit/kiconeditslots.cpp:488)

void KIconEdit::slotUpdateStatusName(const char *name)
{
  QString cap = "", str = name;
  if(!str.isEmpty())
  {
    cap += name;
    cap += " - ";
    addRecent(name);
  }
  cap += kapp->caption();
  setCaption(cap.data());
}

kiconedit'KIconEdit::slotUpdatePaste() (./kdegraphics/kiconedit/kiconeditslots.cpp:501)

void KIconEdit::slotUpdatePaste(bool state)
{
  edit->setItemEnabled(ID_EDIT_PASTE, state);
  toolbar->setItemEnabled(ID_EDIT_PASTE, state);
  edit->setItemEnabled(ID_EDIT_PASTE_AS_NEW, state);
  toolbar->setItemEnabled(ID_EDIT_PASTE_AS_NEW, state);
}

kiconedit'KIconEdit::slotUpdateCopy() (./kdegraphics/kiconedit/kiconeditslots.cpp:509)

void KIconEdit::slotUpdateCopy(bool state)
{
  edit->setItemEnabled(ID_EDIT_COPY, state);
  toolbar->setItemEnabled(ID_EDIT_COPY, state);
  edit->setItemEnabled(ID_EDIT_CUT, state);
  toolbar->setItemEnabled(ID_EDIT_CUT, state);
}

kiconedit'KIconEdit::slotOpenBlank() (./kdegraphics/kiconedit/kiconeditslots.cpp:517)

void KIconEdit::slotOpenBlank(const QSize s)
{
  icon->cleanup();
  grid->loadBlank( s.width(), s.height());
}

#if 0
void KIconEdit::slotDropEvent( KDNDDropZone * _dropZone )
{
  debug("KIconEdit::slotDropEvent");
  QStrList & list = _dropZone->getURLList();
  char *s;
  bool loadedinthis = false;
  
  for ( s = list.first(); s != 0L; s = list.next() )
  {
    // Load the first file in this window
    debug("KIconEdit:slotDropEvent - %s", s);
    //s == list.getFirst();
    if (!grid->isModified() && !loadedinthis) 
    {
      icon->open( &grid->image(), s );
      loadedinthis = true;
    }
    else 
    {
      slotNewWin(s);
    }
  }    
}

kiconedit'KIconEdit::slotQDropEvent() (./kdegraphics/kiconedit/kiconeditslots.cpp:551)

void KIconEdit::slotQDropEvent( QDropEvent *e )
{
  debug("Got QDropEvent!");
  gridview->setAcceptDrop(false);
  QImage image;
  QStrList list;
  char *s;
  bool loadedinthis = false;
  
  if ( QImageDrag::decode( e, image ) )
  {
    debug("Image decoded");
    if(!image.isNull())
    {
      image = image.convertDepth(32);
      //image.setAlphaBuffer(true);
      for(int y = 0; y < image.height(); y++)
      {
        uint *l = (uint*)image.scanLine(y);
        for(int x = 0; x < image.width(); x++, l++)
        {
          if(*l < OPAQUE_MASK) // the dnd encoding stuff turns off the opaque bits
          {
            *l = *l | OPAQUE_MASK;
          }
        }
      }
      grid->load(&image);
    }
    else
      debug("Image is invalid");
  }
#if QT_VERSION > 140
  else if(QUrlDrag::decode( e, list ) )
  {
    for ( s = list.first(); s != 0L; s = list.next() )
    {
      // Load the first file in this window
      debug("KIconEdit:slotQDropEvent - %s", s);
      //s == list.getFirst();
      if (!grid->isModified() && !loadedinthis) 
      {
        icon->open( &grid->image(), s );
        loadedinthis = true;
      }
      else 
      {
        slotNewWin(s);
      }
    }
  } 
#endif   
}

kiconedit'KIconEdit::slotQDragLeaveEvent() (./kdegraphics/kiconedit/kiconeditslots.cpp:605)

void KIconEdit::slotQDragLeaveEvent( QDragLeaveEvent * /*e*/ )
{
  debug("Got QDragLeaveEvent!");
  gridview->setAcceptDrop(false);
}

kiconedit'KIconEdit::slotQDragEnterEvent() (./kdegraphics/kiconedit/kiconeditslots.cpp:611)

void KIconEdit::slotQDragEnterEvent( QDragEnterEvent *e )
{
  debug("Got QDragEnterEvent!");
  if( QImageDrag::canDecode( e ) )
  {
    e->accept();
    gridview->setAcceptDrop(true);
  }
#if QT_VERSION > 140
  else if( QUrlDrag::canDecode( e ) )
  {
    gridview->setAcceptDrop(true);
    e->accept();
  }
#endif
  else
    e->ignore();
}