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

klyx'KLyXToolBarReceiver (./klyx/src/KLyXToolBar.h:101)

class KLyXToolBarReceiver : public QObject
{
  Q_OBJECT

public:
  KLyXToolBarReceiver( LyXView* view ) { _view = view; }

public slots:
/* normal toolbar */
  void fileNew();	// Rocher 981124
  void fileNewTmplt();	// Rocher 981124
  void open();
  void write();
  void previewCustom();	// Rocher 981124
  void previewUpdate(); // Rocher 981124
  void print();
  void cut();
  void copy();
  void paste();
  void emph();
  void noun();
  void free();
  void footmelt();
  void marginmelt();
  void depth();
  void tex();
  void mathmode();
  void figure();
  void table();
  void layoutComboActivated( int );

  /* math toolbar */
  void squareroot();
  void fraction();
  void sum();
  void integral();
  void exponent();
  void index();
  void delimiter();
  void decoration();
  void function();
  void spacing();
  void matrix();
  void equation();
  void greek();
  void boperators();
  void brelations();
  void arrows();
  void varsize();
  void misc();

  /* table toolbar */ 
  void tableStyleComboActivated(int);
  void tableLongComboActivated(int);
  void tableUpdate(int);

  /* char toolbar */ 
  void charComboIgnore(int);
  void charUpdate();

private:
  LyXView* _view;
};

klyx'KLyXToolBarReceiver::fileNew() (./klyx/src/KLyXToolBar.C:93)

void KLyXToolBarReceiver::fileNew()		// Rocher 981124
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_MENUNEW );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::fileNewTmplt() (./klyx/src/KLyXToolBar.C:100)

void KLyXToolBarReceiver::fileNewTmplt()	// Rocher 981124
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_MENUNEWTMPLT );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::open() (./klyx/src/KLyXToolBar.C:107)

void KLyXToolBarReceiver::open()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_MENUOPEN );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::write() (./klyx/src/KLyXToolBar.C:114)

void KLyXToolBarReceiver::write()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_MENUWRITE );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::previewCustom() (./klyx/src/KLyXToolBar.C:121)

void KLyXToolBarReceiver::previewCustom()	// Rocher 981124
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_PREVIEWCUSTOM );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::previewUpdate() (./klyx/src/KLyXToolBar.C:128)

void KLyXToolBarReceiver::previewUpdate()	// Rocher 981124
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_PREVIEWUPDATE );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::print() (./klyx/src/KLyXToolBar.C:135)

void KLyXToolBarReceiver::print()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_MENUPRINT );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::cut() (./klyx/src/KLyXToolBar.C:142)

void KLyXToolBarReceiver::cut()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_CUT );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::copy() (./klyx/src/KLyXToolBar.C:149)

void KLyXToolBarReceiver::copy()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_COPY );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::paste() (./klyx/src/KLyXToolBar.C:156)

void KLyXToolBarReceiver::paste()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_PASTE );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::emph() (./klyx/src/KLyXToolBar.C:163)

void KLyXToolBarReceiver::emph()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_EMPH );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::noun() (./klyx/src/KLyXToolBar.C:170)

void KLyXToolBarReceiver::noun()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_NOUN );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::free() (./klyx/src/KLyXToolBar.C:177)

void KLyXToolBarReceiver::free()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_FREE );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::footmelt() (./klyx/src/KLyXToolBar.C:184)

void KLyXToolBarReceiver::footmelt()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_FOOTMELT );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::marginmelt() (./klyx/src/KLyXToolBar.C:191)

void KLyXToolBarReceiver::marginmelt()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_MARGINMELT );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::depth() (./klyx/src/KLyXToolBar.C:198)

void KLyXToolBarReceiver::depth()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_DEPTH );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::tex() (./klyx/src/KLyXToolBar.C:205)

void KLyXToolBarReceiver::tex()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_TEX );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::mathmode() (./klyx/src/KLyXToolBar.C:212)

void KLyXToolBarReceiver::mathmode()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_MATH_MODE );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::figure() (./klyx/src/KLyXToolBar.C:219)

void KLyXToolBarReceiver::figure()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_FIGURE );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::table() (./klyx/src/KLyXToolBar.C:226)

void KLyXToolBarReceiver::table()
{
  LString res = _view->getLyXFunc()->Dispatch( LFUN_TABLE );
  if(!res.empty())
	lyxerr.print(res); 
}

klyx'KLyXToolBarReceiver::layoutComboActivated() (./klyx/src/KLyXToolBar.C:233)

void KLyXToolBarReceiver::layoutComboActivated( int item )
{
  LString tmp;
  tmp += item + 1;
  
  char layout = -1;
  if (_view->currentBuffer()->text)
    layout = _view->currentBuffer()->text->cursor.par->GetLayout();

  if (item != layout)
    _view->getLyXFunc()->Dispatch( LFUN_LAYOUTNO,
				   tmp.c_str() );
}

klyx'KLyXToolBarReceiver::squareroot() (./klyx/src/KLyXToolBar.C:248)

void KLyXToolBarReceiver::squareroot()
{
  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "sqrt" );
}

klyx'KLyXToolBarReceiver::fraction() (./klyx/src/KLyXToolBar.C:254)

void KLyXToolBarReceiver::fraction()
{
  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "frac" );
}

klyx'KLyXToolBarReceiver::sum() (./klyx/src/KLyXToolBar.C:260)

void KLyXToolBarReceiver::sum()
{
  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "sum" );
}

klyx'KLyXToolBarReceiver::integral() (./klyx/src/KLyXToolBar.C:265)

void KLyXToolBarReceiver::integral()
{
  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "int" );
}

klyx'KLyXToolBarReceiver::exponent() (./klyx/src/KLyXToolBar.C:270)

void KLyXToolBarReceiver::exponent()
{
  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "^" );
}

klyx'KLyXToolBarReceiver::index() (./klyx/src/KLyXToolBar.C:275)

void KLyXToolBarReceiver::index()
{
  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "_" );
}

klyx'KLyXToolBarReceiver::delimiter() (./klyx/src/KLyXToolBar.C:281)

void KLyXToolBarReceiver::delimiter()
{
	if( !_view->dialogs()->mathdelimiter )
		_view->dialogs()->mathdelimiter = new MathDelimiterDialog( _view, NULL );

	if( !_view->dialogs()->mathdelimiter->isVisible() )
		_view->dialogs()->mathdelimiter->show();
}

klyx'KLyXToolBarReceiver::decoration() (./klyx/src/KLyXToolBar.C:291)

void KLyXToolBarReceiver::decoration()
{
  if( !_view->dialogs()->mathdecobrowser )
	_view->dialogs()->mathdecobrowser = new MathDecoBrowser();

  QWidget* trigger = _view->getMathToolbar()->getButton( MATHTOOLBAR_DECORATION );
  int ret = _view->dialogs()->mathdecobrowser->exec( trigger );
  QEvent ev( QEvent::Leave );
  QMouseEvent mev ( QEvent::MouseButtonRelease, 
		    QCursor::pos(), LeftButton, LeftButton );
  QApplication::sendEvent( trigger, &ev );
  QApplication::sendEvent( trigger, &mev );
  switch( ret )
	{
	case 0:
	  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "widehat" );
	  break;
	case 1:
	  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "widetilde" );
	  break;
	case 2:
	  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "overbrace" );
	  break;
	case 3:
	  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "overleftarrow" );
	  break;
	case 4:
	  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "overrightarrow" );
	  break;
	case 5:
	  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "overline" );
	  break;
	case 6:
	  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "underbrace" );
	  break;
	case 7:
	  _view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, "underline" );
	  break;
	};
}

klyx'KLyXToolBarReceiver::function() (./klyx/src/KLyXToolBar.C:333)

void KLyXToolBarReceiver::function()
{
    if( !_view->dialogs()->mathfuncbrowser )
	_view->dialogs()->mathfuncbrowser = new MathFunctionBrowser();

    QWidget* trigger = _view->getMathToolbar()->getButton( MATHTOOLBAR_FUNCTION );
    int ret = _view->dialogs()->mathfuncbrowser->exec( trigger );
    QEvent ev( QEvent::Leave );
    QMouseEvent mev( QEvent::MouseButtonRelease, QCursor::pos(), LeftButton, LeftButton );
    QApplication::sendEvent( trigger, &ev );
    QApplication::sendEvent( trigger, &mev );
    if( ret >= 0 )
	_view->getLyXFunc()->Dispatch( LFUN_INSERT_MATH, func_code[ ret ] );
}

klyx'KLyXToolBarReceiver::spacing() (./klyx/src/KLyXToolBar.C:351)

void KLyXToolBarReceiver::spacing()
{
	if( !_view->dialogs()->mathspacing )
		_view->dialogs()->mathspacing = new MathSpacingDialog( _view, NULL );

	if( !_view->dialogs()->mathspacing->isVisible() )
		_view->dialogs()->mathspacing->show();
}

klyx'KLyXToolBarReceiver::matrix() (./klyx/src/KLyXToolBar.C:361)

void KLyXToolBarReceiver::matrix()
{
	if( !_view->dialogs()->mathmatrix )
	  _view->dialogs()->mathmatrix = new MathMatrixDialog( _view, 
							       _view->toplevelWidget());

  MathMatrixDialog* mathmatrix = _view->dialogs()->mathmatrix;
  int ret = _view->dialogs()->mathmatrix->exec();
  _view->dialogs()->mathmatrix = mathmatrix;

  if( ret == QDialog::Accepted )
	{
	  int nx, ny;
	  static char v_align_c[] = "tcb";

	  MathMatrixDialogData *dlg_data = _view->dialogs()->mathmatrix->data();
	  char s[80];
	  char c = v_align_c[(int)dlg_data->vert_align];
	  char const *sh = dlg_data->horz_align;
	  nx = (int)(dlg_data->num_cols+0.5);
	  ny = (int)(dlg_data->num_rows+0.5);
	  sprintf(s, "%d %d %c%s", nx, ny, c, sh);      
	  _view->getLyXFunc()->Dispatch(LFUN_INSERT_MATRIX, s);
	}
}

klyx'KLyXToolBarReceiver::equation() (./klyx/src/KLyXToolBar.C:388)

void KLyXToolBarReceiver::equation()
{
  _view->getLyXFunc()->Dispatch( LFUN_MATH_DISPLAY, "frac" );
}

klyx'KLyXToolBarReceiver::greek() (./klyx/src/KLyXToolBar.C:394)

void KLyXToolBarReceiver::greek()
{
  if( !_view->dialogs()->mathgreekbrowser )
	_view->dialogs()->mathgreekbrowser = new MathGreekBrowser();

  QWidget* trigger = _view->getMathToolbar()->getButton( MATHTOOLBAR_GREEK );
  int ret = _view->dialogs()->mathgreekbrowser->exec( trigger );
  QEvent ev( QEvent::Leave );
  QMouseEvent mev ( QEvent::MouseButtonRelease, 
		    QCursor::pos(), LeftButton, LeftButton );
  QApplication::sendEvent( trigger, &ev );
  QApplication::sendEvent( trigger, &mev );

  if( ret != -1 && ret != 11 && ret <= 39 ) // skip unused fields
	{
	  char const *s = 0;
	  s = latex_greek[ ret ]; 

	  if (s)  {
	        if (_view->currentView()->available() && lyxrc->display_shortcuts) {
		  _view->getMiniBuffer()->Set("Inserting symbol ", s );
		}
		_view->getLyXFunc()->Dispatch(LFUN_INSERT_MATH, s);
	  }      
	}
}

klyx'KLyXToolBarReceiver::boperators() (./klyx/src/KLyXToolBar.C:422)

void KLyXToolBarReceiver::boperators()
{
  if( !_view->dialogs()->mathbinopbrowser )
	_view->dialogs()->mathbinopbrowser = new MathBinOpBrowser();

  QWidget* trigger = _view->getMathToolbar()->getButton( MATHTOOLBAR_BOPERATOR );
  int ret = _view->dialogs()->mathbinopbrowser->exec( trigger );
  QEvent ev( QEvent::Leave );
  QMouseEvent mev ( QEvent::MouseButtonRelease, 
		    QCursor::pos(), LeftButton, LeftButton );
  QApplication::sendEvent( trigger, &ev );
  QApplication::sendEvent( trigger, &mev );

  if( ret != -1 && ret < 31 )
	{
	  char const *s = 0;
	  s = latex_bop[ ret ]; 

	  if (s)  {
		if (_view->currentView()->available() && lyxrc->display_shortcuts) {
		  _view->getMiniBuffer()->Set("Inserting symbol ", s );
		}
		_view->getLyXFunc()->Dispatch(LFUN_INSERT_MATH, s);
	  }      
	}
}

klyx'KLyXToolBarReceiver::brelations() (./klyx/src/KLyXToolBar.C:450)

void KLyXToolBarReceiver::brelations()
{
  if( !_view->dialogs()->mathbinrelbrowser )
	_view->dialogs()->mathbinrelbrowser = new MathBinRelBrowser();

  QWidget* trigger = _view->getMathToolbar()->getButton( MATHTOOLBAR_BRELATION );
  int ret = _view->dialogs()->mathbinrelbrowser->exec( trigger );
  QEvent ev( QEvent::Leave );
  QMouseEvent mev ( QEvent::MouseButtonRelease, 
		    QCursor::pos(), LeftButton, LeftButton );
  QApplication::sendEvent( trigger, &ev );
  QApplication::sendEvent( trigger, &mev );

  if( ret != -1 )
	{
	  char const *s = 0;
	  s = latex_brel[ ret ]; 

	  if (s)  {
		if (_view->currentView()->available() && lyxrc->display_shortcuts) {
		  _view->getMiniBuffer()->Set("Inserting symbol ", s );
		}
		_view->getLyXFunc()->Dispatch(LFUN_INSERT_MATH, s);
	  }      
	}
}

klyx'KLyXToolBarReceiver::arrows() (./klyx/src/KLyXToolBar.C:478)

void KLyXToolBarReceiver::arrows()
{
  if( !_view->dialogs()->matharrowbrowser )
	_view->dialogs()->matharrowbrowser = new MathArrowBrowser();

  QWidget* trigger = _view->getMathToolbar()->getButton( MATHTOOLBAR_ARROW );
  int ret = _view->dialogs()->matharrowbrowser->exec( trigger );
  QEvent ev( QEvent::Leave );
  QMouseEvent mev ( QEvent::MouseButtonRelease, 
		    QCursor::pos(), LeftButton, LeftButton );
  QApplication::sendEvent( trigger, &ev );
  QApplication::sendEvent( trigger, &mev );

  if( ret != -1 )
	{
	  char const *s = 0;
	  s = latex_arrows[ ret ]; 

	  if (s)  {
		if (_view->currentView()->available() && lyxrc->display_shortcuts) {
		  _view->getMiniBuffer()->Set("Inserting symbol ", s );
		}
		_view->getLyXFunc()->Dispatch(LFUN_INSERT_MATH, s);
	  }      
	}
}

klyx'KLyXToolBarReceiver::varsize() (./klyx/src/KLyXToolBar.C:506)

void KLyXToolBarReceiver::varsize()
{
  if( !_view->dialogs()->mathvarsizebrowser )
	_view->dialogs()->mathvarsizebrowser = new MathVarSizeBrowser();

  QWidget* trigger = _view->getMathToolbar()->getButton( MATHTOOLBAR_VARSIZE );
  int ret = _view->dialogs()->mathvarsizebrowser->exec( trigger );
  QEvent ev( QEvent::Leave );
  QMouseEvent mev ( QEvent::MouseButtonRelease, 
		    QCursor::pos(), LeftButton, LeftButton );
  QApplication::sendEvent( trigger, &ev );
  QApplication::sendEvent( trigger, &mev );

  if( ret != -1 && ret != 14 )
	{
	  char const *s = 0;
	  s = latex_varsz[ ret ]; 

	  if (s)  {
		if (_view->currentView()->available() && lyxrc->display_shortcuts) {
		  _view->getMiniBuffer()->Set("Inserting symbol ", s );
		}
		_view->getLyXFunc()->Dispatch(LFUN_INSERT_MATH, s);
	  }      
	}
}

klyx'KLyXToolBarReceiver::misc() (./klyx/src/KLyXToolBar.C:534)

void KLyXToolBarReceiver::misc()
{
  if( !_view->dialogs()->mathmiscbrowser )
	_view->dialogs()->mathmiscbrowser = new MathMiscBrowser();

  QWidget* trigger = _view->getMathToolbar()->getButton( MATHTOOLBAR_MISC );
  int ret = _view->dialogs()->mathmiscbrowser->exec( trigger );
  QEvent ev( QEvent::Leave );
  QMouseEvent mev ( QEvent::MouseButtonRelease, 
		    QCursor::pos(), LeftButton, LeftButton );
  QApplication::sendEvent( trigger, &ev );
  QApplication::sendEvent( trigger, &mev );

  if( ret != -1 && ret != 29 )
	{
	  char const *s = 0;
	  s = latex_misc[ ret ]; 

	  if (s)  {
		if (_view->currentView()->available() && lyxrc->display_shortcuts) {
		  _view->getMiniBuffer()->Set("Inserting symbol ", s );
		}
		_view->getLyXFunc()->Dispatch(LFUN_INSERT_MATH, s);
	  }      
	}
}

klyx'KLyXToolBarReceiver::tableStyleComboActivated() (./klyx/src/KLyXToolBar.C:562)

void KLyXToolBarReceiver::tableStyleComboActivated(int arg){
  if (arg == TABLE_STYLE_NORMAL)
    tableUpdate(TABLETOOLBAR_NORMAL_TABLE);
  else if (arg == TABLE_STYLE_LONG)
    tableUpdate(TABLETOOLBAR_LONG_TABLE);
  else if (arg == TABLE_STYLE_ROTATE)
    tableUpdate(TABLETOOLBAR_ROTATE_TABLE);
  _view->updateToolbars();
}

klyx'KLyXToolBarReceiver::tableLongComboActivated() (./klyx/src/KLyXToolBar.C:572)

void KLyXToolBarReceiver::tableLongComboActivated(int arg){
  switch (arg){
  case TABLE_LONG_NORMAL:
    tableUpdate(TABLETOOLBAR_LONG_NORMAL);
    break;
  case TABLE_LONG_FIRST_HEAD:
    tableUpdate(TABLETOOLBAR_LONG_FIRST_HEAD);
    break;
  case TABLE_LONG_HEAD:
    tableUpdate(TABLETOOLBAR_LONG_HEAD);
    break;
  case TABLE_LONG_FOOT:
    tableUpdate(TABLETOOLBAR_LONG_FOOT);
    break;
  case TABLE_LONG_LAST_FOOT:
    tableUpdate(TABLETOOLBAR_LONG_LAST_FOOT);
    break;
  case TABLE_LONG_NEW_PAGE:
    tableUpdate(TABLETOOLBAR_LONG_NEW_PAGE);
    break;
  }
}

klyx'KLyXToolBarReceiver::tableUpdate() (./klyx/src/KLyXToolBar.C:595)

void KLyXToolBarReceiver::tableUpdate(int arg){
  LyXTable *table = 0;

  if (_view->currentBuffer())
    table = _view->currentBuffer()->text->cursor.par->table;
  if (table){
    int
      align,
      cell,
      column,row,
      num = 0;
    LString
      pwidth;
    
    cell = _view->currentBuffer()->text->
      NumberOfCell(_view->currentBuffer()->text->cursor.par, 
		   _view->currentBuffer()->text->cursor.pos);
    column = table->column_of_cell(cell)+1;
    row = table->row_of_cell(cell)+1;
    align = table->GetAlignment(cell);
    pwidth = table->GetPWidth(cell);
    
    KToolBar* tabletoolbar = _view->getTableToolbar();
    
    switch (arg) {
    case TABLETOOLBAR_MULTICOLUMN:
      num = LyXTable::MULTICOLUMN;
      break;
    case TABLETOOLBAR_BORDER_LEFT:
      num = LyXTable::TOGGLE_LINE_LEFT;
      break;
    case TABLETOOLBAR_BORDER_RIGHT:
      num = LyXTable::TOGGLE_LINE_RIGHT;
      break;
    case TABLETOOLBAR_BORDER_TOP:
      num = LyXTable::TOGGLE_LINE_TOP;
      break;
    case TABLETOOLBAR_BORDER_BOTTOM:
      num = LyXTable::TOGGLE_LINE_BOTTOM;
      break;
    case TABLETOOLBAR_APPEND_ROW:
      num = LyXTable::APPEND_ROW;
      break;
    case TABLETOOLBAR_APPEND_COLUMN:
      num = LyXTable::APPEND_COLUMN;
      break;
    case TABLETOOLBAR_DELETE_ROW:
      num = LyXTable::DELETE_ROW;
      break;
    case TABLETOOLBAR_DELETE_COLUMN:
      num = LyXTable::DELETE_COLUMN;
      break;
    case TABLETOOLBAR_DELETE_TABLE:
      num = LyXTable::DELETE_TABLE;
      break;
    case TABLETOOLBAR_ALIGN_LEFT:
      tabletoolbar->setButton(TABLETOOLBAR_ALIGN_RIGHT, false);
      tabletoolbar->setButton(TABLETOOLBAR_ALIGN_CENTER, false);
      num = LyXTable::ALIGN_LEFT;
      break;
    case TABLETOOLBAR_ALIGN_RIGHT:
      if (!pwidth.empty() && !table->IsMultiColumn(cell)) {
	tabletoolbar->setButton(TABLETOOLBAR_ALIGN_RIGHT, false);
	WriteAlert(i18n("Wrong Alignment."), 
		   i18n("Non multicolumn cells with fixed width can only\nbe left aligned in LaTeX."), 
		   i18n("sorry.")); 
	return;
      }

      tabletoolbar->setButton(TABLETOOLBAR_ALIGN_LEFT, false);
      tabletoolbar->setButton(TABLETOOLBAR_ALIGN_CENTER, false);
      num = LyXTable::ALIGN_RIGHT;
      break;
    case TABLETOOLBAR_ALIGN_CENTER:
      if (!pwidth.empty() && !table->IsMultiColumn(cell)) {
	tabletoolbar->setButton(TABLETOOLBAR_ALIGN_CENTER, false);
	WriteAlert(i18n("Wrong Alignment."), 
		   i18n("Non multicolumn cells with fixed width can only\nbe left aligned in LaTeX."), 
		   i18n("sorry.")); 
	return;
      }
      tabletoolbar->setButton(TABLETOOLBAR_ALIGN_RIGHT, false);
      tabletoolbar->setButton(TABLETOOLBAR_ALIGN_LEFT, false);
      num = LyXTable::ALIGN_CENTER;
      break;
    case TABLETOOLBAR_ROTATE_CELL:
      if (tabletoolbar->isButtonOn(TABLETOOLBAR_ROTATE_CELL))
	num = LyXTable::SET_ROTATE_CELL;
      else
	num = LyXTable::UNSET_ROTATE_CELL;
      break;
    case TABLETOOLBAR_ROTATE_TABLE:
      num = LyXTable::SET_ROTATE_TABLE;
      break;
    case TABLETOOLBAR_LONG_TABLE:
      num = LyXTable::SET_LONGTABLE;
      break;
    case TABLETOOLBAR_NORMAL_TABLE:
      num = LyXTable::SET_NORMALTABLE;
      break;
    case TABLETOOLBAR_WIDTH_OF_COLUMN:
      if (tabletoolbar->isButtonOn(TABLETOOLBAR_WIDTH_OF_COLUMN)){
	LabelInput* labelinput = new LabelInput(_view->toplevelWidget(),
						i18n("Width of Column"));
	QString s = labelinput->getString(i18n("Width of Column:"),
					  pwidth.c_str());
	
	if (!s.isNull()){
	  QString str = s;
	  if (str.isEmpty()){
	    tabletoolbar->setButton(TABLETOOLBAR_WIDTH_OF_COLUMN, false);
	  } else if (!isValidLength(str)){
	    WriteAlert(i18n("You entered an invalid Length:"), 
		       s,
		       i18n("A valid example is \"25mm\"")); 
	    return;
	  }
	  if (_view->currentView()->available()){
	    _view->currentView()->getScreen()->HideCursor();
	    _view->currentView()->currentBuffer()->updateFull(false);
	    _view->currentView()->currentBuffer()
	      ->text->TableFeatures(LyXTable::SET_PWIDTH, str);
	    _view->currentView()->currentBuffer()->updateFull();
	  }
	}
      }
      return;
      break;
    case TABLETOOLBAR_LONG_NORMAL:
      num = LyXTable::SET_LTNORMAL;
      break;
    case TABLETOOLBAR_LONG_FIRST_HEAD:
      num = LyXTable::SET_LTFIRSTHEAD;
      break;
    case TABLETOOLBAR_LONG_HEAD:
      num = LyXTable::SET_LTHEAD;
      break;
    case TABLETOOLBAR_LONG_FOOT:
      num = LyXTable::SET_LTFOOT;
      break;
    case TABLETOOLBAR_LONG_LAST_FOOT:
      num = LyXTable::SET_LTLASTFOOT;
      break;
    case TABLETOOLBAR_LONG_NEW_PAGE:
      num = LyXTable::SET_LTNEWPAGE;
      break;
    default:
      return;
    }

    if (_view->currentView()->available()){
      _view->currentView()->getScreen()->HideCursor();
      _view->currentView()->currentBuffer()->updateFull(false);
      _view->currentView()->currentBuffer()->text->TableFeatures(num);
      _view->currentView()->currentBuffer()->updateFull();
    }

  }
}

klyx'KLyXToolBarReceiver::charComboIgnore() (./klyx/src/KLyXToolBar.C:755)

void KLyXToolBarReceiver::charComboIgnore(int){
}

klyx'KLyXToolBarReceiver::charUpdate() (./klyx/src/KLyXToolBar.C:758)

void KLyXToolBarReceiver::charUpdate(){
  CharacterStyleDialogData tempdata;
  if(_view->currentView()->available()) {
    tempdata.family = (CharacterStyleDialogData::Family)
      _view->getCharToolbar()->getCombo(CHARTOOLBAR_FAMILY)->currentItem();
    tempdata.series = (CharacterStyleDialogData::Series)
      _view->getCharToolbar()->getCombo(CHARTOOLBAR_SERIES)->currentItem();
    tempdata.shape = (CharacterStyleDialogData::Shape)
      _view->getCharToolbar()->getCombo(CHARTOOLBAR_SHAPE)->currentItem();
    tempdata.size = (CharacterStyleDialogData::Size)
      _view->getCharToolbar()->getCombo(CHARTOOLBAR_SIZE)->currentItem();
    tempdata.misc = (CharacterStyleDialogData::Misc)
      _view->getCharToolbar()->getCombo(CHARTOOLBAR_MISC)->currentItem();
    tempdata.color = (CharacterStyleDialogData::Color)
      _view->getCharToolbar()->getCombo(CHARTOOLBAR_COLOR)->currentItem();
    // If the mask is completely neutral, tell user
    if (tempdata.font() == LyXFont(LyXFont::ALL_IGNORE)){
      _view->getMiniBuffer()->Set(i18n("No font change defined. You may want to "
					 "set some properties in the combo boxes..."));
      return;
    }
    
    _view->currentView()->getScreen()->HideCursor();
    _view->currentView()->currentBuffer()->updateFull(false);
    _view->currentView()->currentBuffer()->text->ToggleFree(tempdata.font());
    _view->currentView()->currentBuffer()->updateFull();
  }
}