Ordner öffnen und Windows-Lautstärke ändern

  • VB

  • fexs
  • 2777 Aufrufe 6 Antworten

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Ordner öffnen und Windows-Lautstärke ändern

    Hallo,
    die Frage is zwar sowas von simpel aber ich musses zum ersten mal machen un hab keine Ahnung wie es funktioniert. Ich will einfach nur über einen CommandButton einen Ordner öffnen.

    Ich dachte immer es geht mit Shell("C:/") oder so. Aber hab gerade bemerkt dasses so nicht geht:D
    Hab schon im Internet geguckt un 10000 Sachen gefunden, aber nicht den einfachen Befehl einen Ordner zu öffnen:D.
    Es is ja auch schon spät :depp:

    Wäre nett wenn mir mal einer sagen kann wie es funktioniert..;)
    Danke schonmal
    mfg fexs

    Edit:
    Achso un wo ich grad schon am dumme Fragen stellen bin:
    Weiß jemand mit welchem Befehl man "Ton Aus/Ein" hinbekommen könnte??
    Bis dann
    [COLOR="DarkRed"][SIZE="3"]Godspeed[/SIZE][/color] on [COLOR="DarkRed"][SIZE="3"]Devils[/SIZE][/color] Thunder

  • Hier gibt es noch eine offen Frage: VB6 oder VB.NET?

    Eine weitere Frage: Die Antworten öffnen alle einen Explorer.
    In einem Programm kann man damit reichlich wenig anfangen.

    Wills Du einen Explorer, oder einen Dateidialog aus einer Anwendung heraus?
    Es ist besser zu schweigen und für einen Narren gehalten zu werden, als zu reden und damit alle Zweifel zu beseitigen ...

  • Hallo,
    das was Zerd gesagt hat wollte ich nur wissen;)
    Danke:)

    Aber hat zufällig auch einer ne Ahnung wie das mit dem Ton aus/ Ton ein geht?^^
    Also gibts en Code dafür oder liegt vllt irgendwo im System ne .exe die bei klick den Ton ausmacht?:D
    Oder kann man sone .exe downloaden und ann irgendwie ausfürn?
    Könnte ja sein..
    Bis dann
    mfg
    [COLOR="DarkRed"][SIZE="3"]Godspeed[/SIZE][/color] on [COLOR="DarkRed"][SIZE="3"]Devils[/SIZE][/color] Thunder

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von fexs ()

  • Hier das Ganze in VB.NET

    Quellcode

    1. const int MAXPNAMELEN = 32;
    2. const int MIXER_SHORT_NAME_CHARS = 16;
    3. const int MIXER_LONG_NAME_CHARS = 64;
    5. [Flags] enum MIXERLINE_LINEF : uint{
    6. ACTIVE = 0x00000001,
    7. DISCONNECTED = 0x00008000,
    8. SOURCE = 0x80000000
    9. }
    10. [Flags] enum MIXER : uint{
    11. GETLINEINFOF_DESTINATION = 0x00000000,
    12. GETLINEINFOF_SOURCE = 0x00000001,
    13. GETLINEINFOF_LINEID = 0x00000002,
    14. GETLINEINFOF_COMPONENTTYPE = 0x00000003,
    15. GETLINEINFOF_TARGETTYPE = 0x00000004,
    16. GETLINEINFOF_QUERYMASK = 0x0000000F,
    18. GETLINECONTROLSF_ALL = 0x00000000,
    19. GETLINECONTROLSF_ONEBYID = 0x00000001,
    20. GETLINECONTROLSF_ONEBYTYPE = 0x00000002,
    21. GETLINECONTROLSF_QUERYMASK = 0x0000000F,
    23. GETCONTROLDETAILSF_VALUE = 0x00000000,
    24. GETCONTROLDETAILSF_LISTTEXT = 0x00000001,
    25. GETCONTROLDETAILSF_QUERYMASK = 0x0000000F,
    27. OBJECTF_MIXER = 0x00000000,
    28. OBJECTF_WAVEOUT = 0x10000000,
    29. OBJECTF_WAVEIN = 0x20000000,
    30. OBJECTF_MIDIOUT = 0x30000000,
    31. OBJECTF_MIDIIN = 0x40000000,
    32. OBJECTF_AUX = 0x50000000,
    33. OBJECTF_HANDLE = 0x80000000,
    34. OBJECTF_HMIXER = OBJECTF_HANDLE | OBJECTF_MIXER,
    35. OBJECTF_HWAVEOUT = OBJECTF_HANDLE | OBJECTF_WAVEOUT,
    36. OBJECTF_HWAVEIN = OBJECTF_HANDLE | OBJECTF_WAVEIN,
    37. OBJECTF_HMIDIOUT = OBJECTF_HANDLE | OBJECTF_MIDIOUT,
    38. OBJECTF_HMIDIIN = OBJECTF_HANDLE | OBJECTF_MIDIIN
    39. }
    40. [Flags] enum MIXERCONTROL_CT : uint{
    41. CLASS_MASK = 0xF0000000,
    42. CLASS_CUSTOM = 0x00000000,
    43. CLASS_METER = 0x10000000,
    44. CLASS_SWITCH = 0x20000000,
    45. CLASS_NUMBER = 0x30000000,
    46. CLASS_SLIDER = 0x40000000,
    47. CLASS_FADER = 0x50000000,
    48. CLASS_TIME = 0x60000000,
    49. CLASS_LIST = 0x70000000,
    51. SUBCLASS_MASK = 0x0F000000,
    53. SC_SWITCH_BOOLEAN = 0x00000000,
    54. SC_SWITCH_BUTTON = 0x01000000,
    56. SC_METER_POLLED = 0x00000000,
    58. SC_TIME_MICROSECS = 0x00000000,
    59. SC_TIME_MILLISECS = 0x01000000,
    61. SC_LIST_SINGLE = 0x00000000,
    62. SC_LIST_MULTIPLE = 0x01000000,
    64. UNITS_MASK = 0x00FF0000,
    65. UNITS_CUSTOM = 0x00000000,
    66. UNITS_BOOLEAN = 0x00010000,
    67. UNITS_SIGNED = 0x00020000,
    68. UNITS_UNSIGNED = 0x00030000,
    69. UNITS_DECIBELS = 0x00040000, /* in 10ths */
    70. UNITS_PERCENT = 0x00050000, /* in 10ths */
    71. }
    72. [Flags] enum MIXERCONTROL_CONTROLTYPE : uint{
    73. CUSTOM = MIXERCONTROL_CT.CLASS_CUSTOM | MIXERCONTROL_CT.UNITS_CUSTOM,
    74. BOOLEANMETER = MIXERCONTROL_CT.CLASS_METER | MIXERCONTROL_CT.SC_METER_POLLED | MIXERCONTROL_CT.UNITS_BOOLEAN,
    75. SIGNEDMETER = MIXERCONTROL_CT.CLASS_METER | MIXERCONTROL_CT.SC_METER_POLLED | MIXERCONTROL_CT.UNITS_SIGNED,
    76. PEAKMETER = SIGNEDMETER + 1,
    77. UNSIGNEDMETER = MIXERCONTROL_CT.CLASS_METER | MIXERCONTROL_CT.SC_METER_POLLED | MIXERCONTROL_CT.UNITS_UNSIGNED,
    78. BOOLEAN = MIXERCONTROL_CT.CLASS_SWITCH | MIXERCONTROL_CT.SC_SWITCH_BOOLEAN | MIXERCONTROL_CT.UNITS_BOOLEAN,
    79. ONOFF = BOOLEAN + 1,
    80. MUTE = BOOLEAN + 2,
    81. MONO = BOOLEAN + 3,
    82. LOUDNESS = BOOLEAN + 4,
    83. STEREOENH = BOOLEAN + 5,
    84. BASS_BOOST = BOOLEAN + 0x00002277,
    85. BUTTON = MIXERCONTROL_CT.CLASS_SWITCH | MIXERCONTROL_CT.SC_SWITCH_BUTTON | MIXERCONTROL_CT.UNITS_BOOLEAN,
    86. DECIBELS = MIXERCONTROL_CT.CLASS_NUMBER | MIXERCONTROL_CT.UNITS_DECIBELS,
    87. SIGNED = MIXERCONTROL_CT.CLASS_NUMBER | MIXERCONTROL_CT.UNITS_SIGNED,
    88. UNSIGNED = MIXERCONTROL_CT.CLASS_NUMBER | MIXERCONTROL_CT.UNITS_UNSIGNED,
    89. PERCENT = MIXERCONTROL_CT.CLASS_NUMBER | MIXERCONTROL_CT.UNITS_PERCENT,
    90. SLIDER = MIXERCONTROL_CT.CLASS_SLIDER | MIXERCONTROL_CT.UNITS_SIGNED,
    91. PAN = SLIDER + 1,
    92. QSOUNDPAN = SLIDER + 2,
    93. FADER = MIXERCONTROL_CT.CLASS_FADER | MIXERCONTROL_CT.UNITS_UNSIGNED,
    94. VOLUME = FADER + 1,
    95. BASS = FADER + 2,
    96. TREBLE = FADER + 3,
    97. EQUALIZER = FADER + 4,
    98. SINGLESELECT = MIXERCONTROL_CT.CLASS_LIST | MIXERCONTROL_CT.SC_LIST_SINGLE | MIXERCONTROL_CT.UNITS_BOOLEAN,
    99. MUX = SINGLESELECT + 1,
    100. MULTIPLESELECT = MIXERCONTROL_CT.CLASS_LIST | MIXERCONTROL_CT.SC_LIST_MULTIPLE | MIXERCONTROL_CT.UNITS_BOOLEAN,
    101. MIXER = MULTIPLESELECT + 1,
    102. MICROTIME = MIXERCONTROL_CT.CLASS_TIME | MIXERCONTROL_CT.SC_TIME_MICROSECS | MIXERCONTROL_CT.UNITS_UNSIGNED,
    103. MILLITIME = MIXERCONTROL_CT.CLASS_TIME | MIXERCONTROL_CT.SC_TIME_MILLISECS | MIXERCONTROL_CT.UNITS_UNSIGNED
    104. }
    106. [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
    107. struct MIXERLINE{
    108. [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
    109. public struct TargetInfo{
    110. public uint dwType;
    111. public uint dwDeviceID;
    112. public ushort wMid;
    113. public ushort wPid;
    114. public uint vDriverVersion;
    115. [MarshalAs(UnmanagedType.ByValTStr, SizeConst=MAXPNAMELEN)]
    116. public string szPname;
    117. }
    119. public uint cbStruct;
    120. public uint dwDestination;
    121. public uint dwSource;
    122. public uint dwLineID;
    123. public MIXERLINE_LINEF fdwLine;
    124. public uint dwUser;
    125. public uint dwComponentType;
    126. public uint cChannels;
    127. public uint cConnection;
    128. public uint cControls;
    129. [MarshalAs(UnmanagedType.ByValTStr, SizeConst=MIXER_SHORT_NAME_CHARS)]
    130. public string szShortName;
    131. [MarshalAs(UnmanagedType.ByValTStr, SizeConst=MIXER_LONG_NAME_CHARS)]
    132. public string szName;
    133. public TargetInfo Target;
    134. }
    135. [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
    136. struct MIXERCONTROL{
    137. [StructLayout(LayoutKind.Explicit)]
    138. public struct BoundsInfo{
    139. [FieldOffset(0)]
    140. public int lMinimum;
    141. [FieldOffset(4)]
    142. public int lMaximum;
    143. [FieldOffset(0)]
    144. public uint dwMinimum;
    145. [FieldOffset(4)]
    146. public uint dwMaximum;
    147. [FieldOffset(8), MarshalAs(UnmanagedType.ByValArray, SizeConst=4)]
    148. public uint[] dwReserved;
    149. }
    150. [StructLayout(LayoutKind.Explicit)]
    151. public struct MetricsInfo{
    152. [FieldOffset(0)]
    153. public uint cSteps;
    154. [FieldOffset(0)]
    155. public uint cbCustomData;
    156. [FieldOffset(4), MarshalAs(UnmanagedType.ByValArray, SizeConst=5)]
    157. public uint[] dwReserved;
    158. }
    160. public uint cbStruct;
    161. public uint dwControlID;
    162. public MIXERCONTROL_CONTROLTYPE dwControlType;
    163. public uint fdwControl;
    164. public uint cMultipleItems;
    165. [MarshalAs(UnmanagedType.ByValTStr, SizeConst=MIXER_SHORT_NAME_CHARS)]
    166. public string szShortName;
    167. [MarshalAs(UnmanagedType.ByValTStr, SizeConst=MIXER_LONG_NAME_CHARS)]
    168. public string szName;
    169. public BoundsInfo Bounds;
    170. public MetricsInfo Metrics;
    171. }
    172. [StructLayout(LayoutKind.Explicit)]
    173. struct MIXERLINECONTROLS{
    174. [FieldOffset(0)]
    175. public uint cbStruct;
    176. [FieldOffset(4)]
    177. public uint dwLineID;
    178. [FieldOffset(8)]
    179. public uint dwControlID;
    180. [FieldOffset(8)] // not a typo! overlaps previous field
    181. public uint dwControlType;
    182. [FieldOffset(12)]
    183. public uint cControls;
    184. [FieldOffset(16)]
    185. public uint cbmxctrl;
    186. [FieldOffset(20)]
    187. public IntPtr pamxctrl;
    188. }
    189. [StructLayout(LayoutKind.Explicit)]
    190. struct MIXERCONTROLDETAILS{
    191. [FieldOffset(0)]
    192. public uint cbStruct;
    193. [FieldOffset(4)]
    194. public uint dwControlID;
    195. [FieldOffset(8)]
    196. public uint cChannels;
    197. [FieldOffset(12)]
    198. public IntPtr hwndOwner;
    199. [FieldOffset(12)] // not a typo!
    200. public uint cMultipleItems;
    201. [FieldOffset(16)]
    202. public uint cbDetails;
    203. [FieldOffset(20)]
    204. public IntPtr paDetails;
    205. }
    206. [StructLayout(LayoutKind.Sequential)]
    207. struct VOLUME{
    208. public int left;
    209. public int right;
    210. }
    211. struct MixerInfo{
    212. public uint volumeCtl;
    213. public uint muteCtl;
    214. public int minVolume;
    215. public int maxVolume;
    216. }
    218. [DllImport('WinMM.dll', CharSet=CharSet.Auto)]
    219. static extern uint mixerGetLineInfo (IntPtr hmxobj, ref MIXERLINE pmxl, MIXER flags);
    221. [DllImport('WinMM.dll', CharSet=CharSet.Auto)]
    222. static extern uint mixerGetLineControls (IntPtr hmxobj, ref MIXERLINECONTROLS pmxlc, MIXER flags);
    224. [DllImport('WinMM.dll', CharSet=CharSet.Auto)]
    225. static extern uint mixerGetControlDetails(IntPtr hmxobj, ref MIXERCONTROLDETAILS pmxcd, MIXER flags);
    227. [DllImport('WinMM.dll', CharSet=CharSet.Auto)]
    228. static extern uint mixerSetControlDetails(IntPtr hmxobj, ref MIXERCONTROLDETAILS pmxcd, MIXER flags);
    230. static MixerInfo GetMixerControls(){
    231. MIXERLINE mxl = new MIXERLINE();
    232. MIXERLINECONTROLS mlc = new MIXERLINECONTROLS();
    233. mxl.cbStruct = (uint)Marshal.SizeOf(typeof(MIXERLINE));
    234. mlc.cbStruct = (uint)Marshal.SizeOf(typeof(MIXERLINECONTROLS));
    236. mixerGetLineInfo(IntPtr.Zero, ref mxl, MIXER.OBJECTF_MIXER | MIXER.GETLINEINFOF_DESTINATION);
    238. mlc.dwLineID = mxl.dwLineID;
    239. mlc.cControls = mxl.cControls;
    240. mlc.cbmxctrl = (uint)Marshal.SizeOf(typeof(MIXERCONTROL));
    241. mlc.pamxctrl = Marshal.AllocHGlobal((int)(mlc.cbmxctrl * mlc.cControls));
    243. mixerGetLineControls(IntPtr.Zero, ref mlc, MIXER.OBJECTF_MIXER | MIXER.GETLINECONTROLSF_ALL);
    245. MixerInfo rtn = new MixerInfo();
    247. for(int i = 0; i < mlc.cControls; i++){
    248. MIXERCONTROL mxc = (MIXERCONTROL)Marshal.PtrToStructure((IntPtr)((int)mlc.pamxctrl + (int)mlc.cbmxctrl * i), typeof(MIXERCONTROL));
    249. switch(mxc.dwControlType){
    250. case MIXERCONTROL_CONTROLTYPE.VOLUME:
    251. rtn.volumeCtl = mxc.dwControlID;
    252. rtn.minVolume = mxc.Bounds.lMinimum;
    253. rtn.maxVolume = mxc.Bounds.lMaximum;
    254. break;
    255. case MIXERCONTROL_CONTROLTYPE.MUTE:
    256. rtn.muteCtl = mxc.dwControlID;
    257. break;
    258. }
    259. }
    261. Marshal.FreeHGlobal(mlc.pamxctrl);
    263. return rtn;
    264. }
    265. static VOLUME GetVolume(MixerInfo mi){
    266. MIXERCONTROLDETAILS mcd = new MIXERCONTROLDETAILS();
    267. mcd.cbStruct = (uint)Marshal.SizeOf(typeof(MIXERCONTROLDETAILS));
    268. mcd.dwControlID = mi.volumeCtl;
    269. mcd.cMultipleItems = 0;
    270. mcd.cChannels = 2;
    271. mcd.cbDetails = (uint)Marshal.SizeOf(typeof(VOLUME));
    272. mcd.paDetails = Marshal.AllocHGlobal((int)mcd.cbDetails);
    274. mixerGetControlDetails(IntPtr.Zero, ref mcd, MIXER.GETCONTROLDETAILSF_VALUE | MIXER.OBJECTF_MIXER);
    276. VOLUME rtn = (VOLUME)Marshal.PtrToStructure(mcd.paDetails, typeof(VOLUME));
    278. Marshal.FreeHGlobal(mcd.paDetails);
    280. return rtn;
    281. }
    282. static bool IsMuted(MixerInfo mi){
    283. MIXERCONTROLDETAILS mcd = new MIXERCONTROLDETAILS();
    284. mcd.cbStruct = (uint)Marshal.SizeOf(typeof(MIXERCONTROLDETAILS));
    285. mcd.dwControlID = mi.muteCtl;
    286. mcd.cMultipleItems = 0;
    287. mcd.cChannels = 1;
    288. mcd.cbDetails = 4;
    289. mcd.paDetails = Marshal.AllocHGlobal((int)mcd.cbDetails);
    291. mixerGetControlDetails(IntPtr.Zero, ref mcd, MIXER.GETCONTROLDETAILSF_VALUE | MIXER.OBJECTF_MIXER);
    293. int rtn = Marshal.ReadInt32(mcd.paDetails);
    295. Marshal.FreeHGlobal(mcd.paDetails);
    297. return rtn != 0;
    298. }
    299. static void AdjustVolume(MixerInfo mi, int delta){
    300. VOLUME volume = GetVolume(mi);
    302. if(delta > 0){
    303. volume.left = Math.Min(mi.maxVolume, volume.left + delta);
    304. volume.right = Math.Min(mi.maxVolume, volume.right + delta);
    305. }else{
    306. volume.left = Math.Max(mi.minVolume, volume.left + delta);
    307. volume.right = Math.Max(mi.minVolume, volume.right + delta);
    308. }
    310. SetVolume(mi, volume);
    311. }
    312. static void SetVolume(MixerInfo mi, VOLUME volume){
    313. MIXERCONTROLDETAILS mcd = new MIXERCONTROLDETAILS();
    314. mcd.cbStruct = (uint)Marshal.SizeOf(typeof(MIXERCONTROLDETAILS));
    315. mcd.dwControlID = mi.volumeCtl;
    316. mcd.cMultipleItems = 0;
    317. mcd.cChannels = 2;
    318. mcd.cbDetails = (uint)Marshal.SizeOf(typeof(VOLUME));
    319. mcd.paDetails = Marshal.AllocHGlobal((int)mcd.cbDetails);
    321. Marshal.StructureToPtr(volume, mcd.paDetails, false);
    323. mixerSetControlDetails(IntPtr.Zero, ref mcd, MIXER.GETCONTROLDETAILSF_VALUE | MIXER.OBJECTF_MIXER);
    325. Marshal.FreeHGlobal(mcd.paDetails);
    326. }
    327. static void SetMute(MixerInfo mi, bool mute){
    328. MIXERCONTROLDETAILS mcd = new MIXERCONTROLDETAILS();
    329. mcd.cbStruct = (uint)Marshal.SizeOf(typeof(MIXERCONTROLDETAILS));
    330. mcd.dwControlID = mi.muteCtl;
    331. mcd.cMultipleItems = 0;
    332. mcd.cChannels = 1;
    333. mcd.cbDetails = 4;
    334. mcd.paDetails = Marshal.AllocHGlobal((int)mcd.cbDetails);
    336. Marshal.WriteInt32(mcd.paDetails, mute ? 1 : 0);
    338. mixerSetControlDetails(IntPtr.Zero, ref mcd, MIXER.GETCONTROLDETAILSF_VALUE | MIXER.OBJECTF_MIXER);
    340. Marshal.FreeHGlobal(mcd.paDetails);
    341. }
    Alles anzeigen
    Es ist besser zu schweigen und für einen Narren gehalten zu werden, als zu reden und damit alle Zweifel zu beseitigen ...