Exemplo n.º 1
0
int wxComboBox::GetSelection() const
{
    // if the popup is currently opened, use the selection as it had been
    // before it dropped down
    return g_SelectionBeforePopup == wxID_NONE ? GetCurrentSelection()
                                               : g_SelectionBeforePopup;
}
Exemplo n.º 2
0
void GtagFileListbox::SetTTText()
{
	std::wstring tt;
	GetCurrentSelection( tt, FALSE);
	
    // Create the tooltip. g_hInst is the global instance handle.
    HWND hwndTip = CreateWindowEx(NULL, TOOLTIPS_CLASS, NULL,
                              WS_POPUP |TTS_ALWAYSTIP | TTS_BALLOON,
                              CW_USEDEFAULT, CW_USEDEFAULT,
                              CW_USEDEFAULT, CW_USEDEFAULT,
                              _hParent, NULL, 
                              _hInst, NULL);
    
   if (!hwndTip) return;
                              
    // Associate the tooltip with the tool.
    TOOLINFO toolInfo = { 0 };
    toolInfo.cbSize = sizeof(toolInfo);
	toolInfo.hwnd = _hParent;
    toolInfo.uFlags = TTF_IDISHWND | TTF_SUBCLASS;
    toolInfo.uId = (UINT_PTR)_hSelf;
	toolInfo.lpszText = (LPWSTR)tt.c_str();
	SendMessage(hwndTip, TTM_ADDTOOL, 0, (LPARAM)&toolInfo);
	return;
}
Exemplo n.º 3
0
	void Menu::CalculateMenuSelectorCubePosition()
	{
		SetSelectItemY(GetMenuItems()[GetCurrentSelection()]->GetMenuItemY() + 7);
		SetSelectItemX(GetMenuX() + GetMenuWidth() - 25);
		SetSelectItemHeight(Constants::TileSize());
		SetSelectItemWidth(Constants::TileSize());
	}
void CEditToolSelector::NotifyLeftClick( void )
{
	EEditorTool eSelected = GetCurrentSelection();
	if ( eSelected != ETool_COUNT )
	{
		CMMMContext::GetInstance().SetEditTool( gs_EditTool[eSelected] );
	}
}
int ctlComboBox::GetGuessedSelection() const
{
    int sel=GetCurrentSelection();

    if (sel < 0)
        sel = FindString(GetValue());
    return sel;
}
/*
 * Function GetUnitScale
 * return the scaling factor to convert users units
 * to normalized units ( ohm )
 */
double UNIT_SELECTOR_RESISTOR::GetUnitScale()
{
    switch( GetCurrentSelection() )
    {
    case 0: return UNIT_OHM;    break;
    case 1: return UNIT_KOHM;   break;
    }
    return 1.0;
}
/*
 * Function GetUnitScale
 * return the scaling factor to convert users units
 * to normalized units ( radian )
 */
double UNIT_SELECTOR_ANGLE::GetUnitScale()
{
    switch( GetCurrentSelection() )
    {
    case 0: return UNIT_RADIAN; break;
    case 1: return UNIT_DEGREE; break;
    }
    return 1.0;
}
Exemplo n.º 8
0
BOOL ComboBox::GetCurrentSelectionItemData(DWORD_PTR *pData)
{
	int selection;
	BOOL bResult = GetCurrentSelection(&selection);
	if (bResult)
	{
		bResult = GetItemData(selection, pData);
	}
	return bResult;
}
Exemplo n.º 9
0
int wxChoice::GetSelection() const
{
    // if m_lastAcceptedSelection is set, it means that the dropdown is
    // currently shown and that we want to use the last "permanent" selection
    // instead of whatever is under the mouse pointer currently
    //
    // otherwise, get the selection from the control
    return m_lastAcceptedSelection == wxID_NONE ? GetCurrentSelection()
                                                : m_lastAcceptedSelection;
}
int ctlComboBox::GetSelection() const
{
    int sel=0;
#ifdef __WXMSW__
    sel=GetCurrentSelection();

    if (sel < 0)
#endif
        sel = FindString(GetValue());
    return sel;
}
/*
 * Function GetUnitScale
 * return the scaling factor to convert users units
 * to normalized units (herz )
 */
double UNIT_SELECTOR_FREQUENCY::GetUnitScale()
{
    switch( GetCurrentSelection() )
    {
    case 0: return UNIT_GHZ;
    case 1: return UNIT_MHZ;
    case 2: return UNIT_KHZ;
    case 3: return 1.0;
    }
    return 1.0;
}
/*
 * Function GetUnitScale
 * return the scaling factor to convert users units
 * to normalized units (meter)
 */
double UNIT_SELECTOR_LEN::GetUnitScale()
{
    switch( GetCurrentSelection() )
    {
    case 0: return UNIT_MM;     break;
    case 1: return UNIT_MICRON; break;
    case 2: return UNIT_CM;     break;
    case 3: return UNIT_MIL;    break;
    case 4: return UNIT_INCH;   break;
    }
    return 1.0;
}
Exemplo n.º 13
0
BOOL ComboBox::GetSelectedString(TCHAR **ppBuffer)
{
    int index = 0;
    if (GetCurrentSelection(&index))
    {
        return GetString(index, ppBuffer);
    }
    else
    {
        return FALSE;
    }
}
Exemplo n.º 14
0
void CWeaponChooser::Update()
{
	// If Weapon chooser is being drawn, see if we want to change weapons...
	if (!IsOpen()) return;


	// See if we should close ourselves...
	if (m_AutoCloseTimer.IsStarted() && m_AutoCloseTimer.IsTimedOut())
	{
        g_pClientSoundMgr->PlayInterfaceSound((char*)g_pInterfaceResMgr->GetSoundSelect());
		Close();
	}
	else if (m_NextWeaponKeyDownTimer.IsStarted() && m_NextWeaponKeyDownTimer.IsTimedOut())
	{
		// See if we should switch to the next weapon...
		if (m_AutoSwitchTimer.IsStarted())
		{
			if (m_AutoSwitchTimer.IsTimedOut())
			{
				NextWeapon(-1);
				g_pClientWeaponMgr->ChangeWeapon( GetCurrentSelection() );
				m_AutoSwitchTimer.Start(g_vtChooserAutoSwitchFreq.GetFloat());
			}
		}
		else
		{
			m_AutoSwitchTimer.Start(g_vtChooserAutoSwitchFreq.GetFloat());
		}
	}
	else if (m_PrevWeaponKeyDownTimer.IsStarted() && m_PrevWeaponKeyDownTimer.IsTimedOut())
	{
		if (m_AutoSwitchTimer.IsTimedOut())
		{
			PrevWeapon();
			g_pClientWeaponMgr->ChangeWeapon( GetCurrentSelection());
			m_AutoSwitchTimer.Start(g_vtChooserAutoSwitchFreq.GetFloat());
		}
	}

}
Exemplo n.º 15
0
/*----------------------------------------------------------------------
  TtaIsDocumentSelected answers TRUE if the document is selected.  
  ----------------------------------------------------------------------*/
ThotBool TtaIsDocumentSelected (Document document)
{
  PtrDocument         docsel;
  PtrElement          firstSelection, lastSelection;
  int                 firstChar, lastChar;

  if (!GetCurrentSelection (&docsel, &firstSelection, &lastSelection,
                            &firstChar, &lastChar))
    return (FALSE);
  else if (LoadedDocument[document - 1] != docsel)
    return (FALSE);
  else
    return (TRUE);
}
Exemplo n.º 16
0
WXLRESULT wxComboBox::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
    // TODO: handle WM_CTLCOLOR messages from our EDIT control to be able to
    //       set its colour correctly (to be the same as our own one)

    switch ( nMsg )
    {
        case WM_SIZE:
        // wxStaticBox can generate this message, when modifying the control's style.
        // This causes the content of the combobox to be selected, for some reason.
        case WM_STYLECHANGED:
            {
                // combobox selection sometimes spontaneously changes when its
                // size changes, restore it to the old value if necessary
                if ( !GetEditHWNDIfAvailable() )
                    break;

                long fromOld, toOld;
                GetSelection(&fromOld, &toOld);

                // if an editable combobox has a not empty text not from the
                // list, it tries to autocomplete it from the list when it is
                // resized, but we don't want this to happen as it doesn't seem
                // to make any sense, so we forcefully restore the old text
                wxString textOld;
                if ( !HasFlag(wxCB_READONLY) && GetCurrentSelection() == -1 )
                    textOld = GetValue();

                // eliminate flickering during following hacks
                wxWindowUpdateLocker lock(this);

                WXLRESULT result = wxChoice::MSWWindowProc(nMsg, wParam, lParam);

                if ( !textOld.empty() && GetValue() != textOld )
                    SetLabel(textOld);

                long fromNew, toNew;
                GetSelection(&fromNew, &toNew);

                if ( fromOld != fromNew || toOld != toNew )
                {
                    SetSelection(fromOld, toOld);
                }

                return result;
            }
    }

    return wxChoice::MSWWindowProc(nMsg, wParam, lParam);
}
Exemplo n.º 17
0
int wxComboBox::GetSelection() const
{
#ifdef __WXGTK24__
    if (!gtk_check_version(2,4,0))
    {
        GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
        return gtk_combo_box_get_active( combobox );
    }
    else
#endif
        // if the popup is currently opened, use the selection as it had been
        // before it dropped down
        return g_SelectionBeforePopup == wxID_NONE ? GetCurrentSelection()
                                               : g_SelectionBeforePopup;
}
void IncrementalSelectListBase::OnKeyDown(wxKeyEvent& event)
{
    int selected = 0, selectedMax = 0;

    GetCurrentSelection(selected, selectedMax);
    if (selected == wxNOT_FOUND)
        selected = 0;

    // remember previous selection
    int selectedPrevious = selected;
    KeyDownAction(event, selected, selectedMax);
    if (selectedMax < 0)
        return;
    UpdateCurrentSelection(selected, selectedPrevious);
}
Exemplo n.º 19
0
/*----------------------------------------------------------------------
  TtaExtendSelection

  Extends the current selection to a given element.
  Parameters:
  document: the document for which the selection must be extended.
  element: the element to which the selection must be extended.
  lastCharacter: position within this element of the last character
  to be selected. 0 if the whole element must be selected.
  ----------------------------------------------------------------------*/
void TtaExtendSelection (Document document, Element element, int lastCharacter)
{
  PtrDocument         pDoc;
  PtrElement          firstSelection, lastSelection;
  DisplayMode         dispMode;
  int                 firstChar, lastChar;
  ThotBool            ok;
  ThotBool            abort;

  UserErrorCode = 0;
  if (element == NULL)
    TtaError (ERR_invalid_parameter);
  else if (((PtrElement) element)->ElParent == NULL)
    TtaError (ERR_invalid_parameter);
  /* Checks the parameter document */
  else if (document < 1 || document > MAX_DOCUMENTS)
    TtaError (ERR_invalid_document_parameter);
  else if (LoadedDocument[document - 1] == NULL)
    TtaError (ERR_invalid_document_parameter);
  else
    /* Parameter document is correct */
    {
      /* verifies if there is a selection */
      ok = GetCurrentSelection (&pDoc, &firstSelection, &lastSelection,
                                &firstChar, &lastChar);
      dispMode = TtaGetDisplayMode (document);
      if (dispMode == DisplayImmediately)
        /* The command can be executed */
        {
          if (ok)
            /* verifies that the selection is into the document */
            ok = (pDoc == LoadedDocument[document - 1]);
        }
      /* verifies if a selection is applied */
      else if (IsSelectionRegistered (document, &abort))
        /* There is an application, the extension is accepted if there is 
           a request which is not for aborting */
        ok = !abort;
      
      if (!ok)
        /* Error: no selection */
        TtaError (ERR_no_selection_in_document);
      else if (dispMode == DisplayImmediately)
        ExtendSelection ((PtrElement) element, lastCharacter, TRUE, FALSE, FALSE);
      else
        NewSelectionExtension (document, element, lastCharacter);
    }
}
Exemplo n.º 20
0
/*----------------------------------------------------------------------
  TtaGiveLastSelectedElement

  Returns the last element in the current selection in a given document.
  If this element is a Text element and if only a substring is selected,
  return also the rank of the first and last characters in the selection.
  Parameter:
  document: the document for which the selection is asked.
  Return values:
  selectedElement: the last selected element, NULL if no element is
  selected in the document.
  firstCharacter: rank of the first selected character in the element, or
  0 if the whole element is in the selection.
  lastCharacter: rank of the last selected character in the element, or
  0 if the whole element is in the selection, or firstCharacter - 1 for
  a position.
  ----------------------------------------------------------------------*/
void TtaGiveLastSelectedElement (Document document, Element *selectedElement,
                                 int *firstCharacter, int *lastCharacter)
{
  PtrDocument         pDoc;
  PtrElement          firstSelection, lastSelection;
  int                 firstChar, lastChar;
  ThotBool            ok;

  UserErrorCode = 0;
  *selectedElement = NULL;
  *firstCharacter = 0;
  *lastCharacter = 0;
  /* Checks the parameter document */
  if (document < 1 || document > MAX_DOCUMENTS)
    TtaError (ERR_invalid_document_parameter);
  else if (LoadedDocument[document - 1] == NULL)
    TtaError (ERR_invalid_document_parameter);
  else
    {
      /* Parameter document is correct */
      ok = GetCurrentSelection (&pDoc, &firstSelection, &lastSelection,
                                &firstChar, &lastChar);
      if (ok)
        if (pDoc == LoadedDocument[document - 1])
          {
            *selectedElement = (Element) lastSelection;
            if (lastSelection == firstSelection)
              {
                /* only one element */
                *firstCharacter = firstChar;
                if (SelPosition)
                  /* a position */
                  *lastCharacter = firstChar - 1;
                else
                  *lastCharacter = lastChar;
              }
            else if (lastChar > 0)
              {
                /* the selection ends in the middle of the element */
                *firstCharacter = 1;
                *lastCharacter = lastChar;
              }
          }
    }
}
Exemplo n.º 21
0
void CEditToolSelector::Render( void )
{
//	CMMMContext::GetInstance().GetMouse()->SetValidPos( MouseIsValidPos() );
	const FLOAT32 fTOP_LEFT_X = 10.0f;
	const FLOAT32 fTOP_LEFT_Y = 10.0f;
	const FLOAT32 fWIDTH = 300.0f;
	const FLOAT32 fLINE_OFFSET = 20.0f;

	const FLOAT32 fDEPTH = fTOP_LEFT_X +  (ETool_COUNT-1) * fLINE_OFFSET;

	GDE::SVertex BoxVerts[4];
	BoxVerts[0].m_fX = fTOP_LEFT_X;
	BoxVerts[0].m_fY = fTOP_LEFT_Y;
	BoxVerts[1].m_fX = fTOP_LEFT_X+fWIDTH;
	BoxVerts[1].m_fY = fTOP_LEFT_Y;
	BoxVerts[2].m_fX = fTOP_LEFT_X+fWIDTH;
	BoxVerts[2].m_fY = fTOP_LEFT_Y+fDEPTH;
	BoxVerts[3].m_fX = fTOP_LEFT_X;
	BoxVerts[3].m_fY = fTOP_LEFT_Y+fDEPTH;

	for ( UINT32 i=0; i<4; i++ )
	{
		BoxVerts[i].m_fZ = 0.5f;
		BoxVerts[i].m_uColour = 0x3F000000;	// very grey
	}

	// untextured:
	CMMMContext::GetInstance().GetRenderer()->GetTextureManager().GetNULLTexture()->Apply( 0 );
	CMMMContext::GetInstance().GetRenderer()->DrawPrimitives( GDE::PT_QuadList, 1, BoxVerts );

	const UINT32 uStartCol = CMMMContext::GetInstance().GetFont()->GetColour();

	const EEditorTool eCurrent = GetCurrentSelection();

	FLOAT32 fY = fTOP_LEFT_Y + 5.0f;
	for ( UINT32 i=1; i<ETool_COUNT; i++ )
	{
		const UINT32 uCol = (i==(UINT32)eCurrent)?0xFF7F7FFF:0xFFFFFFFF;
		CMMMContext::GetInstance().GetFont()->SetColour( uCol );
		CMMMContext::GetInstance().GetFont()->Render( fTOP_LEFT_X + 5.0f, fY, GDE::FJ_Left, gs_EditTool[i]->GetName() );
		fY += fLINE_OFFSET;
	}
	CMMMContext::GetInstance().GetFont()->SetColour( uStartCol );
}
Exemplo n.º 22
0
/*----------------------------------------------------------------------
  La frame d'indice frame devient la fenetre active.               
  ----------------------------------------------------------------------*/
void ChangeSelFrame (int frame)
{
  Document            doc, olddoc;
  PtrDocument         docsel;
  PtrElement          first, last;
  View                view;
  //AmayaFrame         *p_frame;
  int                 oldframe, firstChar, lastChar;

  if (ActiveFrame != frame)
    {
      CloseTextInsertion ();
      oldframe = ActiveFrame;
      FrameToView (oldframe, &olddoc, &view);
      ActiveFrame = frame;
      FrameToView (frame, &doc, &view);
      // set the new focus
      if (ChangeFocusFunction &&
          doc && LoadedDocument[doc-1]->DocTypeName &&
          strcmp (LoadedDocument[doc-1]->DocTypeName, "log") &&
          olddoc && LoadedDocument[olddoc-1]->DocTypeName &&
          strcmp (LoadedDocument[olddoc-1]->DocTypeName, "log"))
        (*(Proc1)ChangeFocusFunction) ((void *) doc);

      /* update the class list */
      TtaExecuteMenuAction ("ApplyClass", doc, 1, FALSE);
      TtaRefreshElementMenu (doc, 1);
      UpdateAttrMenu (LoadedDocument[doc-1], TRUE);
      // update the show errors
      TtaExecuteMenuAction ("UpdateShowError", doc, 1, FALSE);
      TtaExecuteMenuAction ("UpdateStyleList", doc, 1, FALSE);
      GetCurrentSelection (&docsel, &first, &last, &firstChar, &lastChar);
      if (LoadedDocument[doc-1] != docsel)
        TtaSetStatusSelectedElement (doc, 1, NULL);
      else
        TtaSetStatusSelectedElement (doc, 1, (Element)first);
      /* the active frame changed so update the application focus */
      /*p_frame = TtaGetFrameFromId(frame);
      if (p_frame)
      p_frame->GetCanvas()->SetFocus();*/
    }
}
Exemplo n.º 23
0
/*----------------------------------------------------------------------
  TtaAddElementToSelection

  Add a new element to the current selection.  The new selection
  may then contain separate elements.
  Parameters:
  document: the document to which the element belongs.  This element must
	belong to the same document as the elements selected by previous calls
	to TtaAddElementToSelection and by the last call to TtaSelectElement.
  element: the element to be added to the current selection
  ----------------------------------------------------------------------*/
void TtaAddElementToSelection (Document document, Element element)
{
  PtrDocument         pDoc;
  PtrElement          firstSelection, lastSelection;
  DisplayMode         dispMode;
  int                 firstChar, lastChar;
  ThotBool            ok;

  UserErrorCode = 0;
  if (element == NULL)
    TtaError (ERR_invalid_parameter);
  else if (((PtrElement) element)->ElParent == NULL)
    TtaError (ERR_invalid_parameter);
  /* Checks the parameter document */
  else if (document < 1 || document > MAX_DOCUMENTS)
    TtaError (ERR_invalid_document_parameter);
  else if (LoadedDocument[document - 1] == NULL)
    TtaError (ERR_invalid_document_parameter);
  else
    /* Parameter document is correct */
    {
      /* is there a current selection */
      ok = GetCurrentSelection (&pDoc, &firstSelection, &lastSelection,
                                &firstChar, &lastChar);
      dispMode = TtaGetDisplayMode (document);
      if (ok)
        {
          if (dispMode == NoComputedDisplay)
            /* accept only if immediate display mode */
            ok = FALSE;
          else
            /* is the current selection is in the same document? */
            ok = (pDoc == LoadedDocument[document - 1]);
        }
      if (!ok)
        /* Error: no selection */
        TtaError (ERR_no_selection_in_document);
      else
        AddInSelection ((PtrElement) element, FALSE);
    }
}
Exemplo n.º 24
0
/*----------------------------------------------------------------------
  TtaGiveNextSelectedElement

  Returns the element that follows a given element in the current selection
  in a given document. If this element is a Text element and if only a
  substring is selected, return also the rank of the first and last
  characters in the selection.
  Parameters:
  document: the document for which the selection is asked.
  selectedElement: the current element.
  Return parameters:
  selectedElement: the next selected element, NULL if
  this was the last selected element in the document.
  firstCharacter: rank of the first character in the selection, or 0 if the
  whole element is in the selection.
  lastCharacter: rank of the last character in the selection, or 0 if the
  whole element is in the selection.
  ----------------------------------------------------------------------*/
void TtaGiveNextSelectedElement (Document document, Element *selectedElement,
                                 int *firstCharacter, int *lastCharacter)
{
  PtrDocument         pDoc;
  PtrElement          pEl;
  PtrElement          firstSelection, lastSelection;
  int                 firstChar, lastChar;
  ThotBool            ok;

  UserErrorCode = 0;
  *firstCharacter = 0;
  *lastCharacter = 0;
  /* Checks the parameter document */
  if (document < 1 || document > MAX_DOCUMENTS)
    TtaError (ERR_invalid_document_parameter);
  else if (LoadedDocument[document - 1] == NULL)
    TtaError (ERR_invalid_document_parameter);
  else
    {
      /* Parameter document is correct */
      ok = GetCurrentSelection (&pDoc, &firstSelection, &lastSelection,
                                &firstChar, &lastChar);
      if (!ok)
        *selectedElement = NULL;
      else if (pDoc != LoadedDocument[document - 1])
        *selectedElement = NULL;
      else
        {
          pEl = NextInSelection ((PtrElement) *selectedElement, lastSelection);
          *selectedElement = (Element) pEl;
          if (pEl == lastSelection && lastChar > 0)
            {
              *firstCharacter = 1;
              *lastCharacter = lastChar;
            }
        }
    }
}
Exemplo n.º 25
0
bool wxComboBox::MSWCommand(WXUINT param, WXWORD id)
{
    int sel = -1;
    wxString value;

    switch ( param )
    {
        case CBN_DROPDOWN:
            // remember the last selection, just as wxChoice does
            m_lastAcceptedSelection = GetCurrentSelection();
            {
                wxCommandEvent event(wxEVT_COMBOBOX_DROPDOWN, GetId());
                event.SetEventObject(this);
                ProcessCommand(event);
            }
            break;

        case CBN_CLOSEUP:
            // Do the same thing as in wxChoice but using different event type.
            if ( m_pendingSelection != wxID_NONE )
            {
                SendSelectionChangedEvent(wxEVT_COMBOBOX);
                m_pendingSelection = wxID_NONE;
            }
            {
                wxCommandEvent event(wxEVT_COMBOBOX_CLOSEUP, GetId());
                event.SetEventObject(this);
                ProcessCommand(event);
            }
            break;

        case CBN_SELENDOK:
#ifndef __SMARTPHONE__
            // we need to reset this to prevent the selection from being undone
            // by wxChoice, see wxChoice::MSWCommand() and comments there
            m_lastAcceptedSelection = wxID_NONE;
#endif

            // set these variables so that they could be also fixed in
            // CBN_EDITCHANGE below
            sel = GetSelection();
            value = GetStringSelection();

            // this string is going to become the new combobox value soon but
            // we need it to be done right now, otherwise the event handler
            // could get a wrong value when it calls our GetValue()
            ::SetWindowText(GetHwnd(), value.t_str());

            SendSelectionChangedEvent(wxEVT_COMBOBOX);

            // fall through: for compatibility with wxGTK, also send the text
            // update event when the selection changes (this also seems more
            // logical as the text does change)

        case CBN_EDITCHANGE:
            if ( m_allowTextEvents )
            {
                wxCommandEvent event(wxEVT_TEXT, GetId());

                // if sel != -1, value was already initialized above
                if ( sel == -1 )
                {
                    value = wxGetWindowText(GetHwnd());
                }

                event.SetString(value);
                InitCommandEventWithItems(event, sel);

                ProcessCommand(event);
            }
            break;

        default:
            return wxChoice::MSWCommand(param, id);
    }

    // skip wxChoice version as it would generate its own events for
    // CBN_SELENDOK and also interfere with our handling of CBN_DROPDOWN
    return true;
}
Exemplo n.º 26
0
bool wxChoice::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
{
    /*
        The native control provides a great variety in the events it sends in
        the different selection scenarios (undoubtedly for greater amusement of
        the programmers using it). For the reference, here are the cases when
        the final selection is accepted (things are quite interesting when it
        is cancelled too):

        A. Selecting with just the arrows without opening the dropdown:
            1. CBN_SELENDOK
            2. CBN_SELCHANGE

        B. Opening dropdown with F4 and selecting with arrows:
            1. CBN_DROPDOWN
            2. many CBN_SELCHANGE while changing selection in the list
            3. CBN_SELENDOK
            4. CBN_CLOSEUP

        C. Selecting with the mouse:
            1. CBN_DROPDOWN
            -- no intermediate CBN_SELCHANGEs --
            2. CBN_SELENDOK
            3. CBN_CLOSEUP
            4. CBN_SELCHANGE

        Admire the different order of messages in all of those cases, it must
        surely have taken a lot of effort to Microsoft developers to achieve
        such originality.
     */
    switch ( param )
    {
        case CBN_DROPDOWN:
            // we use this value both because we don't want to track selection
            // using CB_GETCURSEL while the dropdown is opened and because we
            // need to reset the selection back to it if it's eventually
            // cancelled by user
            m_lastAcceptedSelection = GetCurrentSelection();
            break;

        case CBN_CLOSEUP:
            // if the selection was accepted by the user, it should have been
            // reset to wxID_NONE by CBN_SELENDOK, otherwise the selection was
            // cancelled and we must restore the old one
            if ( m_lastAcceptedSelection != wxID_NONE )
            {
                SetSelection(m_lastAcceptedSelection);
                m_lastAcceptedSelection = wxID_NONE;
            }
            break;

        case CBN_SELENDOK:
            // reset it to prevent CBN_CLOSEUP from undoing the selection (it's
            // ok to reset it now as GetCurrentSelection() will now return the
            // same thing anyhow)
            m_lastAcceptedSelection = wxID_NONE;

            {
                const int n = GetSelection();

                wxCommandEvent event(wxEVT_COMMAND_CHOICE_SELECTED, m_windowId);
                event.SetInt(n);
                event.SetEventObject(this);

                if ( n > -1 )
                {
                    event.SetString(GetStringSelection());
                    InitCommandEventWithItems(event, n);
                }

                ProcessCommand(event);
            }
            break;

        // don't handle CBN_SELENDCANCEL: just leave m_lastAcceptedSelection
        // valid and the selection will be undone in CBN_CLOSEUP above

        // don't handle CBN_SELCHANGE neither, we don't want to generate events
        // while the dropdown is opened -- but do add it if we ever need this

        default:
            return false;
    }

    return true;
}
Exemplo n.º 27
0
/*----------------------------------------------------------------------
   FindReference cherche une reference a` l'element selectionne'.       
   A l'appel:                                                   
   - pPrevRef: pointeur sur la derniere reference trouvee  
   ou NULL si on cherche la premiere reference (dans ce  
   cas, pExtDoc doit aussi etre NULL).                   
   - pReferredEl: l'element dont on cherche les references,
   NULL si on cherche la premiere reference.             
   - pDoc: le document auquel appartient         
   l'element dont on cherche les references, NULL si on  
   cherche la premiere reference.                        
   Au retour:                                                   
   - pPrevRef: pointeur sur la reference trouvee ou NULL   
   si on n'a pas trouve' de reference.                   
   - pReferredEl: l'element dont on cherche les references.
  ----------------------------------------------------------------------*/
void FindReference (PtrReference *pPrevRef, PtrDocument pDoc,
		    PtrElement *pReferredEl)
{
  PtrElement          firstSel;
  PtrElement          lastSel;
  PtrElement          pEl;
  PtrDocument         pSelDoc;
  PtrElement          pAncest;
  int                 firstChar;
  int                 lastChar;
  ThotBool            ok;
  ThotBool            found;

  ok = TRUE;
  if (*pPrevRef)
    /* on a deja une reference courante */
    *pPrevRef = NextReferenceToEl (*pReferredEl, pDoc, *pPrevRef);
  else
    /* pas de reference courante */
    {
      /* prend la selection courante */
      ok = GetCurrentSelection (&pSelDoc, &firstSel, &lastSel, &firstChar,
				&lastChar);
      if (ok)
	/* cherche le premier element reference' qui englobe la */
	/* selection courante */
	{
	  pEl = firstSel;
	  found = FALSE;
	  do
	    {
	      if (pEl->ElReferredDescr &&
		  /* l'element a un descripteur d'element reference' */
		  pEl->ElReferredDescr->ReFirstReference)
		/* l'element est effectivement reference' */
		found = TRUE;
	      if (!found)
		/* l'element n'est pas reference', on passe au pere */
		pEl = pEl->ElParent;
	    }
	  while (!found && pEl);
	  if (found)
	    /* on a trouve' un ascendant reference' */
	    {
	      /* conserve un pointeur sur l'element dont on cherche les */
	      /* references ainsi que sur son document */
	      *pReferredEl = pEl;
	      /* cherche la premiere reference a cet element */
	      *pPrevRef = NextReferenceToEl (*pReferredEl, pDoc, *pPrevRef);
	    }
	}
    }
  if (*pPrevRef != NULL)
    /* on a trouve' une reference */
    {
      ok = TRUE;
      /* on ignore les references qui sont a l'interieur d'une inclusion */
      if ((*pPrevRef)->RdElement != NULL)
	{
	  pAncest = (*pPrevRef)->RdElement->ElParent;
	  while (pAncest->ElParent != NULL && pAncest->ElSource == NULL)
	    pAncest = pAncest->ElParent;
	  if (pAncest->ElSource != NULL)
	    /* on est dans une inclusion */
	    ok = FALSE;
	}
      /* on ignore les references dans les partie cachees */
      if (ok)
	if (ElementIsHidden ((*pPrevRef)->RdElement))
	  /* on est dans une partie cachee */
	  ok = FALSE;
      /* on ignore les references qui sont dans le tampon de Copier-Couper */
      if (ok)
	if (IsASavedElement ((*pPrevRef)->RdElement))
	  ok = FALSE;
      if (!ok)
	/* cherche la reference suivante au meme element */
	FindReference (pPrevRef, pDoc, pReferredEl);
      else
	/* selectionne la reference trouvee */
	SelectElementWithEvent (pDoc, (*pPrevRef)->RdElement, FALSE, FALSE);
    }
}
Exemplo n.º 28
0
void EditPolyData::Hide (EditPolyMod *pMod, bool isFaceLevel, bool hideSelected)
{
	if (theHold.Holding()) {
		theHold.Put (new EditPolyHideRestore (pMod, this, false));
		if (isFaceLevel) theHold.Put (new EditPolyHideRestore (pMod, this, true));
		if (isFaceLevel || hideSelected) theHold.Put (new EditPolySelectRestore (pMod, this, EPM_SL_VERTEX));
		if (isFaceLevel && hideSelected) theHold.Put (new EditPolySelectRestore (pMod, this, EPM_SL_FACE));
	}

	SynchBitArrays ();

	bool stackSel = pMod->getParamBlock()->GetInt (epm_stack_selection) != 0;

	if (isFaceLevel) {
		BitArray & faceSel = *(GetCurrentSelection (MNM_SL_FACE, stackSel));
		int i, max = faceSel.GetSize();
		if (mFaceHide.GetSize()<max) max = mFaceHide.GetSize();
		if (hideSelected) {
			if (mpMesh) {
				// Hide vertices used by all hidden or selected faces first:
				BitArray touchedByHidden, touchedByNonHidden;
				touchedByHidden.SetSize (mpMesh->numv);
				touchedByNonHidden.SetSize (mpMesh->numv);
				int mmax = max;
				if (mmax>mpMesh->numf) mmax = mpMesh->numf;
				for (i=0; i<mmax; i++) {
					if (faceSel[i]) {
						for (int j=0; j<mpMesh->f[i].deg; j++) touchedByHidden.Set (mpMesh->f[i].vtx[j]);
					} else if (!mFaceHide[i]) {
						for (int j=0; j<mpMesh->f[i].deg; j++) touchedByNonHidden.Set (mpMesh->f[i].vtx[j]);
					}
				}
				for (i=0; i<mpMesh->numv; i++) {
					if (touchedByNonHidden[i]) touchedByHidden.Clear(i);
				}

				// Ok, now everything left in touchedByHidden should be hidden and deselected.
				mVertHide |= touchedByHidden;
				if (!stackSel) mVertSel &= ~touchedByHidden;
			}
			for (i=0; i<max; i++) {
				if (faceSel[i]) {
					if (!stackSel) faceSel.Clear(i);
					mFaceHide.Set(i,true);
				}
			}
		} else {
			if (mpMesh) {
				// Hide vertices used by all hidden or nonselected faces first:
				BitArray touchedByHidden, touchedByNonHidden;
				touchedByHidden.SetSize (mpMesh->numv);
				touchedByNonHidden.SetSize (mpMesh->numv);
				int mmax = max;
				if (mmax>mpMesh->numf) mmax = mpMesh->numf;
				for (i=0; i<mmax; i++) {
					if (!faceSel[i]) {
						for (int j=0; j<mpMesh->f[i].deg; j++) touchedByHidden.Set (mpMesh->f[i].vtx[j]);
					} else if (!mFaceHide[i]) {
						for (int j=0; j<mpMesh->f[i].deg; j++) touchedByNonHidden.Set (mpMesh->f[i].vtx[j]);
					}
				}
				for (i=0; i<mpMesh->numv; i++) {
					if (touchedByNonHidden[i]) touchedByHidden.Clear(i);
				}

				// Ok, now everything left in touchedByHidden should be hidden and deselected.
				mVertHide |= touchedByHidden;
				if (!stackSel) mVertSel &= ~touchedByHidden;
			}
			for (int i=0; i<max; i++) if (!faceSel[i]) mFaceHide.Set(i,true);
		}
	} else {
		BitArray & vertSel = *GetCurrentSelection (MNM_SL_VERTEX, pMod->getParamBlock()->GetInt(epm_stack_selection)!=0);
		int max = vertSel.GetSize();
		if (mVertHide.GetSize()<max) max = mVertHide.GetSize();
		if (hideSelected) {
			for (int i=0; i<max; i++) {
				if (vertSel[i]) {
					if (!stackSel) vertSel.Clear(i);
					mVertHide.Set(i,true);
				}
			}
		} else {
			for (int i=0; i<max; i++) if (!vertSel[i]) mVertHide.Set(i,true);
		}
	}
}
Exemplo n.º 29
0
/*----------------------------------------------------------------------
  CallbackChecker
  ----------------------------------------------------------------------*/
void CallbackChecker (int ref, int dataType, char *data)
{
  PtrElement          pEl1, pElN;
  int                 c1, cN;

  if (ref == -1)
    /* detruit le dialogue du correcteur */
    RemoveSpellForm ();
  else
    switch (ref - SpellingBase)
      {
      case ChkrMenuIgnore:
        switch ((long int) data)
          {
          case 0:
            /* ignorer les mots ecrits en majuscule */
            IgnoreUppercase = !IgnoreUppercase;
            break;
          case 1:
            /* ignorer les mots contenant un chiffre arabe */
            IgnoreArabic = !IgnoreArabic;
            break;
          case 2:
            /* ignorer les chiffres romains */
            IgnoreRoman = !IgnoreRoman;
            break;
          case 3:
            /* ignorer les mots contenant certains car speciaux */
            IgnoreSpecial = !IgnoreSpecial;
            break;
          }	/* end of switch */
        break;
      case ChkrSpecial:
        /* recopier la liste des car. speciaux dans RejectedChar[] */
        strncpy (RejectedChar, data, MAX_REJECTED_CHARS);
        /* bascule automatiquement l'indicateur IgnoreSpecial */
        if (!IgnoreSpecial)
          {
            IgnoreSpecial = TRUE;
#ifdef _GTK
            TtaSetToggleMenu (SpellingBase + ChkrMenuIgnore, 3, IgnoreSpecial);
#endif /* _GTK */
          }
        break;
      case ChkrMenuOR:
        /* definition du sens de correction OU? */
        switch ((long int) data)
          {
          case 0:	/* ElemIsBefore la selection */
            ChkrRange->SStartToEnd = FALSE;
            break;
          case 1:	/* Dans la selection */
            FirstStep = TRUE;
            break;
          case 2:	/* Apres la selection */
            ChkrRange->SStartToEnd = TRUE;
            break;
          case 3:	/* Dans tout le document */
            FirstStep = TRUE;
            break;
          }
        /* La premiere fois on initialise le domaine de recherche */
        if (FirstStep)
          {
            InitSearchDomain ((long int) data, ChkrRange);
            /* On prepare la recheche suivante */
#ifdef _GTK
            if (ChkrRange->SStartToEnd)
              TtaSetMenuForm (SpellingBase + ChkrMenuOR, 2);
            else
              TtaSetMenuForm (SpellingBase + ChkrMenuOR, 0);
#endif /* GTK */
          }
        else if (ChkrRange != NULL)
          /* Est-ce que le document vient de recevoir la selection */
          if (pDocSel != ChkrRange->SDocument)
            {
              /* Est-ce encore vrai */
              GetCurrentSelection (&pDocSel, &pEl1, &pElN, &c1, &cN);
#ifdef _GTK
              if (pDocSel == ChkrRange->SDocument)
                {
                  /* Il faut reactiver les entree */
                  TtaRedrawMenuEntry (SpellingBase + ChkrMenuOR,
                                      0, NULL, (ThotColor)-1, 1);
                  TtaRedrawMenuEntry (SpellingBase + ChkrMenuOR,
                                      1, NULL, (ThotColor)-1, 1);
                  TtaRedrawMenuEntry (SpellingBase + ChkrMenuOR,
                                      2, NULL, (ThotColor)-1, 1);
                } 
#endif /* GTK */
            }
        break;
      case ChkrSelectProp:
        /* retour du selecteur de propositions */
        /* recopier le choix dans CorrectWord */
        strcpy (CorrectWord, data);
        if (CorrectWord[0] != EOS && BadWord != EOS
            && strcmp (CorrectWord, BadWord) != 0)
          ToReplace = TRUE;
        break;
      case ChkrFormCorrect:
        /* retour de la feuille de dialogue CORRECTION */
        /* effectuer l'action demandee */
        ApplyCommand ((long int) data);
        break;
      }
}
Exemplo n.º 30
0
/*----------------------------------------------------------------------
  TtcSpellCheck  active le formulaire de correction                
  ----------------------------------------------------------------------*/
void TtcSpellCheck (Document doc, View view)
{
  PtrDocument         document;
  PtrElement          pEl1, pElN;
  int                 c1, cN;
  int                 i;
  ThotBool            ok;
#ifdef _WX
  ThotBool             created;
#endif /* _WX */

  /* Document concerne */
  document = LoadedDocument[doc - 1];
  if (document == NULL)
    return;
  SpellCheckLoadResources ();

  /* Afficher une liste de mots EMPTY */
  strcpy (ChkrCorrection[0], " ");
  for (i = 1; i <= NB_PROPOSALS; i++)
    strcpy (ChkrCorrection[i], "$");

  /* ne pas ignorer les mots en capitale, chiffres romains */
  /* ou contenant des chiffres arabes,  certains car. speciaux */
  strncpy (RejectedChar, "@#$&+~", MAX_REJECTED_CHARS);
  /* liste par defaut */
  IgnoreUppercase = TRUE;
  IgnoreArabic = TRUE;
  IgnoreRoman = TRUE;
  IgnoreSpecial = TRUE;
  /* Document selectionne */
  ok = GetCurrentSelection (&pDocSel, &pEl1, &pElN, &c1, &cN);


  /* Indique que c'est une nouvelle correction qui debute */
  FirstStep = TRUE;
  ChkrRange = NULL;		/* pas de contexte de correction alloue */
  /* On alloue le contexte */
  GetSearchContext (&ChkrRange);
  ChkrRange->SDocument = document;
  /* ne cree pas inutilement le dictionnaire fichier */
  TtaLoadDocumentDictionary (document, (int*) &ChkrFileDict, FALSE);

#ifdef _WINGUI  
  /* to have the same behavior as under Unix, we need to destroy the
     dialog if it already existed */
  if (SpellChecker) 
    {
      EndDialog (SpellChecker, ID_DONE);
      SpellChecker = NULL;
      hwndLanguage = NULL;
    }
  DialogBox (hInstance, MAKEINTRESOURCE (SPELLCHECKDIALOG), NULL,
             (DLGPROC) SpellCheckDlgProc);
#endif /* _WINGUI */
#ifdef _WX
  if (!ok || pDocSel != document)
    i = 1;
  else
    i = 2;
  created = CreateSpellCheckDlgWX (SpellingBase + ChkrFormCorrect,
                                   SpellingBase, TtaGetViewFrame (doc, view), i);
  CallbackChecker (SpellingBase + ChkrMenuOR, INTEGER_DATA, (char *)i);
  if (created)
    TtaShowDialogue (SpellingBase + ChkrFormCorrect, FALSE, TRUE);
#endif /* _WX */
}