Пример #1
0
//
// ICListSlider::Activate
//
// Activate the control
//
Bool ICListSlider::Activate()
{
  // Activate the ICSlider component first, this will initialise the client rect
  if (ICSlider::Activate())
  {
    // Check and setup the vars
    for (List<ListBoxWatcher>::Iterator i(&listBoxes); *i; i++)
    {
      ListBoxWatcher *ptr = *i;

      ActivateVar(ptr->count, VarSys::VI_INTEGER);
      ActivateVar(ptr->top  , VarSys::VI_INTEGER);
      ActivateVar(ptr->vis  , VarSys::VI_INTEGER);
    }

    // Force recalculation of knob size
    knobPct = -1.0F;
    resizeKnob = TRUE;

    // Set up initial values
    GetSliderValue();

    return (TRUE);
  }
  else
  {
    return (FALSE);
  }
}
Пример #2
0
long CModuleControlLong::GetValue() {
  if (m_hSlider)
    return GetSliderValue();

  long lValue = GetEditValue();
  if (lValue < m_iMin) lValue = m_iMin;
  if (lValue > m_iMax) lValue = m_iMax;
  return lValue;
}
Пример #3
0
void CModuleControlLong::UpdateValue(long lValue) {
  if (m_hSlider && GetSliderValue() != lValue) {
    m_hSlider.SendMessage(TBM_SETPOS, true, lValue);
  }
  if (!m_hEdit.GetWindowTextLength() || GetEditValue() != lValue)
  {
    double dValue = lValue*1.0 / m_iDivisor;
    CString sValue;
    sValue.Format(TEXT("%g"), dValue);
    m_hEdit.SetWindowText(sValue);
  }
}
Пример #4
0
//
// ICListSlider::SetSliderValue
//
void ICListSlider::SetSliderValue(F32 value)
{
  GetSliderValue();

  // Clamp the value
  value = Max(minVal, Min(maxVal, value));

  // Update all listboxes
  for (List<ListBoxWatcher>::Iterator i(&listBoxes); *i; i++)
  {
    ListBoxWatcher *ptr = *i;

    ptr->top->SetIntegerValue(S32(value));
  }
}
Пример #5
0
BOOL CALLBACK DSound51::ConfigProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
	int wmId,wmEvent;
	int tSel=0;

	switch(uMsg)
	{
		case WM_INITDIALOG:

			haveGuid = ! FAILED(GUIDFromString(Config_DSound51.Device,&DevGuid));
			SendMessage(GetDlgItem(hWnd,IDC_DS_DEVICE),CB_RESETCONTENT,0,0);

			ndevs=0;
			DirectSoundEnumerate(DSEnumCallback,NULL);

			tSel=-1;
			for(int i=0;i<ndevs;i++)
			{
				SendMessage(GetDlgItem(hWnd,IDC_DS_DEVICE),CB_ADDSTRING,0,(LPARAM)devices[i].name);
				if(haveGuid && IsEqualGUID(devices[i].guid,DevGuid))
				{
					tSel=i;
				}
			}

			if(tSel>=0)
			{
				SendMessage(GetDlgItem(hWnd,IDC_DS_DEVICE),CB_SETCURSEL,tSel,0);
			}

			INIT_SLIDER(IDC_LEFT_GAIN_SLIDER,0,512,64,16,8);
			INIT_SLIDER(IDC_RIGHT_GAIN_SLIDER,0,512,64,16,8);
			INIT_SLIDER(IDC_RLEFT_GAIN_SLIDER,0,512,64,16,8);
			INIT_SLIDER(IDC_RRIGHT_GAIN_SLIDER,0,512,64,16,8);
			INIT_SLIDER(IDC_CENTER_GAIN_SLIDER,0,512,64,16,8);
			INIT_SLIDER(IDC_LFE_SLIDER,0,512,64,16,8);
			INIT_SLIDER(IDC_LR_CENTER_SLIDER,0,512,64,16,8);

			AssignSliderValue( hWnd, IDC_LEFT_GAIN_SLIDER, IDC_LEFT_GAIN_EDIT, Config_DSound51.GainL );
			AssignSliderValue( hWnd, IDC_RIGHT_GAIN_SLIDER, IDC_RIGHT_GAIN_EDIT, Config_DSound51.GainR );
			AssignSliderValue( hWnd, IDC_RLEFT_GAIN_SLIDER, IDC_RLEFT_GAIN_EDIT, Config_DSound51.GainSL );
			AssignSliderValue( hWnd, IDC_RRIGHT_GAIN_SLIDER, IDC_RRIGHT_GAIN_EDIT, Config_DSound51.GainSR );
			AssignSliderValue( hWnd, IDC_CENTER_GAIN_SLIDER, IDC_CENTER_GAIN_EDIT, Config_DSound51.GainC);
			AssignSliderValue( hWnd, IDC_LFE_SLIDER, IDC_LFE_EDIT, Config_DSound51.GainLFE);
			AssignSliderValue( hWnd, IDC_LR_CENTER_SLIDER, IDC_LR_CENTER_EDIT, Config_DSound51.AddCLR );

			char temp[128];
			INIT_SLIDER( IDC_BUFFERS_SLIDER, 2, MAX_BUFFER_COUNT, 2, 1, 1 );
			SendMessage(GetDlgItem(hWnd,IDC_BUFFERS_SLIDER),TBM_SETPOS,TRUE,Config_DSound51.NumBuffers);
			sprintf_s(temp, 128, "%d (%d ms latency)",Config_DSound51.NumBuffers, 1000 / (96000 / (Config_DSound51.NumBuffers * BufferSize)));
			SetWindowText(GetDlgItem(hWnd,IDC_LATENCY_LABEL2),temp);
			break;

		case WM_COMMAND:
			wmId    = LOWORD(wParam);
			wmEvent = HIWORD(wParam);
			// Parse the menu selections:
			switch (wmId)
			{
				case IDOK:
					{
						int i = (int)SendMessage(GetDlgItem(hWnd,IDC_DS_DEVICE),CB_GETCURSEL,0,0);

						if(!devices[i].hasGuid)
						{
							Config_DSound51.Device[0]=0; // clear device name to ""
						}
						else
						{
							sprintf_s(Config_DSound51.Device,256,"{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
								devices[i].guid.Data1,
								devices[i].guid.Data2,
								devices[i].guid.Data3,
								devices[i].guid.Data4[0],
								devices[i].guid.Data4[1],
								devices[i].guid.Data4[2],
								devices[i].guid.Data4[3],
								devices[i].guid.Data4[4],
								devices[i].guid.Data4[5],
								devices[i].guid.Data4[6],
								devices[i].guid.Data4[7]
								);

							Config_DSound51.NumBuffers = GetSliderValue( hWnd, IDC_BUFFERS_SLIDER );
							Config_DSound51.GainL = GetSliderValue( hWnd, IDC_LEFT_GAIN_SLIDER );
							Config_DSound51.GainR = GetSliderValue( hWnd, IDC_RIGHT_GAIN_SLIDER );
							Config_DSound51.GainSL = GetSliderValue( hWnd, IDC_RLEFT_GAIN_SLIDER );
							Config_DSound51.GainSR = GetSliderValue( hWnd, IDC_RRIGHT_GAIN_SLIDER );
							Config_DSound51.GainLFE = GetSliderValue( hWnd, IDC_LFE_SLIDER );
							Config_DSound51.GainC = GetSliderValue( hWnd, IDC_CENTER_GAIN_SLIDER );
							Config_DSound51.AddCLR = GetSliderValue( hWnd, IDC_LR_CENTER_SLIDER );

							if( Config_DSound51.NumBuffers < 2 ) Config_DSound51.NumBuffers = 2;
							if( Config_DSound51.NumBuffers > MAX_BUFFER_COUNT ) Config_DSound51.NumBuffers = MAX_BUFFER_COUNT;
						}
					}
					EndDialog(hWnd,0);
					break;
				case IDCANCEL:
					EndDialog(hWnd,0);
					break;
				default:
					return FALSE;
			}
			break;

		case WM_HSCROLL:
			wmId    = LOWORD(wParam);
			wmEvent = HIWORD(wParam);
			switch(wmId) {
				//case TB_ENDTRACK:
				//case TB_THUMBPOSITION:
				case TB_LINEUP:
				case TB_LINEDOWN:
				case TB_PAGEUP:
				case TB_PAGEDOWN:
					wmEvent=(int)SendMessage((HWND)lParam,TBM_GETPOS,0,0);
				case TB_THUMBTRACK:
					if( wmEvent < 2 ) wmEvent = 2;
					if( wmEvent > MAX_BUFFER_COUNT ) wmEvent = MAX_BUFFER_COUNT;
					SendMessage((HWND)lParam,TBM_SETPOS,TRUE,wmEvent);
					sprintf_s(temp,128,"%d (%d ms latency)",wmEvent, 1000 / (96000 / (wmEvent * BufferSize)));
					SetWindowText(GetDlgItem(hWnd,IDC_LATENCY_LABEL2),temp);
					break;
				default:
					return FALSE;
			}
			break;

		case WM_VSCROLL:
			HANDLE_SCROLL_MESSAGE(IDC_LEFT_GAIN_SLIDER,IDC_LEFT_GAIN_EDIT);
			HANDLE_SCROLL_MESSAGE(IDC_RIGHT_GAIN_SLIDER,IDC_RIGHT_GAIN_EDIT);
			HANDLE_SCROLL_MESSAGE(IDC_RLEFT_GAIN_SLIDER,IDC_RLEFT_GAIN_EDIT);
			HANDLE_SCROLL_MESSAGE(IDC_RRIGHT_GAIN_SLIDER,IDC_RRIGHT_GAIN_EDIT);
			HANDLE_SCROLL_MESSAGE(IDC_CENTER_GAIN_SLIDER,IDC_CENTER_GAIN_EDIT);
			HANDLE_SCROLL_MESSAGE(IDC_LFE_SLIDER,IDC_LFE_EDIT);
			HANDLE_SCROLL_MESSAGE(IDC_LR_CENTER_SLIDER,IDC_LR_CENTER_EDIT);

		default:
			return FALSE;
	}
	return TRUE;
}
Пример #6
0
LRESULT CModuleControlLong::OnSliderScroll(UINT message, WPARAM wParam, LPARAM lParam, BOOL& bHandled) {
  UpdateValue(GetSliderValue());
  return 0;
}
Пример #7
0
LRESULT W_CALLBACK SliderWndProc(HWND hWnd, UINT msg, 
				 WPARAM wParam, LPARAM lParam)
{
    HWND hSBWnd;
    LONG lResult;
    ITEMID idWidget, idVertical, idMin = NULLID, idMax = NULLID;
    ITEMID idDesc, idVisible;
    double fMinV, fMaxV, fValue;
    RECT rCrect;
    double dSliderPos;
    BOOL bCommand = TRUE;
    short nTextHgt, nTitleHgt, nSlideHgt, nSlideLeft;

    switch (msg) {
      case WM_SETFOCUS:
          hSBWnd = GetDlgItem(hWnd, HSLIDERID);
          if (!hSBWnd)
              hSBWnd = GetDlgItem(hWnd, VSLIDERID);
          if (hSBWnd)
              SetFocus(hSBWnd);
          break;

      case WM_HSCROLL:
          hSBWnd = GetDlgItem(hWnd, HSLIDERID);
		  SetFocus(hSBWnd);
          idWidget = KpsGetWidgetFromWindow(hWnd);

          if (hSBWnd)
              dSliderPos = (double) GetScrollPos(hSBWnd, SB_CTL);

          switch (wParam) {
            case SB_LINEUP:
                break;

            case SB_LINEDOWN:
                break;

            case SB_PAGEUP:
                dSliderPos -= 1000;
                break;

            case SB_PAGEDOWN:
                dSliderPos += 1000;
                break;

            case SB_THUMBTRACK:
            case SB_THUMBPOSITION:
                dSliderPos = LOWORD(lParam);
                break;

            default:
                bCommand = FALSE;
                break;
          }
          if (bCommand)
          {
              if (dSliderPos > 10000.0)
                  dSliderPos = 10000.0;
              if (dSliderPos < 0.0)
                  dSliderPos = 0.0;

              GetSliderValue(idWidget, hWnd, wParam, dSliderPos);
          }
          break;
      case WM_VSCROLL:
          hSBWnd = GetDlgItem(hWnd, VSLIDERID);
		  SetFocus(hSBWnd);
          idWidget = KpsGetWidgetFromWindow(hWnd);

          if (hSBWnd)
              dSliderPos = (double) GetScrollPos(hSBWnd, SB_CTL);

          switch (wParam){
            case SB_LINEUP:
                break;
            case SB_LINEDOWN:
                break;
            case SB_PAGEUP:
                dSliderPos -= 1000;
                break;
            case SB_PAGEDOWN:
                dSliderPos += 1000;
                break;
            case SB_THUMBTRACK:
            case SB_THUMBPOSITION:
                dSliderPos = (short) LOWORD(lParam);
                break;

            default:
                bCommand = FALSE;
                break;
          }
          if (bCommand)
          {
              if (dSliderPos < -10000.0)
                  dSliderPos = -10000.0;
              if (dSliderPos > 0.0)
                  dSliderPos = 0.0;

              GetSliderValue(idWidget, hWnd, wParam, dSliderPos);
          }
          break;

      case IDG_RESET:
          idWidget = KpsGetWidgetFromWindow(hWnd);
          idVisible = KppGetSlotValue(idWidget, lpSNs->idVisibleSN);
          if (idVisible != lpIDs->idFalse)
          {
              GetClientRect(hWnd, (LPRECT) & rCrect);
              nSlideLeft = (rCrect.right / 2) - (SLIDERPAD / 2);
              GetSliderParam(hWnd, &nTitleHgt, &nTextHgt, &nSlideHgt);
              idVertical = KppGetSlotValue(idWidget, lpSNs->idVerticalSN);

              if (RetrieveSliderData(idWidget, &idMin, &idMax,
                                     (ITEMID *) NULL,
                                     &fMinV, &fMaxV, &fValue, &idDesc))
              {
                  if (idVertical == lpIDs->idTrue)
                  {
                      hSBWnd = GetDlgItem(hWnd, HSLIDERID);
                      if (hSBWnd)
                          DestroyWindow(hSBWnd);

                      hSBWnd = GetDlgItem(hWnd, VSLIDERID);
                      if (!hSBWnd)
                      {
                          hSBWnd = CreateWindow((LPSTR) "Scrollbar",
                                                (LPSTR) NULL,
                                                WS_CHILD | WS_CLIPSIBLINGS |
                                                SBS_VERT,
                                                nSlideLeft,
                                                nTitleHgt + (2 * HEIGHTPAD),
                                                SLIDERPAD, nSlideHgt,
                                                hWnd, VSLIDERID,
                                                hInstThisDll, (LPSTR) NULL);
                          SetScrollRange(hSBWnd, SB_CTL, -10000, 0, TRUE);
                          SetScrollPos(hSBWnd, SB_CTL, 0, TRUE);
                          ShowWindow(hSBWnd, SW_HIDE);
						  SetProp(hSBWnd, HORIZONTAL, FALSE); 

                          if (!lpOrigSliderProc)
                              lpOrigSliderProc =
                                  (FARPROC) GetClassLong(hSBWnd, GCL_WNDPROC);

                          SetWindowLong(hSBWnd, GWL_WNDPROC,
                                        (LONG) NewSliderProc);
                      }
                      else
                          MoveWindow(hSBWnd, nSlideLeft,
                                     nTitleHgt + (2 * HEIGHTPAD),
                                     SLIDERPAD, nSlideHgt, TRUE);
                  }
                  else
                  {
                      hSBWnd = GetDlgItem(hWnd, VSLIDERID);
                      if (hSBWnd)
                          DestroyWindow(hSBWnd);

                      hSBWnd = GetDlgItem(hWnd, HSLIDERID);
                      if (!hSBWnd)
                      {
                          hSBWnd = CreateWindow((LPSTR) "Scrollbar",
                                                (LPSTR) NULL,
                                                WS_CHILD | WS_CLIPSIBLINGS |
                                                SBS_HORZ,
                                                SLIDERPAD,
                                                nTitleHgt + (2 * HEIGHTPAD),
                                                rCrect.right - (2 * SLIDERPAD),
                                                nSlideHgt,
                                                hWnd, HSLIDERID,
                                                hInstThisDll, (LPSTR) NULL);
                          SetScrollRange(hSBWnd, SB_CTL, 0, 10000, TRUE);
                          ShowWindow(hSBWnd, SW_HIDE);
						  SetProp(hSBWnd, HORIZONTAL, TRUE); 

                          if (!lpOrigSliderProc)
                              lpOrigSliderProc =
                                  (FARPROC) GetClassLong(hSBWnd, GCL_WNDPROC);

                          SetWindowLong(hSBWnd, GWL_WNDPROC,
                                        (LONG) NewSliderProc);
                      }
                      else
                          MoveWindow(hSBWnd, SLIDERPAD, nTitleHgt + (2 * HEIGHTPAD),
                           rCrect.right - (2 * SLIDERPAD), nSlideHgt, TRUE);
                  }
              }
              BringWindowToTop(hWnd);
              hSBWnd = GetDlgItem(hWnd, HSLIDERID);
              if (!hSBWnd)
                  hSBWnd = GetDlgItem(hWnd, VSLIDERID);
              if (hSBWnd)
                  ShowWindow(hSBWnd, SW_SHOW);
          }
          InvalidateRect(hWnd, (LPRECT) NULL, TRUE);
          UpdateWindow(hWnd);
          return (LONG) TRUE;

      case WM_SIZE:
          if (wParam == SIZENORMAL)
              KpsSizeWidget(hWnd, LOWORD(lParam), HIWORD(lParam));
          GetClientRect(hWnd, (LPRECT) &rCrect);
          GetSliderParam(hWnd, &nTitleHgt, &nTextHgt, &nSlideHgt);

          hSBWnd = GetDlgItem(hWnd, VSLIDERID);
          if (hSBWnd != NULL)
          {
              nSlideLeft = (rCrect.right / 2) - (SLIDERPAD / 2);
              MoveWindow(hSBWnd, nSlideLeft, nTitleHgt + (2 * HEIGHTPAD),
                         SLIDERPAD, nSlideHgt, TRUE);
          }
          else
          {
              hSBWnd = GetDlgItem(hWnd, HSLIDERID);
              if (hSBWnd)
              {
                  MoveWindow(hSBWnd, SLIDERPAD, nTitleHgt + (2 * HEIGHTPAD),
                           rCrect.right - (2 * SLIDERPAD), nSlideHgt, TRUE);
              }
          }
          break;

      case WM_PAINT:
          lResult = (LONG) KpsDrawWidget(hWnd);
          hSBWnd = GetDlgItem(hWnd, VSLIDERID);
          if (!hSBWnd)
              hSBWnd = GetDlgItem(hWnd, HSLIDERID);
          if (hSBWnd)
          {
              InvalidateRect(hSBWnd, (LPRECT) NULL, TRUE);
              UpdateWindow(hSBWnd);
          }

          return (LONG) lResult;

      default:
          break;
    }

    return DefWindowProc(hWnd, msg, wParam, lParam);
}