Database Users

Notify Icon works on Win Mobile 5 but not on Win Mobile 2003

Hello together,
does anyone know why a Notify Icon is shown on Windows Mobile 5.0 Pocket PC's but not shown on Windows Mobile 2003 Pocket PC's?
Here is the code of my Notify Icon class:
Code:
using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
namespace NotifyClient
{
public class NotifyIcon
{
//Declare click event
public event System.EventHandler Click;
private WindowSink windowSink;
private int uID = 5000;
//Constructor
public NotifyIcon()
{
//Create instance of the MessageWindow subclass
windowSink = new WindowSink(this);
windowSink.uID = uID;
}
//Destructor
~NotifyIcon()
{
Remove();
}
public void Add(IntPtr hIcon)
{
TrayMessage(windowSink.Hwnd, NIM_ADD, (uint)uID, hIcon);
}
public void Remove()
{
TrayMessage(windowSink.Hwnd, NIM_DELETE, (uint)uID, IntPtr.Zero);
}
public void Modify(IntPtr hIcon)
{
TrayMessage(windowSink.Hwnd, NIM_MODIFY, (uint)uID, hIcon);
}
private void TrayMessage(IntPtr hwnd, int dwMessage, uint uID, IntPtr hIcon)
{
NOTIFYICONDATA notdata = new NOTIFYICONDATA();
notdata.cbSize = 152;
notdata.hIcon = hIcon;
notdata.hWnd = hwnd;
notdata.uCallbackMessage = WM_NOTIFY_TRAY;
notdata.uFlags = NIF_MESSAGE | NIF_ICON;
notdata.uID = uID;
int ret = Shell_NotifyIcon(dwMessage, ref notdata);
}
#region API Declarations
internal const int WM_LBUTTONDOWN = 0x0201;
//User defined message
internal const int WM_NOTIFY_TRAY = 0x0400 + 2001;
internal const int NIM_ADD = 0x00000000;
internal const int NIM_MODIFY = 0x00000001;
internal const int NIM_DELETE = 0x00000002;
const int NIF_MESSAGE = 0x00000001;
const int NIF_ICON = 0x00000002;
internal struct NOTIFYICONDATA
{
internal int cbSize;
internal IntPtr hWnd;
internal uint uID;
internal uint uFlags;
internal uint uCallbackMessage;
internal IntPtr hIcon;
//internal char[] szTip = new char[64];
//internal IntPtr szTip;
}
[DllImport("coredll.dll")]
internal static extern int Shell_NotifyIcon(
int dwMessage,ref NOTIFYICONDATA pnid);
[DllImport("coredll.dll")]
internal static extern int SetForegroundWindow(IntPtr hWnd);
[DllImport("coredll.dll")]
internal static extern int ShowWindow(
IntPtr hWnd,
int nCmdShow);
[DllImport("coredll.dll")]
internal static extern IntPtr GetFocus();
#endregion
#region WindowSink
internal class WindowSink : Microsoft.WindowsCE.Forms.MessageWindow
{
//Private members
private int m_uID = 0;
private NotifyIcon notifyIcon;
//Constructor
public WindowSink(NotifyIcon notIcon)
{
notifyIcon = notIcon;
}
public int uID
{
set
{
m_uID = value;
}
}
protected override void WndProc(ref Microsoft.WindowsCE.Forms.Message msg)
{
if (msg.Msg == WM_NOTIFY_TRAY)
{
if((int)msg.LParam == WM_LBUTTONDOWN)
{
if ((int)msg.WParam == m_uID)
{
//If somebody hooked, raise the event
if (notifyIcon.Click != null)
notifyIcon.Click(notifyIcon, null);
}
}
}
}
}
#endregion
}
}
The usage of this class is in my WM 5.0 project identical with my WM 2003 project. But the icon is not shown...
It seems like the space in the "Task Bar" is reserved and my application reacts correct when I click on the place the icon should appear...
Does anyone have an idea?
Greetings
Alex

Finding Windows and their executable filepaths

I've just spent a lot of time looking for ways to tie Windows and process exe files together and I saw a lot of people asking after similar topics.
It was somewhat frustrating because of numerous little difficulties - using CreateToolhelp32Snapshot unpredictably fails, GetProcessById is no good if the process wasn't started with StartInfo, because you can have multiple windows to a process it's hard to identify which is a processes mainwindow.
But I solved my problem, a solution that I haven't seen elsewhere, so I thought I'd share it here. This is my solution to the specific problem of finding a window to match an executable file path....
This is on WM6, using CF2 in C#.
Used as follows (with S2U2 as the example):
Ionwerks.Window w = new Ionwerks.Window(@"\Program Files\S2U2\S2U2.exe");
IntPtr WindowsHandle = w.handle;
Code:
using System;
using System.Runtime.InteropServices;
using System.Diagnostics;
namespace Ionwerks
{
delegate int EnumWindowsProc(IntPtr hwnd, IntPtr lParam);
class Window
{
private EnumWindowsProc callbackDelegate;
private IntPtr callbackDelegatePointer;
private IntPtr m_handle = IntPtr.Zero;
private string moduleFileName = "";
//Construct from path
public Window(string path)
{
moduleFileName = path;
Enumerate();
}
public IntPtr handle
{
get
{
return m_handle;
}
}
private void Enumerate() {
callbackDelegate = new EnumWindowsProc(EnumWindowsCallbackProc);
callbackDelegatePointer = Marshal.GetFunctionPointerForDelegate(callbackDelegate);
EnumWindows(callbackDelegatePointer, 0);
}
[DllImport("coredll.dll", SetLastError = true)]
private static extern bool EnumWindows(IntPtr lpEnumFunc, uint lParam);
[DllImport("coredll.dll", EntryPoint = "GetModuleFileNameW", SetLastError = true)]
private static extern uint GetModuleFileName(IntPtr hModule, [MarshalAs(UnmanagedType.LPWStr)] string lpFileName, uint nSize);
[DllImport("coredll")]
private static extern uint GetWindowThreadProcessId(IntPtr hwnd, out int lpdwProcessId);
[DllImport("coredll.dll")]
private static extern IntPtr OpenProcess(int flags, bool fInherit, int PID);
[DllImport("coredll.dll")]
private static extern bool CloseHandle(IntPtr handle);
[DllImport("coredll.dll")]
private static extern bool IsWindowVisible(IntPtr handle);
private string ModuleFileName = new string((char)0x20, 255);
private int EnumWindowsCallbackProc(IntPtr hwnd, IntPtr lParam)
{
//get windows process
int pid = 0;
GetWindowThreadProcessId(hwnd, out pid);
IntPtr pHnd = OpenProcess(0, false, pid);
//get processes image
GetModuleFileName(pHnd, ModuleFileName, (uint)ModuleFileName.Length);
//if paths match up
if (String.Compare(ModuleFileName.Substring(0, ModuleFileName.IndexOf('\0')), moduleFileName, true) == 0) {
//only interested in processes mainwindow
if (hwnd == Process.GetProcessById(pid).MainWindowHandle)
{
m_handle = hwnd;
}
}
CloseHandle(pHnd);
return 1;
}
}
}

thanks man! your code helped!

simple explanation ... ?.... what that codes for and how to use

fade to black

I want my form to fade to black until the app. exits, when I click my self-made exit-button. I've got my inspiration from the apps. "S2U2" and "PocketCM" ... they fade to black really smooth and fast.
I already got my app working... but it is extrem slowly.
for those who are interested in my application
Code:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
namespace TransparentSample
{
public partial class Form1 : Form
{
public struct BlendFunction
{
public byte BlendOp;
public byte BlendFlags;
public byte SourceConstantAlpha;
public byte AlphaFormat;
}
public enum BlendOperation : byte
{
AC_SRC_OVER = 0x00
}
public enum BlendFlags : byte
{
Zero = 0x00
}
public enum SourceConstantAlpha : byte
{
Transparent = 0x00,
Opaque = 0xFF
}
public enum AlphaFormat : byte
{
AC_SRC_ALPHA = 0x01
}
[DllImport("coredll.dll")]
extern public static Int32 AlphaBlend(IntPtr hdcDest,
Int32 xDest,
Int32 yDest,
Int32 cxDest,
Int32 cyDest,
IntPtr hdcSrc,
Int32 xSrc,
Int32 ySrc,
Int32 cxSrc,
Int32 cySrc,
BlendFunction blendFunction);
Bitmap backBuffer = null;
Byte alpha;
public Form1()
{
InitializeComponent();
backBuffer = new Bitmap( pictureBox1.Image);
alpha = 0x00;
}
protected override void OnPaintBackground(PaintEventArgs e)
{
// Prevent flicker, we will take care of the background in Form1_Paint
}
private void Form1_Paint(object sender, PaintEventArgs e)
{
if (backBuffer != null)
{
Graphics gxBuffer = Graphics.FromImage(backBuffer);
gxBuffer.Clear(Color.White);
gxBuffer.DrawImage(pictureBox1.Image, 0, 0);
Graphics gxSrc = Graphics.FromImage( new Bitmap( backBuffer.Width, backBuffer.Height));
gxSrc.Clear(Color.Black);
IntPtr hdcDst = gxBuffer.GetHdc();
IntPtr hdcSrc = gxSrc.GetHdc();
BlendFunction blendFunction = new BlendFunction();
blendFunction.BlendOp = (byte)BlendOperation.AC_SRC_OVER; // Only supported blend operation
blendFunction.BlendFlags = (byte)BlendFlags.Zero; // Documentation says put 0 here
blendFunction.SourceConstantAlpha = (byte)alpha;// Constant alpha factor
blendFunction.AlphaFormat = (byte)0; // Don't look for per pixel alpha
Form1.AlphaBlend(
hdcDst,
0,
0,
backBuffer.Width,
backBuffer.Height,
hdcSrc,
0,
0,
pictureBox1.Width,
pictureBox1.Height,
blendFunction);
gxBuffer.ReleaseHdc(hdcDst); // Required cleanup to GetHdc()
gxSrc.ReleaseHdc(hdcSrc); // Required cleanup to GetHdc()
// Put the final composed image on screen.
e.Graphics.DrawImage(backBuffer, 0, 0);
}
}
private void btnExit_Click(object sender, EventArgs e)
{
tmrFade.Enabled = true;
}
private void tmrFade_Tick(object sender, EventArgs e)
{
// timers interval: 100ms ... so this should take 1Sek.
alpha = (byte)(alpha + (byte)25);
if (alpha == 250)
{
alpha = 0xff;
Application.Exit();
}
this.Refresh();
}
}
}
Have you got a better idea to solve this?
thanks

Look for DIBSection, but in .NET that's not gonna be easy.

You might be right about .NET
I already thought about coding in c++ ...I think that's what I am going to do.
Thank you

RIL problem

With this code:
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
namespace TEST1
{
public partial class Form1 : Form
{
public delegate void RILRESULTCALLBACK(int dwCode, IntPtr hrCmdID, IntPtr lpData, int cbData, int dwParam);
public delegate void RILNOTIFYCALLBACK(int dwCode, IntPtr lpData, int cbData, int dwParam);
public static IntPtr hRil;
[StructLayout(LayoutKind.Explicit)]
class RILADDRESS
{
[FieldOffset(0)]
public uint dwSize;
[FieldOffset(4)]
public uint dwParams;
[FieldOffset(8)]
public uint dwType;
[FieldOffset(12)]
public uint dwNumPlan;
[FieldOffset(16)]
public byte[] sAddress = new byte[256 * 2];
//[FieldOffset(528)]
}
[StructLayout(LayoutKind.Explicit)]
class RILSUBADDRESS
{
[FieldOffset(0)]
public uint dwSize;
[FieldOffset(4)]
public uint dwParams;
[FieldOffset(8)]
public uint dwType;
[FieldOffset(12)]
public byte[] sSubAddress = new byte[256 * 2];
//[FieldOffset(524)]
}
[StructLayout(LayoutKind.Explicit)]
class RILREMOTEPARTYINFO
{
[FieldOffset(0)]
public uint dwSize;
[FieldOffset(4)]
public uint dwParams;
/*[FieldOffset(8)]
public RILADDRESS rilAddress = new RILADDRESS();
[FieldOffset(536)]
public RILSUBADDRESS rilSubAddress = new RILSUBADDRESS();
[FieldOffset(1060)]
public char[] sDescription = new char[256 * 2];
[FieldOffset(1572)]
public uint dwValidity;*/
}
[StructLayout(LayoutKind.Explicit)]
class RILCELLTOWERINFO
{
[FieldOffset(0)]
uint dwSize;
[FieldOffset(4)]
uint dwParams;
[FieldOffset(8)]
public uint dwMobileCountryCode;
[FieldOffset(12)]
public uint dwMobileNetworkCode;
[FieldOffset(16)]
public uint dwLocationAreaCode;
[FieldOffset(20)]
public uint dwCellID;
[FieldOffset(24)]
uint dwBaseStationID;
[FieldOffset(28)]
uint dwBroadcastControlChannel;
[FieldOffset(32)]
uint dwRxLevel;
[FieldOffset(36)]
uint dwRxLevelFull;
[FieldOffset(40)]
uint dwRxLevelSub;
[FieldOffset(44)]
uint dwRxQuality;
[FieldOffset(48)]
uint dwRxQualityFull;
[FieldOffset(52)]
uint dwRxQualitySub;
/* More minor interesting fields below */
}
[StructLayout(LayoutKind.Explicit)]
class RILRINGINFO
{
[FieldOffset(0)]
public uint dwSize;
[FieldOffset(4)]
public uint dwParams;
[FieldOffset(8)]
public uint dwCallType;
[FieldOffset(12)]
public uint dwAddressID;
}
//private static bool done = false;
private static string result = "";
[DllImport("ril.dll")]
private static extern IntPtr RIL_Initialize(int dwIndex, RILRESULTCALLBACK pfnResult, RILNOTIFYCALLBACK pfnNotify, int dwNotificationClasses, int dwParam, out IntPtr lphRil);
[DllImport("ril.dll", EntryPoint = "RIL_GetCellTowerInfo")]
private static extern IntPtr RIL_GetCellTowerInfo(IntPtr hRil);
[DllImport("ril.dll", EntryPoint = "RIL_Hangup")]
private static extern IntPtr RIL_Hangup(IntPtr hRil);
[DllImport("ril.dll")]
private static extern IntPtr RIL_Deinitialize(IntPtr hRil);
public static void f_notify(int dwCode, IntPtr lpData, int cbData, int dwParam)
{
string strMsg = "";
switch (dwCode & 0x00ff0000) //RIL_NCLASS_ALL
{
case 0x00080000: //RIL_NCLASS_SUPSERVICE
switch (dwCode & 0xff)
{
case 0x00000001: // RIL_NOTIFY_CALLERID
RILREMOTEPARTYINFO rilRemotePartyInfo = new RILREMOTEPARTYINFO();
Marshal.PtrToStructure(lpData, rilRemotePartyInfo);
break;
case 0x00000002: // RIL_NOTIFY_DIALEDRID
break;
case 0x00000003: // RIL_NOTIFY_CALLWAITING
break;
case 0x00000004: // RIL_NOTIFY_SUPSERVICEDATA
break;
}
strMsg += "SUPSERVICE";
break;
case 0x00010000: //RIL_NCLASS_CALLCTRL
switch (dwCode & 0xff)
{
case 0x00000001: // RIL_NOTIFY_RING
RILRINGINFO rilRingInfo = new RILRINGINFO();
Marshal.PtrToStructure(lpData, rilRingInfo);
switch (rilRingInfo.dwCallType)
{
case 0x00000000:
strMsg += "UNKNOWN ";
break;
case 0x00000001:
strMsg += "VOICE ";
//RIL_Hangup(hRil);
break;
case 0x00000002:
strMsg += "DATA ";
break;
case 0x00000003:
strMsg += "FAX ";
break;
default:
strMsg += "UNHANDLED ";
break;
}
break;
case 0x00000002: // RIL_NOTIFY_CONNECT
strMsg += "CONNECT ";
break;
case 0x00000003: // RIL_NOTIFY_DISCONNECT
strMsg += "DISCONNECT ";
break;
case 0x0000000B: // RIL_NOTIFY_CALLPROGRESSINFO
strMsg += "CPI ";
break;
default:
strMsg += "SOME ";
break;
}
strMsg += "CALL";
break;
case 0x00020000: // RIL_NCLASS_MESSAGE
switch (dwCode & 0xff)
{
case 0x00000001: // RIL_NOTIFY_MESSAGE
strMsg += "NEW ";
break;
default:
strMsg += "SOME ";
break;
}
strMsg += "SMS";
break;
}
//MessageBox.Show(strMsg);
}
public static void f_result(int dwCode, IntPtr hrCmdID, IntPtr lpData, int cbData, int dwParam)
{
/*RILCELLTOWERINFO rci = new RILCELLTOWERINFO();
Marshal.PtrToStructure(lpData, rci);
result = String.Format("MCC: {0}, MNC: {1}, LAC: {2}, CID: {3}",
rci.dwMobileCountryCode,
rci.dwMobileNetworkCode,
rci.dwLocationAreaCode,
rci.dwCellID);
done = true;*/
}
public static string GetCellTowerInfo()
{
IntPtr res;
RILRESULTCALLBACK result = new RILRESULTCALLBACK(f_result);
RILNOTIFYCALLBACK notify = new RILNOTIFYCALLBACK(f_notify);
res = RIL_Initialize(1, result, notify, (0x00010000 | 0x00020000 | 0x00080000), 0, out Form1.hRil);
if (res != IntPtr.Zero)
return ("Could not initialize Ril");
/*Form1.done = false;
Form1.result = "";
res = RIL_GetCellTowerInfo(hRil);
int i = 10;
while (i-- > 0 && !Form1.done)
{
System.Threading.Thread.Sleep(1000);
}
RIL_Deinitialize(hRil);*/
return Form1.result;
}
public Form1()
{
InitializeComponent();
string s = Form1.GetCellTowerInfo();
//MessageBox.Show(s);
}
private void button1_Click(object sender, EventArgs e)
{
RIL_Deinitialize(hRil);
Application.Exit();
}
}
}
at line 136 (Marshal.PtrToStructure(lpData, rilRemotePartyInfo) there is an exception (NotSupportedException) and i don't understand why!!!
Need some help please...........

[Q] an unexpected error has occurred in xxxxx.exe

hi guys i'm having this Error for a couple of days now, at first i thought it only happens with G alarm but i found out that it happens with spoon charge and toughXperiance too.
here is the error message:
an unexpected error has occurred in SpoonCharege.exe.
select quit and then restart this program, or select details for more information.
specified argument was out of the range of valid values.
when i select details:
SpoonCharge.exe
ArgumentOutOfRangeException
Specified argument was out of the range of valid values.
at System.DateTime.TimeToTicks(Int32 hour, Int32 minute, Int32 second)
at System.DateTime..ctor(Int32 year, Int32 month, Int32 day, Int32 hour, Int32 minute, Int32 second, Int32 millisecond, DateTimeKind kind)
at System.CurrentSystemTimeZone.GetDayOfWeek(Int32 year, Int32 month, Int32 targetDayOfWeek, Int32 numberOfSunday, Int32 hour, Int32 minute, Int32 second, Int32 millisecond)
at System.CurrentSystemTimeZone.GetDaylightChanges(Int32 year)
at System.CurrentSystemTimeZone.GetUtcOffsetFromUniversalTime(DateTime time, Boolean& isAmbiguousLocalDst)
at System.CurrentSystemTimeZone.ToLocalTime(DateTime time)
at System.DateTime.ToLocalTime()
at System.DateTime.get_Now()
at Microsoft.VisualBasic.DateAndTime.get_Now()
at SpoonCharge.MainForm.RefreshTime()
at SpoonCharge.MainForm.Form_Load()
at SpoonCharge.MainForm._Lambda$__1(Object a0, EventArgs a1)
at System.Windows.Forms.Form.OnLoad(EventArgs e)
at System.Windows.Forms.Form._SetVisibleNotify(Boolean fVis)
at System.Windows.Forms.Control.set_Visible(Boolean value)
at System.Windows.Forms.Application.Run(Form fm)
at SpoonCharge.MainForm.Main()
Any Ideas?!!
Thanx in advance