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

kcron'KTApp (./kdeadmin/kcron/ktapp.h:37)

class KTApp : public KTMainWindow
{
  Q_OBJECT

  friend class KTView;

public:

  // Menu constants
  static const int menuFileSave;
  static const int menuFileQuit;
  static const int menuEditCut;
  static const int menuEditCopy;
  static const int menuEditPaste;
  static const int menuEditNew;
  static const int menuEditModify;
  static const int menuEditDelete;
  static const int menuEditEnabled;
  static const int menuEditRunNow;
  static const int menuOptionsShowToolbar;
  static const int menuOptionsShowStatusbar;
  static const int menuHelpContents;
  static const int statusMessage;

/**
  * Initialize the application.
  */
  KTApp();

/**
  * Quit the application..
  */
  ~KTApp();

/**
  * Enable menu item/toolbar item.  Id is one of the static constants 
  * identified above.
  */
  void enableCommand(int id_, bool enable = true);

/**
  * Enable enable.
  */
  void enableEnable(bool display = true, bool enable = true);

/**
  * Returns a reference to the document.
  */	
  const CTHost& getCTHost() const; 	

protected:

/**
  * Resize application window contents.
. */
  virtual void resizeEvent (QResizeEvent*);

/** Called on window close event.  Asks the document if it is dirty
  * and if so, prompts the user for saving before exiting..
  */
  virtual bool queryClose();

/** Called when the last window of the application is going to be
  * closed.  Saves options.
  */
  virtual bool queryExit();

public slots:

/**
  * Switch argument for slot selection by menu or toolbar ID.
  */
  void commandCallback(int id_);

/**
  * Switch argument for satus ar help entries on slot selection. Add your
  * ID's help here for toolbars and menubar entries.
  */
  void statusCallback(int id_);

/**
  * Save document.
  */
  void slotFileSave();

/**
  * Close all open windows then quits the application.  If queryClose()
  * returns false because the user canceled the saveModified() dialog, the
  * closing breaks.
  */
  void slotFileQuit();

/**
  * Pop up an edit menu.
  */
  void slotEdit(const QPoint& qp);

/**
  * Put the marked objects on the clipboard and remove it from the
  * document.
  */
  void slotEditCut();

/**
  * Put the marked objects on the clipboard.
  */
  void slotEditCopy();

/**
  * Paste the object on clipboard into the document
  */
  void slotEditPaste();

/**
  * New.
  */
  void slotEditNew();

/**
  * Modify.
  */
  void slotEditModify();

/**
  * Delete.
  */
  void slotEditDelete();

/**
  * Toggle enabled.
  */
  void slotEditEnable();

/**
  * Run program now.
  */
  void slotEditRunNow();

/**
  * Toggle the toolbar being visible.
  */
  void slotViewToolBar();

/**
  * Toggles the status bar being visible.
  */
  void slotViewStatusBar();

/**
  * Changes the status bar contents for the standard label permanently;
  * used to indicate current actions.
  */
  void slotStatusMsg(const char *text);

/**
  * Changes the status message of the whole status bar for two seconds,
  * then restores the last status. This is used to display status bar
  * messages that give information about actions for toolbar icons and
  * menu entries.
  */
  void slotStatusHelpMsg(const char *text);

private:

/**
  * Disabled copy constructor.
  */
  KTApp(const KTApp& source);

/**
  * Disabled assignment operator.
  */
  void operator = (const KTApp& source);

/**
  * Get application caption.
  */
  QString caption();

/**
  * Initialize menus.
  */
  void initMenuBar();

/**
  * Initialize toolbar.
  */
  void initToolBar();

/**
  * Initialize status bar.
  */
  void initStatusBar();

/**
  * Initialize keyboard accelerators.
  */
  void initKeyAccel();

/**
  * Read general options again and initialize all variables like the
  * geometry.
  */
  void readOptions();

/**
  * Save general options like all bar positions and status as well as the
  * geometry to the configuration file.
  */ 	
  void saveOptions();

/**
  * File menu.
  */
  QPopupMenu* file_menu;

/**
  * Edit menu.
  */
  QPopupMenu* edit_menu;

/**
  * View menu.
  */
  QPopupMenu* view_menu;

/**
  * Help menu.
  */
  QPopupMenu* help_menu;

/**
  * Configuration object of the application.
  */
  KConfig* config;

/**
  * Key accelerator.
  */
  KAccel* key_accel;

/**
  * Main GUI view/working area.
  */
  KTView* view;

/**
  * Document object, here crotab enries.
  */
  CTHost* cthost;

/**
  * Menu bar
  */
  KMenuBar* menuBar;

};

kcron'KTApp::KTApp() (./kdeadmin/kcron/ktapp.cpp:42)

KTApp::KTApp()
{
#ifdef KDE1
  config=KApplication::getKApplication()->getConfig();
#else
  config=kapp->config();
#endif

  setIcon(KTIcon::application(true));

  setCaption(i18n("Task Scheduler"));

  // Call inits to invoke all other construction parts.
  initMenuBar();
  initToolBar();
  initStatusBar();
  initKeyAccel();

  // Initialize document.
  cthost = new CTHost();

  // Initialize view.
  view = new KTView(this);
  setView(view);	

  // Read options.
  readOptions();
}

kcron'KTApp::~KTApp() (./kdeadmin/kcron/ktapp.cpp:71)

KTApp::~KTApp()
{
 delete view;
 delete cthost;
}

kcron'KTApp::enableCommand() (./kdeadmin/kcron/ktapp.cpp:77)

void KTApp::enableCommand(int id_, bool enable)
{
  // enable menu and toolbar functions by their ID's
  menuBar->setItemEnabled(id_, enable);
  toolBar()->setItemEnabled(id_, enable);
}

kcron'KTApp::enableEnable() (./kdeadmin/kcron/ktapp.cpp:84)

void KTApp::enableEnable(bool display, bool enable)
{
  edit_menu->setItemChecked(menuEditEnabled, display ? enable : false);
  enableCommand(menuEditEnabled, display);
}

kcron'KTApp::getCTHost() (./kdeadmin/kcron/ktapp.cpp:90)

const CTHost& KTApp::getCTHost() const
{
  return *cthost;
}

kcron'KTApp::caption() (./kdeadmin/kcron/ktapp.cpp:96)

QString KTApp::caption()
{
#ifdef KDE1
  QString cap(kapp->appName());
#else
  QString cap(kapp->caption());
#endif
  return cap;
}

kcron'KTApp::initMenuBar() (./kdeadmin/kcron/ktapp.cpp:106)

void KTApp::initMenuBar()
{
  file_menu = new QPopupMenu();
  file_menu->insertItem(KTIcon::save() ,i18n("&Save"), menuFileSave);
  file_menu->insertSeparator();
  file_menu->insertItem(i18n("&Quit"), menuFileQuit );

  edit_menu = new QPopupMenu();
  edit_menu->setCheckable(true);
  edit_menu->insertItem(KTIcon::cut(), i18n("Cu&t"), menuEditCut);
  edit_menu->insertItem(KTIcon::copy(), i18n("&Copy"), menuEditCopy);
  edit_menu->insertItem(KTIcon::paste(), i18n("&Paste"), menuEditPaste);
  edit_menu->insertSeparator();
  edit_menu->insertItem(i18n("&New..."), menuEditNew);
  edit_menu->insertItem(i18n("M&odify..."), menuEditModify);
  edit_menu->insertItem(i18n("&Delete"), menuEditDelete);
  edit_menu->insertSeparator();
  edit_menu->insertItem(i18n("&Enabled"), menuEditEnabled);
  edit_menu->insertSeparator();
  edit_menu->insertItem(KTIcon::task(true), i18n("&Run Now"), menuEditRunNow);

  view_menu = new QPopupMenu();
  view_menu->setCheckable(true);
  view_menu->insertItem(i18n("Show &Toolbar"), menuOptionsShowToolbar);
  view_menu->insertItem(i18n("Show &Statusbar"), menuOptionsShowStatusbar);

  help_menu = new QPopupMenu();

  QString aboutstring = caption()  + " " + VERSION + "\n\n" +
    "(c) 1999 Gary Meyer <gary@meyer.net>";

#ifdef KDE1
  help_menu = KApplication::getKApplication()->getHelpMenu(true, aboutstring);
#else
  help_menu = helpMenu(aboutstring);
#endif

  menuBar = new KMenuBar(this);
  menuBar->insertItem(i18n("&File"), file_menu);
  menuBar->insertItem(i18n("&Edit"), edit_menu);
  menuBar->insertItem(i18n("&Options"), view_menu);
  menuBar->insertSeparator();
  menuBar->insertItem(i18n("&Help"), help_menu);

  setMenu(menuBar);

  connect(file_menu,SIGNAL(activated(int)),SLOT(commandCallback(int)));
  connect(file_menu,SIGNAL(highlighted(int)),SLOT(statusCallback(int)));

  connect(edit_menu,SIGNAL(activated(int)),SLOT(commandCallback(int)));
  connect(edit_menu,SIGNAL(highlighted(int)),SLOT(statusCallback(int)));

  connect(view_menu,SIGNAL(activated(int)),SLOT(commandCallback(int)));
  connect(view_menu,SIGNAL(highlighted(int)),SLOT(statusCallback(int)));
}

kcron'KTApp::initToolBar() (./kdeadmin/kcron/ktapp.cpp:162)

void KTApp::initToolBar()
{
  toolBar()->insertButton(KTIcon::save(), menuFileSave, true, i18n("Save"));
  toolBar()->insertSeparator();
  toolBar()->insertButton(KTIcon::cut(), menuEditCut, true, i18n("Cut"));
  toolBar()->insertButton(KTIcon::copy(), menuEditCopy, true, i18n("Copy"));
  toolBar()->insertButton(KTIcon::paste(), menuEditPaste, true, i18n("Paste"));
  toolBar()->insertSeparator();
  toolBar()->insertButton(KTIcon::help(), menuHelpContents, SIGNAL(clicked()),
    kapp, SLOT(appHelpActivated()), true, i18n("Help"));

  connect(toolBar(), SIGNAL(clicked(int)), SLOT(commandCallback(int)));
  connect(toolBar(), SIGNAL(pressed(int)), SLOT(statusCallback(int)));
}

kcron'KTApp::initStatusBar() (./kdeadmin/kcron/ktapp.cpp:177)

void KTApp::initStatusBar()
{
  statusBar()->insertItem(i18n("Ready."), statusMessage);
}

kcron'KTApp::initKeyAccel() (./kdeadmin/kcron/ktapp.cpp:182)

void KTApp::initKeyAccel()
{
  key_accel = new KAccel(this);

  // file menu accelerators
  key_accel->connectItem(KStdAccel::Save, this, SLOT(slotFileSave()));
  key_accel->connectItem(KStdAccel::Quit, this, SLOT(slotFileQuit()));

  // edit menu accelerators
  key_accel->connectItem(KStdAccel::Cut, this, SLOT(slotEditCut()));
  key_accel->connectItem(KStdAccel::Copy, this, SLOT(slotEditCopy()));
  key_accel->connectItem(KStdAccel::Paste, this, SLOT(slotEditPaste()));
  key_accel->connectItem(KStdAccel::New, this, SLOT(slotEditNew()));
  key_accel->connectItem(KStdAccel::Insert, this, SLOT(slotEditNew()));
  key_accel->connectItem(KStdAccel::Open, this, SLOT(slotEditModify()));

  // help menu accelerators
  key_accel->connectItem(KStdAccel::Help, kapp, SLOT(appHelpActivated()));

  key_accel->changeMenuAccel(file_menu, menuFileSave, KStdAccel::Save);
  key_accel->changeMenuAccel(file_menu, menuFileQuit, KStdAccel::Quit);

  key_accel->changeMenuAccel(edit_menu, menuEditCut, KStdAccel::Cut);
  key_accel->changeMenuAccel(edit_menu, menuEditCopy, KStdAccel::Copy);
  key_accel->changeMenuAccel(edit_menu, menuEditPaste, KStdAccel::Paste);

  key_accel->changeMenuAccel(edit_menu, menuEditNew, KStdAccel::Insert);
  key_accel->changeMenuAccel(edit_menu, menuEditNew, KStdAccel::New);
  key_accel->changeMenuAccel(edit_menu, menuEditModify, KStdAccel::Open);

  key_accel->readSettings();
}

kcron'KTApp::saveOptions() (./kdeadmin/kcron/ktapp.cpp:215)

void KTApp::saveOptions()
{	
  config->setGroup(QString("General Options"));
  config->writeEntry(QString("Geometry"), size());
  config->writeEntry(QString("Show Toolbar"), toolBar()->isVisible());
  config->writeEntry(QString("Show Statusbar"), statusBar()->isVisible());
  config->writeEntry(QString("ToolBarPos"),  (int)toolBar()->barPos());
}

kcron'KTApp::readOptions() (./kdeadmin/kcron/ktapp.cpp:225)

void KTApp::readOptions()
{
  config->setGroup(QString("General Options"));

  // bar status settings
  bool bViewToolbar = config->readBoolEntry(QString("Show Toolbar"), true);
  view_menu->setItemChecked(menuOptionsShowToolbar, bViewToolbar);
  if (!bViewToolbar)
    enableToolBar(KToolBar::Hide);
	
  bool bViewStatusbar = config->readBoolEntry(QString("Show Statusbar"), true);
  view_menu->setItemChecked(menuOptionsShowStatusbar, bViewStatusbar);
  if (!bViewStatusbar)
    enableStatusBar(KStatusBar::Hide);
	
  // bar position settings
  KToolBar::BarPosition tool_bar_pos;
  tool_bar_pos=(KToolBar::BarPosition)
    config->readNumEntry(QString("ToolBarPos"),
    KToolBar::Top);

  toolBar()->setBarPos(tool_bar_pos);
	
  QSize size=config->readSizeEntry(QString("Geometry"));

  if (!size.isEmpty())
    resize(size);
}

kcron'KTApp::queryClose() (./kdeadmin/kcron/ktapp.cpp:254)

bool KTApp::queryClose()
{
  if(cthost->dirty())
  {
    KTApp* win = (KTApp*)parent();

    int retVal = QMessageBox::information(win, caption(),
      i18n("Scheduled tasks have been modified.\nDo you want to save changes?"),
      QMessageBox::Yes | QMessageBox::Default,
      QMessageBox::No,
      QMessageBox::Cancel | QMessageBox::Escape);

    switch (retVal)
    {
      case QMessageBox::Yes:
        cthost->apply();
        return true;
        break;
      case QMessageBox::No:
        return true;
        break;	
      case QMessageBox::Cancel:
        return false;
        break;
      default:
        return false;
        break;
    }
  }
  else
  {
    return true;
  }
}

kcron'KTApp::queryExit() (./kdeadmin/kcron/ktapp.cpp:289)

bool KTApp::queryExit()
{
  saveOptions();
  return true;
}

kcron'KTApp::slotFileSave() (./kdeadmin/kcron/ktapp.cpp:295)

void KTApp::slotFileSave()
{
  slotStatusMsg(i18n("Saving..."));
  cthost->apply();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotFileQuit() (./kdeadmin/kcron/ktapp.cpp:302)

void KTApp::slotFileQuit()
{
  saveOptions();
  close();
}

kcron'KTApp::slotEdit() (./kdeadmin/kcron/ktapp.cpp:308)

void KTApp::slotEdit(const QPoint& qp)
{
  edit_menu->exec(qp, 0);
}

kcron'KTApp::slotEditCut() (./kdeadmin/kcron/ktapp.cpp:313)

void KTApp::slotEditCut()
{
  slotStatusMsg(i18n("Cutting to clipboard..."));
  view->copy();
  view->remove();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotEditCopy() (./kdeadmin/kcron/ktapp.cpp:321)

void KTApp::slotEditCopy()
{
  slotStatusMsg(i18n("Copying to clipboard..."));
  view->copy();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotEditPaste() (./kdeadmin/kcron/ktapp.cpp:328)

void KTApp::slotEditPaste()
{
  slotStatusMsg(i18n("Pasting from clipboard..."));
  view->paste();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotEditNew() (./kdeadmin/kcron/ktapp.cpp:335)

void KTApp::slotEditNew()
{
  slotStatusMsg(i18n("Adding new entry..."));
  view->create();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotEditModify() (./kdeadmin/kcron/ktapp.cpp:342)

void KTApp::slotEditModify()
{
  slotStatusMsg(i18n("Modifying entry..."));
  view->edit();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotEditDelete() (./kdeadmin/kcron/ktapp.cpp:349)

void KTApp::slotEditDelete()
{
  slotStatusMsg(i18n("Deleting entry..."));
  view->remove();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotEditEnable() (./kdeadmin/kcron/ktapp.cpp:356)

void KTApp::slotEditEnable()
{
  if (edit_menu->isItemChecked(menuEditEnabled))
  {
    slotStatusMsg(i18n("Disabling entry..."));
    view->enable(false);
    edit_menu->setItemChecked(menuEditEnabled, false);
  }
  else
  {
    slotStatusMsg(i18n("Enabling entry..."));
    view->enable(true);
    edit_menu->setItemChecked(menuEditEnabled, true);
  }
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotEditRunNow() (./kdeadmin/kcron/ktapp.cpp:373)

void KTApp::slotEditRunNow()
{
  slotStatusMsg(i18n("Running command..."));
  view->run();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotViewToolBar() (./kdeadmin/kcron/ktapp.cpp:380)

void KTApp::slotViewToolBar()
{
  if (view_menu->isItemChecked(menuOptionsShowToolbar))
    view_menu->setItemChecked(menuOptionsShowToolbar, false);
  else
    view_menu->setItemChecked(menuOptionsShowToolbar, true);
  enableToolBar();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotViewStatusBar() (./kdeadmin/kcron/ktapp.cpp:390)

void KTApp::slotViewStatusBar()
{
  if (view_menu->isItemChecked(menuOptionsShowStatusbar))
    view_menu->setItemChecked(menuOptionsShowStatusbar, false);
  else
    view_menu->setItemChecked(menuOptionsShowStatusbar, true);
  enableStatusBar();
  slotStatusMsg(i18n("Ready."));
}

kcron'KTApp::slotStatusMsg() (./kdeadmin/kcron/ktapp.cpp:400)

void KTApp::slotStatusMsg(const char *text)
{
  statusBar()->clear();
  statusBar()->changeItem(text, statusMessage);
}

kcron'KTApp::slotStatusHelpMsg() (./kdeadmin/kcron/ktapp.cpp:406)

void KTApp::slotStatusHelpMsg(const char *text)
{
  statusBar()->message(text, 2000);
}

kcron'KTApp::commandCallback() (./kdeadmin/kcron/ktapp.cpp:411)

void KTApp::commandCallback(int id_){

  switch (id_){

    case menuFileSave:
    	slotFileSave();
    	break;
    case menuFileQuit:
    	slotFileQuit();
    	break;

    case menuEditCut:
    	slotEditCut();
    	break;
    case menuEditCopy:
    	slotEditCopy();
    	break;
    case menuEditPaste:
    	slotEditPaste();
    	break;
    case menuEditNew:
    	slotEditNew();
    	break;
    case menuEditModify:
    	slotEditModify();
    	break;
    case menuEditDelete:
    	slotEditDelete();
    	break;
    case menuEditEnabled:
    	slotEditEnable();
    	break;
    case menuEditRunNow:
    	slotEditRunNow();
    	break;

    case menuOptionsShowToolbar:
    	slotViewToolBar();
    	break;
    case menuOptionsShowStatusbar:
    	slotViewStatusBar();
    	break;
    default:
    	break;
  }
}

kcron'KTApp::statusCallback() (./kdeadmin/kcron/ktapp.cpp:458)

void KTApp::statusCallback(int id_){

  switch (id_){

    case menuFileSave:
      slotStatusHelpMsg(i18n("Save tasks and variables."));
      break;
    case menuFileQuit:
      slotStatusHelpMsg(i18n("Exit " + caption() + "."));
      break;

    case menuEditCut:
      slotStatusHelpMsg(i18n("Cut the selected task or variable and put on the clipboard."));
      break;
    case menuEditCopy:
      slotStatusHelpMsg(i18n("Copy the selected task or variable to the clipboard."));
      break;
    case menuEditPaste:
      slotStatusHelpMsg(i18n("Paste task or variable from the clipboard."));
      break;
    case menuEditNew:
      slotStatusHelpMsg(i18n("Create a new task or variable."));
      break;
    case menuEditModify:
      slotStatusHelpMsg(i18n("Edit the selected task or variable."));
      break;
    case menuEditDelete:
      slotStatusHelpMsg(i18n("Delete the selected task or variable."));
      break;
    case menuEditEnabled:
      slotStatusHelpMsg(i18n("Enable/disable the selected task or variable."));
      break;
    case menuEditRunNow:
      slotStatusHelpMsg(i18n("Run the selected task now."));
      break;

    case menuOptionsShowToolbar:
      slotStatusHelpMsg(i18n("Enables/disable the tool bar."));
      break;
    case menuOptionsShowStatusbar:
      slotStatusHelpMsg(i18n("Enable/disable the status bar."));
      break;

    default:
      break;
  }
}

kcron'KTApp::resizeEvent() (./kdeadmin/kcron/ktapp.cpp:506)

void KTApp::resizeEvent (QResizeEvent* event)
{
  view->setGeometry(0, menuBar->height() +
    view_menu->isItemChecked(menuOptionsShowToolbar) * toolBar()->height(),
    width(), height() - menuBar->height() -
    view_menu->isItemChecked(menuOptionsShowToolbar) * toolBar()->height() -
    view_menu->isItemChecked(menuOptionsShowStatusbar) *
    statusBar()->height());

  repaint();
}