void TMenuView::do_a_select( TEvent& event )
{
    putEvent( event );
    event.message.command = owner->execView(this);
    if( event.message.command != 0 && commandEnabled(event.message.command) )
        {
        event.what = evCommand;
        event.message.infoPtr = 0;
        putEvent(event);
        }
    clearEvent(event);
}
Exemplo n.º 2
0
void TDirListBox::handleEvent( TEvent& event )
{
    if( event.what == evMouseDown && event.mouse.doubleClick )
        {
        event.what = evCommand;
        event.message.command = cmChangeDir;
        putEvent( event );
        clearEvent( event );
        }
    else
        TListBox::handleEvent( event );
}
Exemplo n.º 3
0
void TNHexInputLine::handleEvent( TEvent& event )
{
	if( ((state & sfSelected) != 0) &&
		(event.what == evKeyDown) )
		switch( ctrlToArrow( event.keyDown.keyCode ) )
			{
			case kbLeft:
			case kbRight:
			case kbHome:
			case kbEnd:
			case kbBack:
			case kbDel:
			case kbIns:
				break;

			default:
				if( ((event.keyDown.charScan.charCode < 'a') ||
					 (event.keyDown.charScan.charCode > 'f')) &&
					((event.keyDown.charScan.charCode < 'A') ||
					 (event.keyDown.charScan.charCode > 'F')) &&
					isalpha( event.keyDown.charScan.charCode ) )
					{
					clearEvent( event );
					return;
					}

				int num;
				getData( &num );

				if( (event.keyDown.charScan.charCode == '0') &&
					(num == 0) )
					{
					clearEvent( event );
					return;
					}
		}

	TNRightJustInputLine::handleEvent( event );
}
Exemplo n.º 4
0
void TProgram::handleEvent( TEvent& event )
{
    if( event.what == evKeyDown )
        {
        char c = getAltChar( event.keyDown.keyCode );
        if( c >= '1' && c <= '9' )
            {
            if( message( deskTop,
                         evBroadcast,
                         cmSelectWindowNum,
                         (void *)(c - '0')
                       ) != 0 )
                clearEvent( event );
            }
        }

    TGroup::handleEvent( event );
    if( event.what == evCommand && event.message.command == cmQuit )
        {
        endModal( cmQuit );
        clearEvent( event );
        }
}
Exemplo n.º 5
0
void TClickTester::handleEvent(TEvent& event)
{
    TStaticText::handleEvent(event);

    if (event.what == evMouseDown)
        {
        if (event.mouse.doubleClick)
            {
            clicked = (clicked) ? 0 : 1;
            drawView();
            }
        clearEvent(event);
        }
}
Exemplo n.º 6
0
void TNNumericInputLine::handleEvent( TEvent& event )
{
	if( ((state & sfSelected) != 0) &&
		(event.what == evKeyDown) )
		switch( ctrlToArrow( event.keyDown.keyCode ) )
			{
			case kbLeft:
			case kbRight:
			case kbHome:
			case kbEnd:
			case kbBack:
			case kbDel:
			case kbIns:
				break;

			default:
				if( (event.keyDown.charScan.charCode >= ' ') &&
					(event.keyDown.charScan.charCode != '.') &&
					!isdigit( event.keyDown.charScan.charCode ) )
					{
					clearEvent( event );
					return;
					}

				int num;
				getData( &num );

				if( (event.keyDown.charScan.charCode == '0') &&
					(num == 0) )
					{
					clearEvent( event );
					return;
					}
		}

	TNRightJustInputLine::handleEvent( event );
}
Exemplo n.º 7
0
void TStatusLine::handleEvent( TEvent& event )
{
    TView::handleEvent(event);

    switch (event.what)
        {
        case  evMouseDown:
            {
            TStatusItem *T = 0;

            do  {
                TPoint mouse = makeLocal( event.mouse.where );
                if( T != itemMouseIsIn(mouse) )
                    drawSelect( T = itemMouseIsIn(mouse) );
                } while( mouseEvent( event, evMouseMove ) );

            if( T != 0 && commandEnabled(T->command) )
                {
                event.what = evCommand;
                event.message.command = T->command;
                event.message.infoPtr = 0;
                putEvent(event);
                }
            clearEvent(event);
            drawView();
            break;
            }
        case evKeyDown:
            {
            for( TStatusItem *T = items; T != 0; T = T->next )
                {
                if( event.keyDown.keyCode ==  T->keyCode && 
                    commandEnabled(T->command))
                    {
                    event.what = evCommand;
                    event.message.command = T->command;
                    event.message.infoPtr = 0;
                    return;
                    }
            }
            break;
            }
        case evBroadcast:
            if( event.message.command == cmCommandSetChanged )
                drawView();
            break;
        }
}
Exemplo n.º 8
0
void TProgressBar::handleEvent(TEvent& event)
{
    TView::handleEvent(event);
 
    switch(event.what)
    {
    case evKeyboard:
		  mainProcess() ;
		  break;
	 case evBroadcast:
		  if(event.message.command == cmOK)
				mainProcess() ;
		  break;
	 }
	 clearEvent(event);
}
void TMyApp::handleEvent(TEvent& event)
{
    TApplication::handleEvent(event);   // act like base!
    if( event.what == evCommand )
        {
        switch( event.message.command )
            {
            case cmMyNewWin:            // but respond to additional commands
                myNewWindow();          // define action for cmMyNewWin                                // command
                break;
            default:
                return;
            }
        clearEvent( event );            // clear event after handling
        }
}
Exemplo n.º 10
0
void TMyApp::handleEvent(TEvent& event)
 {
  TApplication::handleEvent(event);
  if( event.what == evCommand )
      {
	switch( event.message.command )
	    {
	     case cmInputBox:
	       inputBox();
	      break;

	     default:
	      return;
	    }
	clearEvent( event );
      }
 }
void TChDirDialog::handleEvent( TEvent& event )
{
    TDialog::handleEvent( event );
    switch( event.what )
        {
        case evCommand:
            {
            char curDir[PATH_MAX];
            switch( event.message.command )
                {
                case cmRevert:
                    getCurDir( curDir );
                    break;
                case cmChangeDir:
                    {
                    TDirEntry *p = dirList->list()->at( dirList->focused );
                    strcpy( curDir, p->dir() );
			/* SS: changed */
                        if( curDir[strlen(curDir)-1] != '/' )
                            strcat( curDir, "/" );
                    break;
                    }
#ifndef __UNPATCHED
		//!! Handle directory selection.
                case cmDirSelection:
                    chDirButton->makeDefault( (Boolean) event.message.infoPtr );
                    return;     // NOTE: THIS IS RETURN NOT BREAK!!
#endif
                default:
                    return;
                }
            dirList->newDirectory( curDir );
            int len = strlen( curDir );
	    /* SS: changed */
            if( len > 0 && curDir[len-1] == '/' )
                curDir[len-1] = EOS;
            strcpy( dirInput->data, curDir );
            dirInput->drawView();
            dirList->select();
            clearEvent( event );
            }
        default:
            break;
        }
}
Exemplo n.º 12
0
void TMouseDialog::handleEvent(TEvent& event)
{
    TDialog::handleEvent(event);
    switch(event.what)
        {
        case evCommand:
            if(event.message.command == cmCancel)
                TEventQueue::doubleDelay = oldDelay;
            break;

        case evBroadcast:
            if(event.message.command == cmScrollBarChanged)
                {
                TEventQueue::doubleDelay = mouseScrollBar->value;
                clearEvent(event);
                }
            break;
        }
}
Exemplo n.º 13
0
void TDeskTop::handleEvent(TEvent& event)
{
    TGroup::handleEvent( event );
    if( event.what == evCommand )
        {
        switch( event.message.command )
            {
            case cmNext:
                selectNext( False );
                break;
            case cmPrev:
                current->putInFrontOf( background );
                break;
            default:
                return;
            }
        clearEvent( event );
        }
}
Exemplo n.º 14
0
void TMyApp::handleEvent(TEvent& event)
{
    TApplication::handleEvent(event);
    if( event.what == evCommand )
    {
        switch( event.message.command )
        {
        case cmMyNewWin:
            newWindow();
            break;
        case cmNewDialog:
            newDialog();
            break;
        default:
            return;
        }
        clearEvent( event );            // clear event after handling
    }
}
Exemplo n.º 15
0
void TitleWindow::handleEvent(MVEvent& event,phaseType)
/****************************************************************************
*
* Function:     TitleWindow::handleEvent
* Parameters:   event   - Event to handle
*               phase   - Current phase for the event (pre,focus,post)
*
* Description:  Event handling routine for the TitleWindow class. Here
*               we handle events that change the text in the window.
*
****************************************************************************/
{
    if (event.what == evBroadcast) {
        if (event.message.command == cmSetDemoTitle) {
            title->setText((const char *)event.message.infoPtr);
            clearEvent(event);
            }
        }
}
void TVDemo::getEvent(TEvent &event)
{
    TWindow *w;
    THelpFile *hFile;
    fpstream *helpStrm;
    static Boolean helpInUse = False;

    TApplication::getEvent(event);
    switch (event.what)
        {
        case evCommand:
            if ((event.message.command == cmHelp) && ( helpInUse == False)) 
                {
                helpInUse = True;
                helpStrm = new fpstream("DEMOHELP.HLP", ios::in|ios::binary);
                hFile = new THelpFile(*helpStrm);
                if (!helpStrm)
                    {
                    messageBox("Could not open help file", mfError | mfOKButton);
                    delete hFile;
                    }
                else
                    {
                    w = new THelpWindow(hFile, getHelpCtx());
                    if (validView(w) != 0)
                        {
                        execView(w);
                        destroy( w );
                        }
                    clearEvent(event);
                    }
                helpInUse = False;
                }
            break;
        case evMouseDown:
            if (event.mouse.buttons != 1)
                event.what = evNothing;
            break;
        }

}  
Exemplo n.º 17
0
void TFileEditor::handleEvent( TEvent& event )
{
    TEditor::handleEvent(event);
    switch( event.what )
        {
        case evCommand:
            switch( event.message.command )
                {
                case cmSave:
                    save();
                    break;
                case cmSaveAs:
                    saveAs();
                    break;
                default:
                    return;
                }
            break;
        default:
            return;
        }
    clearEvent(event);
}
void TMenuView::handleEvent( TEvent& event )
{
    if( menu != 0 )
        switch (event.what)
            {
            case  evMouseDown:
                do_a_select(event);
                break;
            case  evKeyDown:
                if( findItem(getAltChar(event.keyDown.keyCode)) != 0 )
                    do_a_select(event);
                else
                    {
                    TMenuItem *p = hotKey(event.keyDown.keyCode);
                    if( p != 0 && commandEnabled(p->command))
                        {
                        event.what = evCommand;
                        event.message.command = p->command;
                        event.message.infoPtr = 0;
                        putEvent(event);
                        clearEvent(event);
                        }
                    }
                break;
            case  evCommand:
                if( event.message.command == cmMenu )
                    do_a_select(event);
                break;
            case  evBroadcast:
                if( event.message.command == cmCommandSetChanged )
                    {
                    if( updateMenu(menu) )
                        drawView();
                    }
                break;
            }
}
ushort TMenuView::execute()
{
    Boolean    autoSelect = False;
    menuAction action;
    char   ch;
    ushort result = 0;
    TMenuItem *itemShown = 0;
    TMenuItem *p;
    TMenuView *target;
    TRect  r;
    TEvent e;

    current = menu->deflt;
    do  {
        action = doNothing;
        getEvent(e);
        switch (e.what)
            {
            case  evMouseDown:
                if( mouseInView(e.mouse.where) || mouseInOwner(e) )
                    {
                    trackMouse(e);
                    if( size.y == 1 )
                        autoSelect = True;
                    }
                else
                    action =  doReturn;
                break;
            case  evMouseUp:
                trackMouse(e);
                if( mouseInOwner(e) )
                    current = menu->deflt;
                else if( current != 0 && current->name != 0 )
                    action = doSelect;
                else
                    action = doReturn;
                break;
            case  evMouseMove:
                if( e.mouse.buttons != 0 )
                    {
                    trackMouse(e);
                    if( !(mouseInView(e.mouse.where) || mouseInOwner(e)) &&
                        mouseInMenus(e) )
                        action = doReturn;
                    }
                break;
            case  evKeyDown:
                switch( ctrlToArrow(e.keyDown.keyCode) )
                    {
                    case  kbUp:
                    case  kbDown:
                        if( size.y != 1 )
                            trackKey(Boolean(ctrlToArrow(e.keyDown.keyCode) == kbDown));
                        else if( e.keyDown.keyCode == kbDown )
                            autoSelect =  True;
                        break;
                    case  kbLeft:
                    case  kbRight:
                        if( parentMenu == 0 )
                            trackKey(Boolean(ctrlToArrow(e.keyDown.keyCode) == kbRight));
                        else
                            action =  doReturn;
                        break;
                    case  kbHome:
                    case  kbEnd:
                        if( size.y != 1 )
                            {
                            current = menu->items;
                            if( e.keyDown.keyCode == kbEnd )
                                trackKey(False);
                            }
                        break;
                    case  kbEnter:
                        if( size.y == 1 )
                            autoSelect =  True;
                        action = doSelect;
                        break;
                    case  kbEsc:
                        action = doReturn;
                        if( parentMenu == 0 || parentMenu->size.y != 1 )
                            clearEvent(e);
                        break;
                    default:
                        target = this;
                        ch = getAltChar(e.keyDown.keyCode);
                        if( ch == 0 )
                            ch = e.keyDown.charScan.charCode;
                        else
                            target = topMenu();
                        p = target->findItem(ch);
                        if( p == 0 )
                            {
                            p = topMenu()->hotKey(e.keyDown.keyCode);
                            if( p != 0 && commandEnabled(p->command) )
                                {
                                result = p->command;
                                action = doReturn;
                                }
                            }
                        else if( target == this )
                            {
                            if( size.y == 1 )
                                autoSelect = True;
                            action = doSelect;
                            current = p;
                            }
                        else if( parentMenu != target ||
                                 parentMenu->current != p )
                                action = doReturn;
                    }
                break;
            case  evCommand:
                if( e.message.command == cmMenu )
                    {
                    autoSelect = False;
                    if (parentMenu != 0 )
                        action = doReturn;
                    }
                else
                    action = doReturn;
                break;
            }

        if( itemShown != current )
            {
            itemShown =  current;
            drawView();
            }

        if( (action == doSelect || (action == doNothing && autoSelect)) &&
            current != 0 &&
            current->name != 0 )
                if( current->command == 0 )
                    {
                    if( (e.what & (evMouseDown | evMouseMove)) != 0 )
                        putEvent(e);
                    r = getItemRect( current );
                    r.a.x = r.a.x + origin.x;
                    r.a.y = r.b.y + origin.y;
                    r.b = owner->size;
                    if( size.y == 1 )
                        r.a.x--;
                    target = topMenu()->newSubView(r, current->subMenu,this);
                    result = owner->execView(target);
                    destroy( target );
                    }
                else if( action == doSelect )
                    result = current->command;

        if( result != 0 && commandEnabled(result) )
            {
            action =  doReturn;
            clearEvent(e);
            }
        } while( action != doReturn );

    if( e.what != evNothing &&
        (parentMenu != 0 || e.what == evCommand))
            putEvent(e);
    if( current != 0 )
        {
        menu->deflt = current;
        current = 0;
        drawView();
        }
    return result;
}
void TCluster::handleEvent( TEvent& event )
{
    TView::handleEvent(event);
    if( event.what == evMouseDown )
        {
        TPoint mouse = makeLocal( event.mouse.where );
        int i = findSel(mouse);
        if( i != -1 )
            sel = i;
        drawView();
        do  {
            mouse = makeLocal( event.mouse.where );
            if( findSel(mouse) == sel )
                showCursor();
            else
                hideCursor();
            } while( mouseEvent(event,evMouseMove) );
        showCursor();
        mouse = makeLocal( event.mouse.where );
        if( findSel(mouse) == sel )
            {
            press(sel);
            drawView();
            }
        clearEvent(event);
        }
    else if( event.what == evKeyDown )
        switch (ctrlToArrow(event.keyDown.keyCode))
            {
            case kbUp:
                if( (state & sfFocused) != 0 )
                    {
                    if( --sel < 0 )
                        sel = strings->getCount()-1;
                    movedTo(sel);
                    drawView();
                    clearEvent(event);
                    }
                break;

            case kbDown:
                if( (state & sfFocused) != 0 )
                    {
                    if( ++sel >= strings->getCount() )
                        sel = 0;
                    movedTo(sel);
                    drawView();
                    clearEvent(event);
                    }
                break;
            case kbRight:
                if( (state & sfFocused) != 0 )
                    {
                    sel += size.y;
                    if( sel >= strings->getCount() )
                        {
                        sel = (sel +  1) % size.y;
                        if( sel >= strings->getCount() )
                            sel =  0;
                        }
                    movedTo(sel);
                    drawView();
                    clearEvent(event);
                    }
                break;
            case kbLeft:
                if( (state & sfFocused) != 0 )
                    {
                    if( sel > 0 )
                        {
                        sel -= size.y;
                        if( sel < 0 )
                            {
                            sel = ((strings->getCount()+size.y-1) /size.y)*size.y + sel - 1;
                            if( sel >= strings->getCount() )
                                sel = strings->getCount()-1;
                            }
                        }
                    else
                        sel = strings->getCount()-1;
                    movedTo(sel);
                    drawView();
                    clearEvent(event);
                    }
                break;
            default:
                for( int i = 0; i < strings->getCount(); i++ )
                    {
                    char c = hotKey( (char *)(strings->at(i)) );
                    if( getAltCode(c) == event.keyDown.keyCode ||
                        ( ( owner->phase == phPostProcess ||
                            (state & sfFocused) != 0
                          ) &&
                          c != 0 &&
                          toupper(event.keyDown.charScan.charCode) == c
                        )
                      )
                        {
                        select();
                        sel =  i;
                        movedTo(sel);
                        press(sel);
                        drawView();
                        clearEvent(event);
                        return;
                        }
                    }
                if( event.keyDown.charScan.charCode == ' ' &&
                    (state & sfFocused) != 0
                  )
                    {
                    press(sel);
                    drawView();
                    clearEvent(event);
                    }
            }
}
Exemplo n.º 21
0
void TCluster::handleEvent(TEvent &event) {
   TView::handleEvent(event);
   if (!(options & ofSelectable))
      return;
   if (event.what == evMouseDown) {
      TPoint mouse = makeLocal(event.mouse.where);
      int i = findSel(mouse);
      if ((i != -1) && buttonState(i))
         sel = i;
      drawView();
      do  {
         mouse = makeLocal(event.mouse.where);
         if ((findSel(mouse) == sel) && buttonState(sel))
            showCursor();
         else
            hideCursor();
      } while (mouseEvent(event, evMouseMove));
      showCursor();
      mouse = makeLocal(event.mouse.where);
      if (findSel(mouse) == sel) {
         press(sel);
         drawView();
      }
      clearEvent(event);
   } else if (event.what == evKeyDown) {
      int s = sel;
      switch (ctrlToArrow(event.keyDown.keyCode)) {
      case kbUp:
         if ((state & sfFocused) != 0) {
            int i = 0;
            do {
               i++; s--;
               if (s < 0)
                  s = strings->getCount() - 1;
            } while (!(buttonState(s) || (i > strings->getCount())));
            moveSel(i, s);
            clearEvent(event);
         }
         break;

      case kbDown:
         if ((state & sfFocused) != 0) {
            int i = 0;
            do {
               i++; s++;
               if (s >= strings->getCount())
                  s = 0;
            } while (!(buttonState(s) || (i > strings->getCount())));
            moveSel(i, s);
            clearEvent(event);
         }
         break;
      case kbRight:
         if ((state & sfFocused) != 0) {
            int i = 0;
            do {
               i++; s += size.y;
               if (s >= strings->getCount()) {   // BUG FIX - EFW - 10/25/94
                  s = (s +  1) % size.y;
                  if (s >= strings->getCount())
                     s =  0;
               }
            } while (!(buttonState(s) || (i > strings->getCount())));

            moveSel(i, s);    // BUG FIX - EFW - 10/25/94

            clearEvent(event);
         }
         break;
      case kbLeft:
         if ((state & sfFocused) != 0) {
            int i = 0;
            do {
               i++;
               if (s > 0) {
                  s -= size.y;
                  if (s < 0) {
                     s = ((strings->getCount() + size.y - 1) /
                          size.y) * size.y + s - 1;
                     if (s >= strings->getCount())
                        s = strings->getCount() - 1;
                  }
               } else
                  s = strings->getCount() - 1;

            } while (!(buttonState(s) || (i > strings->getCount())));

            moveSel(i, s);    // BUG FIX - EFW - 10/25/94
            clearEvent(event);
         }
         break;
      default:
         for (int i = 0; i < strings->getCount(); i++) {
            char c = hotKey((char *)(strings->at(i)));
            if (getAltCode(c) == event.keyDown.keyCode ||
                  ((owner->phase == phPostProcess ||
                    (state & sfFocused) != 0
                   ) &&
                   c != 0 &&
                   toupper(event.keyDown.charScan.charCode) == c
                  )
               ) {
               if (buttonState(i)) {
                  if (focus()) {
                     sel = i;
                     movedTo(sel);
                     press(sel);
                     drawView();
                  }
                  clearEvent(event);
               }
               return;
            }
         }
         if (event.keyDown.charScan.charCode == ' ' &&
               (state & sfFocused) != 0
            ) {
            press(sel);
            drawView();
            clearEvent(event);
         }
      }
   }
}
Exemplo n.º 22
0
void TOutlineViewer::handleEvent(TEvent &event) {
   const int mouseAutoToSkip = 3;

   TPoint mouse;
   TNode *cur;
   int newFocus;
   int count;
   char *graph;
   uchar dragged;

   TScroller::handleEvent(event);
   switch (event.what) {
   case evMouseDown:
      count = 0;
      dragged = 0;
      do {
         if (dragged < 2)
            dragged++;
         mouse = makeLocal(event.mouse.where);
         if (mouseInView(event.mouse.where))
            newFocus = delta.y + mouse.y;
         else {
            if (event.what == evMouseAuto)
               count++;
            if (count == mouseAutoToSkip) {
               count = 0;
               if (mouse.y < 0)
                  newFocus--;
               if (mouse.y >= size.y)
                  newFocus++;
            }
         }
         if (foc != newFocus) {
            adjustFocus(newFocus);
            drawView();
         }
      } while (!(event.mouse.eventFlags & meDoubleClick) &&
               mouseEvent(event, evMouseMove + evMouseAuto));

      if (event.mouse.eventFlags & meDoubleClick)
         selected(foc);
      else {
         if (dragged < 2) {
            cur = firstThat(isFocused);
            graph = getGraph(focLevel, focLines, focFlags);
            if (mouse.x < strlen(graph)) {
               adjust(cur, ! isExpanded(cur) ? True : False);
               update();
               drawView();
            }
            delete graph;
         }
      }

      break;

   case evKeyboard:

      newFocus = foc;
      switch (ctrlToArrow(event.keyDown.keyCode)) {
      case kbUp:
      case kbLeft:
         newFocus--;
         break;
      case kbDown:
      case kbRight:
         newFocus++;
         break;
      case kbPgDn:
         newFocus += size.y - 1;
         break;
      case kbPgUp:
         newFocus -= size.y - 1;
         break;
      case kbHome:
         newFocus = delta.y;
         break;
      case kbEnd:
         newFocus = delta.y + size.y - 1;
         break;
      case kbCtrlPgUp:
         newFocus = 0;
         break;
      case kbCtrlPgDn:
         newFocus = limit.y - 1;
         break;
      case kbCtrlEnter:
      case kbEnter:
         selected(newFocus);
         break;
      default:
         uchar code = event.keyDown.charScan.charCode;
         switch (code) {
         case '-':
         case '+':
            adjust(getNode(newFocus), code == '+' ? True : False);
            break;
         case '*':
            expandAll(getNode(newFocus));
            break;
         default:
            return;
         }
         update();
      }
      clearEvent(event);
      adjustFocus(newFocus);
      drawView();
   };
};
Exemplo n.º 23
0
void TEditor::handleEvent( TEvent& event )
{
    TView::handleEvent( event );
    convertEvent( event );
    Boolean centerCursor = Boolean(!cursorVisible());
    uchar selectMode = 0;

    if( selecting == True || (getShiftState() & 0x03) != 0 )
        selectMode = smExtend;

    switch( event.what )
        {

        case evMouseDown:
            if( event.mouse.doubleClick == True )
                selectMode |= smDouble;

            do  {
                lock();
                if( event.what == evMouseAuto )
                    {
                    TPoint mouse = makeLocal( event.mouse.where );
                    TPoint d = delta;
                    if( mouse.x < 0 )
                        d.x--;
                    if( mouse.x >= size.x )
                        d.x++;
                    if( mouse.y < 0 )
                        d.y--;
                    if( mouse.y >= size.y )
                        d.y++;
                    scrollTo(d.x, d.y);
                    }
                setCurPtr(getMousePtr(event.mouse.where), selectMode);
                selectMode |= smExtend;
                unlock();
                } while( mouseEvent(event, evMouseMove + evMouseAuto) );
            break;

        case evKeyDown:
            if( event.keyDown.charScan.charCode == 9 ||
                ( event.keyDown.charScan.charCode >= 32 && event.keyDown.charScan.charCode < 255 ) )
                    {
                    lock();
                    if( overwrite == True && hasSelection() == False )
                        if( curPtr != lineEnd(curPtr) )
                            selEnd = nextChar(curPtr);
                    insertText( &event.keyDown.charScan.charCode, 1, False);
                    trackCursor(centerCursor);
                    unlock();
                    }
            else
                return;
            break;

        case evCommand:
            switch( event.message.command )
                {
                case cmFind:
                    find();
                    break;
                case cmReplace:
                    replace();
                    break;
                case cmSearchAgain:
                    doSearchReplace();
                    break;
                default:
                    lock();
                    switch( event.message.command )
                        {
                        case cmCut:
                            clipCut();
                            break;
                        case cmCopy:
                            clipCopy();
                            // hideSelect(); // JS 12.4.94
                            break;
                        case cmPaste:
                            clipPaste();
                            break;
                        case cmUndo:
                            undo();
                            break;
                        case cmClear:
                            deleteSelect();
                            break;
                        case cmCharLeft:
                            setCurPtr(prevChar(curPtr), selectMode);
                            break;
                        case cmCharRight:
                            setCurPtr(nextChar(curPtr), selectMode);
                            break;
                        case cmWordLeft:
                            setCurPtr(prevWord(curPtr), selectMode);
                            break;
                        case cmWordRight:
                            setCurPtr(nextWord(curPtr), selectMode);
                            break;
                        case cmLineStart:
                            setCurPtr(lineStart(curPtr), selectMode);
                            break;
                        case cmLineEnd:
                            setCurPtr(lineEnd(curPtr), selectMode);
                            break;
                        case cmLineUp:
                            setCurPtr(lineMove(curPtr, -1), selectMode);
                            break;
                        case cmLineDown:
                            setCurPtr(lineMove(curPtr, 1), selectMode);
                            break;
                        case cmPageUp:
                            setCurPtr(lineMove(curPtr, -(size.y-1)), selectMode);
                            break;
                        case cmPageDown:
                            setCurPtr(lineMove(curPtr, size.y-1), selectMode);
                            break;
                        case cmTextStart:
                            setCurPtr(0, selectMode);
                            break;
                        case cmTextEnd:
                            setCurPtr(bufLen, selectMode);
                            break;
                        case cmNewLine:
                            newLine();
                            break;
                        case cmBackSpace:
                            deleteRange(prevChar(curPtr), curPtr, True);
                            break;
                        case cmDelChar:
                            deleteRange(curPtr, nextChar(curPtr), True);
                            break;
                        case cmDelWord:
                            deleteRange(curPtr, nextWord(curPtr), False);
                            break;
                        case cmDelStart:
                            deleteRange(lineStart(curPtr), curPtr, False);
                            break;
                        case cmDelEnd:
                            deleteRange(curPtr, lineEnd(curPtr), False);
                            break;
                        case cmDelLine:
                            deleteRange(lineStart(curPtr), nextLine(curPtr), False);
                            break;
                        case cmInsMode:
                            toggleInsMode();
                            break;
                        case cmStartSelect:
                            startSelect();
                            break;
                        case cmHideSelect:
                            hideSelect();
                            break;
                        case cmIndentMode:
                            autoIndent = Boolean(!autoIndent);
                            break;
                        default:
                            unlock();
                            return;
                        }
                    trackCursor(centerCursor);
                    unlock();
                    break;
                }

        case evBroadcast:
            switch( event.message.command )
                {
                case cmScrollBarChanged:
                    checkScrollBar( event, hScrollBar, delta.x );
                    checkScrollBar( event, vScrollBar, delta.y );
                    break;
                default:
                    return;
                }
        }
    clearEvent(event);
}
Exemplo n.º 24
0
void TListViewer::handleEvent(TEvent &event) {
   TPoint mouse;
   ushort colWidth;
   int oldItem, newItem;
   int count;
   int mouseAutosToSkip = 4;

   TView::handleEvent(event);

   if (event.what == evMouseDown) {
      colWidth = size.x / numCols + 1;
      oldItem =  focused;
      mouse = makeLocal(event.mouse.where);
      if (mouseInView(event.mouse.where))
         newItem = mouse.y + (size.y * (mouse.x / colWidth)) + topItem;
      else
         newItem = oldItem;
      count = 0;
      do  {
         if (newItem != oldItem) {
            focusItemNum(newItem);
            drawView();
         }
         oldItem = newItem;
         mouse = makeLocal(event.mouse.where);
         if (mouseInView(event.mouse.where))
            newItem = mouse.y + (size.y * (mouse.x / colWidth)) + topItem;
         else {
            if (numCols == 1) {
               if (event.what == evMouseAuto)
                  count++;
               if (count == mouseAutosToSkip) {
                  count = 0;
                  if (mouse.y < 0)
                     newItem = focused - 1;
                  else if (mouse.y >= size.y)
                     newItem = focused + 1;
               }
            } else {
               if (event.what == evMouseAuto)
                  count++;
               if (count == mouseAutosToSkip) {
                  count = 0;
                  if (mouse.x < 0)
                     newItem = focused - size.y;
                  else if (mouse.x >= size.x)
                     newItem = focused + size.y;
                  else if (mouse.y < 0)
                     newItem = focused - focused % size.y;
                  else if (mouse.y > size.y)
                     newItem = focused - focused % size.y + size.y - 1;
               }
            }
         }
         if (event.mouse.eventFlags & meDoubleClick)
            break;
      } while (mouseEvent(event, evMouseMove | evMouseAuto));
      focusItemNum(newItem);
      drawView();
      if ((event.mouse.eventFlags & meDoubleClick) && range > newItem)
         selectItem(newItem);
      clearEvent(event);
   } else if (event.what == evKeyDown) {
      if (event.keyDown.charScan.charCode ==  ' ' && focused < range) {
         selectItem(focused);
         newItem = focused;
      } else {
         switch (ctrlToArrow(event.keyDown.keyCode)) {
            case kbUp:
               newItem = focused - 1;
               break;
            case kbDown:
               newItem = focused + 1;
               break;
            case kbRight:
               if (numCols > 1)
                  newItem = focused + size.y;
               else
                  return;
               break;
            case kbLeft:
               if (numCols > 1)
                  newItem = focused - size.y;
               else
                  return;
               break;
            case kbPgDn:
               newItem = focused + size.y * numCols;
               break;
            case  kbPgUp:
               newItem = focused - size.y * numCols;
               break;
            case kbHome:
               newItem = topItem;
               break;
            case kbEnd:
               newItem = topItem + (size.y * numCols) - 1;
               break;
            case kbCtrlPgDn:
               newItem = range - 1;
               break;
            case kbCtrlPgUp:
               newItem = 0;
               break;
            default:
               return;
         }
      }
      focusItemNum(newItem);
      drawView();
      clearEvent(event);
   } else if (event.what == evBroadcast) {
      if ((options & ofSelectable) != 0) {
         if (event.message.command == cmScrollBarClicked &&
            (event.message.infoPtr == hScrollBar ||
               event.message.infoPtr == vScrollBar))
                  focus();        // BUG FIX                  <<------ Change
         else 
         if (event.message.command == cmScrollBarChanged) {
            if (vScrollBar == event.message.infoPtr) {
               focusItemNum(vScrollBar->value);
               drawView();
            } else if (hScrollBar == event.message.infoPtr)
               drawView();
         }
      }
   }
}
void TWindow::handleEvent( TEvent& event )
{
 TRect  limits;
 TPoint min, max;

    TGroup::handleEvent(event);
    if( event.what== evCommand )
        switch (event.message.command)
            {
            case  cmResize:
                if( (flags & (wfMove | wfGrow)) != 0 )
                    {
                    limits = owner->getExtent();
                    sizeLimits(min, max);
                    dragView( event, dragMode | (flags & (wfMove | wfGrow)),
                              limits, min, max);
                    clearEvent(event);
                    }
                break;
            case  cmClose:
                if( (flags & wfClose) != 0 &&
                    ( event.message.infoPtr == 0 || event.message.infoPtr == this )
                  )
                    {
		    clearEvent(event);
                    if( (state & sfModal) == 0 )
                        close();
                    else
                        {
                        event.what = evCommand;
                        event.message.command = cmCancel;
                        putEvent( event );
                        clearEvent( event );
                        }
                    }
                break;
            case  cmZoom:
                if( (flags & wfZoom) != 0 &&
                    (event.message.infoPtr == 0 || event.message.infoPtr == this)
                  )
                    {
                    zoom();
                    clearEvent(event);
                    }
                break;
            }
    else if( event.what == evKeyDown )
            switch (event.keyDown.keyCode)
                {
                case  kbTab:
                    focusNext(False);
                    clearEvent(event);
                    break;
                case  kbShiftTab:
                    focusNext(True);
                    clearEvent(event);
                    break;
                }
    else if( event.what == evBroadcast &&
             event.message.command == cmSelectWindowNum &&
		/*
		 * Some non-portable code changed.  See `TProgram.cc'.
		 */
		(int)event.message.infoPtr == number &&
//             event.message.infoInt == number &&
             (options & ofSelectable) != 0
           )
            {
            select();
            clearEvent(event);
            }
}
Exemplo n.º 26
0
void TMyApp::handleEvent(TEvent& event) {
    TApplication::handleEvent(event); // act like base!
    if (event.what == evCommand) {
        switch (event.message.command) {
        case cmMyNewWin:
            myNewWindow();
            break;
        case cmAboutCmd:
            aboutDlgBox();
            break;
        case cmCalendarCmd:
            calendar();
            break;
        case cmAsciiCmd:
            asciiTable();
            break;
        case cmCalcCmd:
            calculator();
            break;
        case cmPuzzleCmd:
            puzzle();
            break;
        case cmTile:
            tile();
            break;
        case cmCascade:
            cascade();
            break;
        case cmCO128x75:
            setVideoMode(TScreen::smCO128x75);
            break;
        case cmCO128x60:
            setVideoMode(TScreen::smCO128x60);
            break;
        case cmCO128x37:
            setVideoMode(TScreen::smCO128x37);
            break;
        case cmCO113x75:
            setVideoMode(TScreen::smCO113x75);
            break;
        case cmCO113x37:
            setVideoMode(TScreen::smCO113x37);
            break;
        case cmCO102x30:
            setVideoMode(TScreen::smCO102x30);
            break;
        case cmCO85x37:
            setVideoMode(TScreen::smCO85x37);
            break;
        case cmCO85x26:
            setVideoMode(TScreen::smCO85x26);
            break;
        case cmCO85x25:
            setVideoMode(TScreen::smCO85x25);
            break;
        case cmCO85x22:
            setVideoMode(TScreen::smCO85x22);
            break;
        case cmCO73x20:
            setVideoMode(TScreen::smCO73x20);
            break;
        case cmCO64x18:
            setVideoMode(TScreen::smCO64x18);
            break;
        case cmCO64x16:
            setVideoMode(TScreen::smCO64x16);
            break;
        case cmCO40x22:
            setVideoMode(TScreen::smCO40x22);
            break;
        default:
            return;
        }
        clearEvent(event); // clear event after handling
    }
}
Exemplo n.º 27
0
void MVListBase::handleEvent(MVEvent& event,phaseType phase)
/****************************************************************************
*
* Function:     MVListBase::handleEvent
* Parameters:   event   - Event to handle
*               phase   - Current phase for the event (pre,focus,post)
*
* Description:  Event handling mechanism for the MVListBase class.
*
****************************************************************************/
{
    MVView::handleEvent(event,phase);

    switch (event.what) {
        case evMouseDown:
            if (range.isEmpty())
                return;

            if (event.mouse.buttons & mbLeftButton) {
                while (event.what != evMouseUp) {
                    switch (event.what) {
                        case evMouseDown:
                            if (!(event.mouse.modifiers & mdShift)
                                    && !(flags & lsDisjointSelect)) {
                                clearSelection();
                                selectCell(cursor);
                                refresh();
                                }
                            if (event.mouse.doubleClick) {
                                MV_message(owner,evBroadcast,cmListItemSelected,this);
                                goto doneMouse;
                                }
                        case evMouseAuto:
                        case evMouseMove:
                            MVPoint loc;
                            uint    modifiers = mdShift;

                            if (event.what == evMouseDown)
                                modifiers = event.mouse.modifiers;
                            if (flags & lsDisjointSelect)
                                modifiers = 0;

                            uint pos = findCellHit(event.where,loc);
                            if (pos == lsInside && event.what != evMouseAuto) {
                                // Selection within the list
                                if (loc == cursor && event.what == evMouseDown) {
                                    // Post a message to ensure updates
                                    // occur for the first mouse down event
                                    // in the list box.
                                    MV_message(owner,evBroadcast,
                                        cmListCursorChanged,this);
                                    }

                                if (loc.x < cursor.x)
                                    selectLeft(cursor.x - loc.x,modifiers);
                                else if (loc.x > cursor.x)
                                    selectRight(loc.x - cursor.x,modifiers);

                                if (loc.y < cursor.y)
                                    selectUp(cursor.y - loc.y,modifiers);
                                else if (loc.y > cursor.y)
                                    selectDown(loc.y - cursor.y,modifiers);
                                }
                            else if (event.what == evMouseAuto) {
                                // Auto selection outside window to scroll
                                if (pos & lsAbove)
                                    selectUp(1,modifiers);
                                if (pos & lsBelow)
                                    selectDown(1,modifiers);
                                if (pos & lsLeft)
                                    selectLeft(1,modifiers);
                                if (pos & lsRight)
                                    selectRight(1,modifiers);
                                }
                            if (event.what == evMouseDown
                                    && flags & lsDisjointSelect) {
                                toggleCell(cursor);
                                refresh();
                                }
                            break;
                        }
                    getEvent(event);
                    }

doneMouse:
                clearEvent(event);
                }
            break;
        case evKeyDown:
        case evKeyAuto:
            if (range.isEmpty())
                return;

            switch (event.key.charScan.scanCode) {
                case kbSpace:
                    if (event.what == evKeyAuto)
                        break;
                    if (flags & lsDisjointSelect) {
                        toggleCell(cursor);
                        refresh();
                        }
                    break;
                case kbLeft:
                    selectLeft(1,event.key.modifiers);
                    break;
                case kbRight:
                    selectRight(1,event.key.modifiers);
                    break;
                case kbUp:
                    selectUp(1,event.key.modifiers);
                    break;
                case kbDown:
                    selectDown(1,event.key.modifiers);
                    break;
                case kbHome:
                    selectNext(lsLeft | lsAbove,range.bottom(),
                        event.key.modifiers);
                    break;
                case kbEnd:
                    selectNext(lsRight | lsBelow,range.bottom(),
                        event.key.modifiers);
                    break;
                case kbPgUp:
                    selectUp(visible.bottom()-visible.top(),
                        event.key.modifiers,true);
                    break;
                case kbPgDn:
                    selectDown(visible.bottom()-visible.top(),
                        event.key.modifiers,true);
                default:
                    // Key press is not handled by us, so simply return.
                    return;
                }
            clearEvent(event);
            break;
        case evBroadcast:
            if (options & ofSelectable) {
                if (event.message.command == cmScrollBarClicked &&
                        (event.message.infoPtr == hScroll ||
                         event.message.infoPtr == vScroll))
                    select();
                else if (event.message.command == cmScrollBarChanged) {
                    if (range.isEmpty())
                        return;
                    if (event.message.infoPtr == hScroll)
                        hScrollTo(hScroll->getValue());
                    else if (event.message.infoPtr == vScroll)
                        vScrollTo(vScroll->getValue());
                    }
                }
            break;
        }
}
Exemplo n.º 28
0
//*****************************************************************
// a single mouse click is not cleared by List View Box, Dialog uses it
// to erase inputline if user clicks off of it .
void TListViewDialog::handleEvent(TEvent &event) {
   AllocLocalStr(b,inputLineLen);

	switch(event.what)
	{
	  case evMouseDown:  // clears input line
			if (inputLine->state&sfSelected) {
				inputLine->hide();
			}
			break;
	  case evKeyDown:
		  switch(event.keyDown.keyCode)
		  {
		  case kbEsc:  // clears input line
			if (inputLine->state&sfSelected) {
				inputLine->hide();
				clearEvent(event);
			}
			break;
		  case kbEnter: // saves input line to list box using listBoxPtr
			if (inputLine->state&sfSelected) {
				listBoxPtr->putData( (void *)inputLine->getData() );
				inputLine->hide();
				clearEvent(event);
			}
			break;
	  }
	 case evBroadcast: // from List Boxes, infoPtr points to orginator
	   switch (event.message.command)
	   {
		case cmListItemSelected: // if input line is already showing, hide it
			if (inputLine->state&sfSelected) {
				inputLine->hide();
				clearEvent(event);
			}
			else {  // show empty input line
				int mouseLocY =((TListViewBox *)event.message.infoPtr)->cursor.y ;
				int mouseLocX =((TListViewBox *)event.message.infoPtr)->origin.x ;
				listBoxPtr =(TListViewBox *)event.message.infoPtr;
				inputLine->moveTo(mouseLocX, mouseLocY+2);
				inputLine->setDataFromStr( (void *)"        " );
				inputLine->show();
				clearEvent(event);
			}
			break;
		case cmListKeyEnter: // enter key pressed in list box, copy data to inputline
			int mouseLocY =((TListViewBox *)event.message.infoPtr)->cursor.y ;
			int mouseLocX =((TListViewBox *)event.message.infoPtr)->origin.x ;
			listBoxPtr =(TListViewBox *)event.message.infoPtr;
			inputLine->moveTo(mouseLocX, mouseLocY+2);
			listBoxPtr->getText( b,listBoxPtr->focused,inputLineLen );
			inputLine->setDataFromStr( b );
			inputLine->show();
			clearEvent(event);
			break;
	   }
	}
	// Let TDialog handler do it's thing with any remaining events.
	TDialog::handleEvent(event);
	sprintf(b,"%d",listBox->focused);
	itemNumber->setDataFromStr( b );
	itemNumber->draw();
} // end of MyDialogBox::eventHandler()
Exemplo n.º 29
0
void MVScrollBar::handleEvent(MVEvent& event,phaseType phase)
/****************************************************************************
*
* Function:		MVScrollBar::handleEvent
* Parameters:	event	- Event to handle
*				phase	- Current phase for the event (pre,focus,post)
*
* Description:	Event handling routine for scroll bars.
*
****************************************************************************/
{
	MVView::handleEvent(event,phase);

	flags |= sbInteracting;

	if (event.what == evMouseDown) {
		// Let the owning view know that the scroll bar has been clicked,
		// so that any associated lists etc can select themselves and
		// prepare for scroll bar changed events.
		MV_message(owner,evBroadcast,cmScrollBarClicked,this);
		MVEvent e;
		getEvent(e,evRepaint);				// Force repaint
		dc.setClipRect(bounds);

		ibool   down;
		int part = getPartHit(event.where);
		if (part == -1)
			goto QuickExit;

        if ((part == (int)sbLeftArrow && value == minVal) ||
            (part == (int)sbRightArrow && value == maxVal) ||
            (minVal == maxVal)) {
			MV_beep();
			goto QuickExit;
            }

		drawPart(part,down = true);
		while (event.what != evMouseUp) {
			switch (event.what) {
				case evMouseDown:
				case evMouseAuto:
					if (part == getPartHit(event.where))
						changeValue(part);
					break;
				case evMouseMove:
					if (part != (int)sbThumb) {
						if (down != (part == getPartHit(event.where)))
							drawPart(part,down = !down);
						}
					else changeValue(event.where);
					break;
				}
			if (part != (int)sbThumb && (value == minVal || value == maxVal))
				break;
			getEvent(event);
			}
		if (down)
			drawPart(part,false);

		// Redraw the arrows if they have changed state during the
		// interaction, and we were adjusting the paging state.
		if (part == (int)sbPageLeft || part == (int)sbPageRight || part == (int)sbThumb) {
			if (value == minVal)
				drawLeftArrow(false);
			else if (value == maxVal)
				drawRightArrow(false);
			}

QuickExit:
		clearEvent(event);
		}

	flags &= ~sbInteracting;
}
Exemplo n.º 30
0
void TStaticInputLine::handleEvent(TEvent& event)
{
   char testChar[2];
   char *tempData;
   ccIndex index;

   if (event.what == evKeyDown) {
      if (isprint(event.keyDown.charScan.charCode)) {
	 testChar[0] = event.keyDown.charScan.charCode;
	 testChar[1] = '\0';
	 tempData = (char *)getNextMatch(testChar[0]);
	 if (tempData != 0) {
	    strcpy(data, tempData);
	    selectAll(True);
	    drawView();
	 }
	 clearEvent(event);
      }
      else
	 switch (event.keyDown.keyCode) {
	    case kbUp :
	       index = list->indexOf(data) - 1;
	       if (index < 0)
		  index = list->getCount() - 1;
	       strcpy(data, (char *)list->at(index));
	       selectAll(True);
	       drawView();
	       clearEvent(event);
	       break;

	    case kbDown :
	       index = list->indexOf(data) + 1;
	       if (index >= list->getCount())
		  index = 0;
	       strcpy(data, (char *)list->at(index));
	       selectAll(True);
	       drawView();
	       clearEvent(event);
	       break;

	    case kbHome:
	       index = 0;
	       strcpy(data, (char *)list->at(index));
	       selectAll(True);
	       drawView();
	       clearEvent(event);
	       break;

	    case kbEnd:
	       index = list->getCount() - 1;
	       strcpy(data, (char *)list->at(index));
	       selectAll(True);
	       drawView();
	       clearEvent(event);
	       break;

	    case kbLeft  :
	    case kbRight :
	    case kbBack  :
	    case kbIns   :
	    case kbDel   : clearEvent(event);
	 }
   }
   TInputLine::handleEvent(event);
}