Результаты поиска

Я портирую игру, которая изначально была написана для Win32 API, на Linux (ну, портирую порт OS X порта Win32 на Linux).

Я реализовал QueryPerformanceCounter , дав uSeconds с момента запуска процесса:

BOOL QueryPerformanceCounter(LARGE_INTEGER* performanceCount)
{
    gettimeofday(&currentTimeVal, NULL);
    performanceCount->QuadPart = (currentTimeVal.tv_sec - startTimeVal.tv_sec);
    performanceCount->QuadPart *= (1000 * 1000);
    performanceCount->QuadPart += (currentTimeVal.tv_usec - startTimeVal.tv_usec);

    return true;
}

Это, в сочетании с QueryPerformanceFrequency() , дающим постоянную 1000000 в качестве частоты , хорошо работает на моей машине, давая мне 64-битную переменную, которая содержит uSeconds с момента запуска программы.

Так это портативное устройство? Я не хочу обнаружить, что он работает по-другому, если kernel был скомпилирован определенным образом или что-то подобное. Однако меня вполне устраивает, что он не переносится на что-то другое, кроме Linux.

ОК. Это немного тщеславное приложение, но сегодня у меня была ситуация на работе, когда я был в учебном классе, и машина была настроена на блокировку каждые 10 минут. Ну, если тренеры будут возбуждены разговором - в отличие от смены слайдов-машина будет заблокирована.

Я хотел бы написать маленькое приложение, у которого нет ничего, кроме значка на панели задач, который ничего не делает, кроме перемещения мыши на 1 пиксель каждые 4 минуты.

Я могу сделать это тремя способами с Delphi (мой сильный язык), но я переезжаю в C# для работы, и я хотел бы знать путь наименьшего сопротивления там.

Файл Windows exe имеет доступ к командной строке, которая его вызвала, включая путь и имя файла. напр.. C:\MyApp\MyApp.exe --help .

Но это не так для dll, вызванного через LoadLibrary . Кто-нибудь знает способ для dll узнать, каков его путь и имя файла?

В частности, меня интересует решение Delphi, но я подозреваю, что ответ будет практически одинаковым для любого языка.

Как вы создаете свой собственный псевдоним (или протокол URL) на системах Windows?

Образцы:

• http:
• mailto:
• обслуживание:

Есть ли смысл, имея все C#-managed-bliss,, вернуться к программированию Windows Петцольда и попытаться создать код w/ чисто WinAPI?

Чему можно из этого научиться? Не слишком ли она устарела, чтобы быть полезной?

Я ищу эквивалент Windows _wfopen() под Mac ОС X. В какие-нибудь идеи?

Мне это нужно для того, чтобы перенести библиотеку Windows, которая использует wchar* для своего файлового интерфейса. Поскольку это должна быть кроссплатформенная библиотека, я не могу полагаться на то, как клиентское приложение получит путь к файлу и передаст его библиотеке.

Я пытаюсь разобрать файл INI с помощью C++. Какие-нибудь советы о том, что является лучшим способом для достижения этой цели? Должен ли я использовать инструменты Windows API для обработки файлов INI (с которыми я совершенно незнаком), решение с открытым исходным кодом или попытаться проанализировать его вручную?

Я новичок в программировании windows и пытаюсь получать уведомления обо всех изменениях файловой системы (аналогично информации, которую отображает FileMon из SysInternals, но через API). Является ли FindFirstChangeNotification для каждого (не сетевого, не подстанционного) диска моим лучшим выбором или есть другие более подходящие C/C++ APIs?

У нас есть ситуация в нашем продукте, где в течение длительного времени некоторые данные хранились в базе данных приложения в виде строки SQL (выбор сервера MS SQL или sybase SQL в любом месте), которая была зашифрована с помощью функции Windows API CryptEncrypt. (прямой и де-криптографический)

Проблема в том, что CryptEncrypt может производить NULL в выходных данных, что означает, что когда он хранится в базе данных, строковые манипуляции в какой-то момент усекут CipherText.

В идеале мы хотели бы использовать algo, который будет производить CipherText, который не содержит NULLs, поскольку это вызовет наименьшее количество изменений в существующих базах данных (изменение столбца со строки на двоичный и код для работы с двоичным вместо строк) и просто расшифрует существующие данные и повторно зашифрует с помощью нового алгоритма во время обновления базы данных.

Алгоритм не должен быть самым безопасным, так как база данных уже находится в достаточно безопасной среде (а не в открытой сети / межсистемных сетях), но должен быть лучше, чем ROT13 (который я могу почти расшифровать в своей голове сейчас!)

edit: кстати, есть ли конкретная причина для изменения шифротекста на шифротекст? шифротекст кажется более широко используемым...

В приложении, над которым я сейчас работаю, требуется вывести на передний план окно внешнего приложения. Выполнение Win32 API вызовов, таких как BringWindowToTop и SetForeground window, не всегда работает. Это связано с некоторыми ограничениями в пределах Windows XP. Что я хотел бы сделать вместо этого, так это отправить имитацию щелчка мыши по кнопке окна на панели задач, которая, как я надеюсь, выведет окно на передний план. Кто-нибудь знает, как это возможно?

Можно ли получить UI текст из внешнего приложения в C#.

В частности, есть ли способ прочитать текст Unicode из метки (я предполагаю, что это обычный элемент управления Windows label) из внешнего приложения Win32, написанного третьей стороной? Текст виден, но не выбирается мышью в UI.

Я предполагаю, что существует некоторая доступность API (например, предназначенная для чтения с экрана), которая позволяет это сделать.

Edit: в настоящее время изучаю возможность использования чего-то вроде управляемого шпионского приложения , но все равно буду признателен за любые другие зацепки.

Я разрабатываю приложение, которое управляет машиной.
Когда я получаю ошибку от машины, пользователи должны быть в состоянии непосредственно заметить ее, один из способов, который выполняется, - это мигание лотка на панели задач. Когда устройство устранит ошибку, лоток перестанет мигать.

Есть одно небольшое раздражение с помощью функции FlashWindowEx, когда я очищаю мигание окна, оно остается (в моем случае winXP) оранжевым (не мигает).

    [Flags]
        public enum FlashMode {
            /// 
            /// Stop flashing. The system restores the window to its original state.
            /// 
            FLASHW_STOP = 0,
            /// 
            /// Flash the window caption.
            /// 
            FLASHW_CAPTION = 1,
            /// 
            /// Flash the taskbar button.
            /// 
            FLASHW_TRAY = 2,
            /// 
            /// Flash both the window caption and taskbar button.
            /// This is equivalent to setting the FLASHW_CAPTION | FLASHW_TRAY flags.
            /// 
            FLASHW_ALL = 3,
            /// 
            /// Flash continuously, until the FLASHW_STOP flag is set.
            /// 
            FLASHW_TIMER = 4,
            /// 
            /// Flash continuously until the window comes to the foreground.
            /// 
            FLASHW_TIMERNOFG = 12
        }

        public static bool FlashWindowEx(IntPtr hWnd, FlashMode fm) {
            FLASHWINFO fInfo = new FLASHWINFO();

            fInfo.cbSize = Convert.ToUInt32(Marshal.SizeOf(fInfo));
            fInfo.hwnd = hWnd;
            fInfo.dwFlags = (UInt32)fm;
            fInfo.uCount = UInt32.MaxValue;
            fInfo.dwTimeout = 0;

            return FlashWindowEx(ref fInfo);
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct FLASHWINFO {
            public UInt32 cbSize;
            public IntPtr hwnd;
            public UInt32 dwFlags;
            public UInt32 uCount;
            public UInt32 dwTimeout;
        }

В моем случае я использую FLASHW_TRAY, чтобы начать мигать и FLASHW_STOP, чтобы остановить мигание.

Я делаю что-то неправильно или это известная ошибка WinXP и есть ли исправление для нее?

В приложениях Windows, над которыми я работаю, у нас есть пользовательский фреймворк, который находится непосредственно над Win32 (не спрашивайте). Когда мы создаем окно, наша обычная практика заключается в том, чтобы поместить this в область пользовательских данных окна через SetWindowLong(hwnd, GWL_USERDATA, this) , что позволяет нам иметь MFC-подобный обратный вызов или плотно интегрированный WndProc, в зависимости от этого. Проблема в том, что это не будет работать на Win64, так как LONG имеет только 32-битную ширину. Как лучше решить эту проблему, которая работает как на 32 -, так и на 64-битных системах?

У меня есть библиотека, которая читает / записывает на устройство USB, используя CreateFile() API. Устройство реализует профиль HID-device, так что оно совместимо с драйвером класса Microsoft HID.

Некоторые другие приложения, установленные в системе, открывают устройство в режиме чтения / записи без режима общего доступа. Что мешает моей библиотеке (и всему, что ее потребляет) работать с устройством. Я полагаю, что это проблема с тем, чтобы быть HID-совместимым устройством - другое программное обеспечение драйвера (мыши, контроллеры, PHIDGETS и т. д.) Может быть несговорчивым.

В любом случае, путь к файлу устройства имеет вид:

1: "\\?\hid#hpqremhiddevice&col01#5&21ff20e7&0&0000#{4d1e55b2-f16f-11cf-88cb-001111000030}".

2: "\\?\hid#vid_045e&pid_0023#7&34aa9ece&0&0000#{4d1e55b2-f16f-11cf-88cb-001111000030}".

3: "\?\hid#vid_056a&pid_00b0&col01#6&5b05f29&0&0000#{4d1e55b2-f16f-11cf-88cb-001111000030}".

И я пытаюсь открыть его с помощью кода, например:

//  First, open it with minimum permissions, this device may not be ours.
//  we'll re-open it later in read/write
hid_device_ref = CreateFile(
    device_path, GENERIC_READ,
    0, NULL, OPEN_EXISTING,
    FILE_ATTRIBUTE_NORMAL, NULL);

Я рассматривал такой инструмент, как FileMon или Process Monitor от SysInternals. Но я не могу заставить его сообщать об использовании дескрипторов файлов устройств, подобных перечисленным выше.

В программе My C# есть список файлов, которые можно перетащить из нее в другую программу. Мои требования заключаются в том, чтобы сначала скопировать файл в другой каталог.

Итак, можно ли уведомить меня об операции удаления, чтобы я мог скопировать файл только в случае успеха операции? Я бы предпочел подождать, пока не узнаю, что его нужно скопировать, прежде чем выполнять копию.

Кроме того, можно ли узнать, в какой программе происходит операция сброса? В идеале я хотел бы изменить путь к файлу на основе того, кто или что его отбрасывает.

Решение этой проблемы может быть любым .NET язык или C/C++ с COM .

Я ищу метод или фрагмент кода для преобразования std::string в LPCWSTR

Фон: у меня есть небольшое приложение для воспроизведения видео с UI, вдохновленное почтенным Sasami2k, только что обновленное для использования VMR9 (т. е. Direct3D9 с DirectShow) и менее нестабильное. В настоящее время это приложение C++, использующее raw Win32, по необходимости: ни один из различных наборов инструментов не стоит ни гроша. WPF, в частности, было невозможно из-за ограничений его воздушного пространства.

OK, так что теперь, когда существует D3DImage, вполне возможно смешать и сопоставить D3D/VMR9/DirectShow и WPF. Учитывая прошлые разочарования в неразрешимости Win32, это кажется хорошей вещью.

Но знаешь, я падаю на первом же препятствии здесь.

С помощью Win32 я создал (очень легко) окно без границ, которое можно изменять, изменять размер пропорционально, привязывать к краям экрана и занимать весь экран (включая область панели задач) при максимальном увеличении. Это видео-приложение, так что все это довольно желательные свойства.

OK, так как же сделать то же самое с WPF?

В Win32 я использую: WM_GETMINMAXINFO для управления максимизацией поведения WM_NCHITTEST для управления изменением размера границ WM_MOVING для управления snap-to-screen-edges WM_SIZING для управления соотношением сторон изменения размера

Однако, глядя на WPF, кажется, что различные события прибывают слишком поздно, если я не ошибаюсь в документации?

Например, я не знаю, когда я нахожусь в середине движения, так как LocationChanged говорит, что он срабатывает только после перемещения окна (что слишком поздно). Аналогично, похоже, что StateChanged срабатывает только после восстановления/максимизации окна (когда мне нужна информация до максимизации, чтобы сообщить системе правильный максимальный размер).

И я, кажется, совершенно упускаю из виду, где система говорит мне о размерах. Точно так же и хит-тестирование.

Итак, эм, я что-то упускаю здесь, или у меня нет другого выбора, кроме как вернуться к подключению wndproc этой штуки в любом случае? Могу ли я делать то, что хочу, не подключая WndProc?

Если мне придется использовать WndProc, я могу также придерживаться своей существующей кодовой базы; я хочу иметь более простой и чистый код UI, и уход от WndProc является фундаментальным для этого.

Если мне действительно нужно зацепить WndProc, я должен задаться вопросом - почему ? Win32 получил сообщения окна sizing/sized, moving/moved, poschanging/poschanged, и все они полезны. Почему бы WPF не повторить тот же набор событий? Это выглядит как ненужный пробел в функциональности.

Кроме того, это означает, что WPF привязан к конкретной реализации, зависящей от USER32. Это означает, что MS не может (скажем, в Windows 7 или 8) инвертировать слой отображения, чтобы сделать WPF "native" и эмулировать HWNDs и WndProcs для устаревших приложений-даже если это именно то, что должен делать MS.