Что такое hook в программировании

Что такое хук (hook) и как он влияет на остатки товаров?

Так как мы говорим о программировании, а не о боксе, хук — это своеобразный тип расширений, которые выполняются вместе с определенным событием в системе. Если взять дословный перевод, то это ловушка для программы.

Чтобы стало понятнее, разберем небольшой пример. Большинство магазинов, которые продают физический товар, должны учитывать остаток этого товара, чтобы случайно не продать «воздух». Сложность в том, что списать товар мы можем как в момент покупки (оплаты), создания заказа (допустим, товар бронируется) или на изменение определенного статуса заказа. В итоге у каждого магазина это происходит по-своему.

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

На самом деле под хуком можно подразумевать все что угодно, например, изменение группы пользователя, статуса или свойства материала, суммы заказа и пр. Основной смысл в том, что мы можем привязывать несколько независимых хуков и гибко манипулировать поведением корзины без каких-либо хаков (модификаций кода компонента).

Хуки и события в корзине JBZoo

Так как в корзине все «элементарно» и по позициям, то любое событие представляет из себя позицию, а хук — элемент в этой позиции. В зависимости от события элементу будет доступна разная информация о системе и зоны ответственности. Поэтому важно понимать, что делает хук и в какое событие его положить. Иначе можно легко добиться абсурдных ситуаций, когда остаток на складе списывается при удалении товара из корзины.

Сейчас хуками можно управлять на двух страницах в панели управления — События и уведомления и События смены статусов. Например, если вы поставите элемент для остатка в событие Успешная оплата, то остаток на складе уменьшится именно в момент оплаты (оповестит платежный робот). Или вы можете использовать позицию статуса успешной оплаты, то хук будет срабатывать как для платежного робота (потому что он изменяет статус), так и вручную от администратора.

По своей сути элементы нотификации, скидки и валидаторы — это тоже хуки, только они имеют узкую специализацию и срабатывают на одно или несколько определенных событий. Мы их выделили в особые группы лишь для простоты настройки.

Рекомендуем прочитать

• Способы оплаты
• Настройка формы заказа в JBZoo (Видео)
• Кастомизация шаблонов JBZoo на примере демо-сайта (часть 1)
• Кастомизация шаблонов JBZoo на примере демо-сайта (часть 2)
• Рецепт: как сделать скидку 10% при стоимости заказа от 2000 руб.?

Краткий обзор хуков

Хуки — нововведение в React 16.8, которое позволяет использовать состояние и другие возможности React без написания классов.

Хуки — обратно совместимы. На этой странице вы получите общее представление о хуках. Имейте в виду, что это беглый обзор, который больше подойдёт опытным пользователям React. В конце каждого раздела есть вот такой жёлтый блок с детальным объяснением на случай, если вы запутались:

Подробное объяснение

Если вы хотите понять, почему мы добавляем хуки в React, прочтите мотивацию.

Рассмотрим пример, в котором рендерится счётчик. Если вы нажмёте на кнопку, значение счётчика будет инкрементировано.

import React,  useState > from 'react'; function Example()   // Объявляем новую переменную состояния "count" const [count, setCount] = useState(0); return ( div> p>Вы нажали count> разp> button onClick=() => setCount(count + 1)>> Нажми на меня button> div> ); >

В этом примере, useState — это хук (определение хука дано ниже). Мы вызываем его, чтобы наделить наш функциональный компонент внутренним состоянием. React будет хранить это состояние между рендерами. Вызов useState возвращает массив с двумя элементами, который содержит: текущее значение состояния и функцию для его обновления. Эту функцию можно использовать где угодно, например, в обработчике событий. Она схожа с this.setState в классах, но не сливает новое и старое состояние вместе. Сравнение хука useState и this.state приводится на странице Использование хука состояния.

Единственный аргумент useState — это начальное состояние. В примере выше — это 0 , так как наш счётчик начинается с нуля. Заметьте, что в отличие от this.state , в нашем случае состояние может, но не обязано, быть объектом. Исходное значение аргумента используется только при первом рендере.

Объявление нескольких переменных состояния

Хук состояния можно использовать в компоненте более одного раза.

function ExampleWithManyStates()  // Объявляем несколько переменных состояния! const [age, setAge] = useState(42); const [fruit, setFruit] = useState('банан'); const [todos, setTodos] = useState([ text: 'Изучить хуки' >]); // . >

Синтаксис деструктуризации массивов позволяет нам по-разному называть переменные состояния, которые мы объявляем при вызове useState . Так как имён этих переменных нет в API useState , React предполагает, что если вы вызываете useState много раз, вы делаете это в одинаковой последовательности при каждом рендере. Мы расскажем, почему это работает и когда это целесообразно, немного позже.

Что же такое хук?

Хуки — это функции, с помощью которых вы можете «подцепиться» к состоянию и методам жизненного цикла React из функциональных компонентов. Хуки не работают внутри классов — они дают вам возможность использовать React без классов. (Мы не рекомендуем сразу же переписывать существующие компоненты, но при желании, вы можете начать использовать хуки в своих новых компонентах.)

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

Вам скорее всего доводилось ранее запрашивать данные, делать подписки или вручную менять DOM из React-компонента. Мы расцениваем эти операции как «побочные эффекты» (или сокращённо «эффекты»), так как они могут влиять на работу других компонентов и их нельзя выполнить во время рендера.

С помощью хука эффекта useEffect вы можете выполнять побочные эффекты из функционального компонента. Он выполняет ту же роль, что и componentDidMount , componentDidUpdate и componentWillUnmount в React-классах, объединив их в единый API. Вы можете найти сравнение useEffect и этих методов на странице использование хука эффекта.

К примеру, этот компонент устанавливает заголовок документа после того, как React обновляет DOM:

import React,  useState, useEffect > from 'react'; function Example()  const [count, setCount] = useState(0); // По принципу componentDidMount и componentDidUpdate: useEffect(() =>  // Обновляем заголовок документа, используя API браузера document.title = `Вы нажали $count> раз`; >); return ( div> p>Вы нажали count> разp> button onClick=() => setCount(count + 1)>> Нажми на меня button> div> ); >

Когда вы вызываете useEffect , React получает указание запустить вашу функцию с «эффектом» после того, как он отправил изменения в DOM. Поскольку эффекты объявляются внутри компонента, у них есть доступ к его пропсам и состоянию. По умолчанию, React запускает эффекты после каждого рендера, включая первый рендер. Мы рассмотрим более подробно, как это отличается от классовых методов жизненного цикла на странице использование хука эффекта.

При необходимости вы можете вернуть из эффекта функцию, которая указывает эффекту, как выполнить за собой «сброс». Например, этот компонент использует эффект, чтобы подписаться на статус друга в сети, и выполняет сброс, отписываясь от него.

import React,  useState, useEffect > from 'react'; function FriendStatus(props)  const [isOnline, setIsOnline] = useState(null); function handleStatusChange(status)  setIsOnline(status.isOnline); > useEffect(() =>  ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange); return () =>  ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange); >; >); if (isOnline === null)  return 'Загрузка. '; > return isOnline ? 'В сети' : 'Не в сети'; >

В этом примере, React будет отписываться от нашего ChatAPI перед тем, как компонент размонтируется и перед тем, как перезапустить эффект при повторном рендере. Вы можете сделать так, чтобы React пропускал повторные подписки если props.friend.id , который мы передали в ChatAPI , остался без изменений.

Так же как и useState , вы можете использовать более одного эффекта в компоненте:

function FriendStatusWithCounter(props)  const [count, setCount] = useState(0); useEffect(() =>  document.title = `Вы нажали $count> раз`; >); const [isOnline, setIsOnline] = useState(null); useEffect(() =>  ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange); return () =>  ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange); >; >); function handleStatusChange(status)  setIsOnline(status.isOnline); > // . 

Хуки дают вам возможность организовать побочные эффекты в компоненте по связанным частям (например, добавление или отмена подписки), вместо того, чтобы принуждать вас делить всё согласно методам жизненного цикла.

Подробное объяснение

Вы можете узнать больше о useEffect на странице Использование хука эффекта.

✌️ Правила хуков

Хуки — это функции JavaScript, которые налагают два дополнительных правила:

• Хуки следует вызывать только на верхнем уровне. Не вызывайте хуки внутри циклов, условий или вложенных функций.
• Хуки следует вызывать только из функциональных компонентов React. Не вызывайте хуки из обычных JavaScript-функций. Есть только одно исключение, откуда можно вызывать хуки — это ваши пользовательские хуки. Мы расскажем о них далее.

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

Подробное объяснение

Вы можете узнать больше на странице Правила хуков.

�� Создание собственных хуков

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

Ранее на этой странице мы рассматривали компонент FriendStatus , который вызывал хуки useState и useEffect , чтобы подписаться на статус друга в сети. Допустим, мы хотим ещё раз использовать эту логику с подпиской, но уже в другом компоненте.

Прежде всего, давайте извлечём эту логику в пользовательский хук useFriendStatus

import React,  useState, useEffect > from 'react'; function useFriendStatus(friendID)  const [isOnline, setIsOnline] = useState(null); function handleStatusChange(status)  setIsOnline(status.isOnline); > useEffect(() =>  ChatAPI.subscribeToFriendStatus(friendID, handleStatusChange); return () =>  ChatAPI.unsubscribeFromFriendStatus(friendID, handleStatusChange); >; >); return isOnline; >

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

Теперь мы можем использовать этот хук в обоих наших компонентах:

function FriendStatus(props)   const isOnline = useFriendStatus(props.friend.id); if (isOnline === null)  return 'Загрузка. '; > return isOnline ? 'В сети' : 'Не в сети'; >

function FriendListItem(props)   const isOnline = useFriendStatus(props.friend.id); return ( li style= color: isOnline ? 'green' : 'black' >>> props.friend.name> li> ); >

Состояния каждого компонента никаким образом не зависят друг от друга. Хуки — это способ использовать повторно логику состояния, а не само состояние. Более того, каждое обращение к хуку обеспечивает совершенно изолированное состояние. Вы даже можете использовать один и тот же хук несколько раз в одном компоненте.

Пользовательские хуки — это в большей степени соглашение, чем дополнение. Если имя функции начинается с ” use ” и она вызывает другие хуки, мы расцениваем это как пользовательский хук. Если вы будете придерживаться соглашения useSomething при именовании хуков, это позволит нашему плагину для линтера найти баги в коде, который использует хуки.

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

Есть ещё несколько менее используемых встроенных хуков, которые могут вам пригодиться. Например, с помощью useContext , вы можете подписаться на контекст React без использования каких-либо вложений.

function Example()   const locale = useContext(LocaleContext); const theme = useContext(ThemeContext); // . >

А хук useReducer даёт возможность управлять внутренним состоянием более сложного компонента с помощью редюсера.

function Todos()   const [todos, dispatch] = useReducer(todosReducer); // . 

Подробное объяснение

Вы можете узнать больше обо всех встроенных хуках на странице API-справочника хуков.

Фух, давайте перестанем торопиться и немного охладим пыл! Если вам что-то непонятно или вы хотите узнать о чём-либо более подробно, вы можете начать читать следующие страницы, начиная с документации хука состояния.

Вы также можете просмотреть API-справочник хуков и FAQ хуков.

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

Что такое хуки и как их использовать: краткий гайд с примерами

Хуки — это технология, которая перехватывает вызовы функций и помогает использовать возможности React без написания классов.

Цифровий курс від robotdreams: DevOps Engineer.
підходи для створення сучасних і масштабованих застосунків.

С помощью хуков можно написать краткий, лаконичный и более понятный код. И это главное их преимущество. Их использование позволяет изменять любую из функций без необходимости переписывать код целиком. Можно сказать, что хук способен как бы «перезагрузить» функцию.

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

Встроенные хуки

Хуки можно создавать самостоятельно, но в React существует ряд встроенных хуков, которыми можно пользоваться прямо сейчас.

useState()

Хук состояния — useState() — добавляет динамическую логику функциональных компонентов:

Інноваційний курс від robotdreams: Android Developer.
Творіть для мобільного світу.

const [state, setState] = useState(initialState);

Хук возвращает функцию и значение состояния для обновления.

Пример. Рендеринг счетчика. При нажатии на кнопку его значение увеличится:

import React, < useState >from 'react'; function Example() < // Объявляем новую переменную состояния "count" const [count, setCount] = useState(0); return ( 
Вы нажали раз
 setCount(count + 1)>> Нажми на меня 
 ); >

Функциональный компонент наделяется внутренним состоянием, которое будет сохраняться между рендерами.

useCallback()

Хук useCallback() оптимизирует рендеринг компонентов:

const memoizedCallback = useCallback( () => < doSomething(a, b); >, [a, b], );

А также возвращает мемоизированную версию Callback (когда результат выполнения сохраняется). При этом массив зависимостей не передается.

useContext()

Хук useContext() передает данные дочерним элементам:

const value = useContext(MyContext);

А также возвращает текущее значение контекста.

useMemo()

Хук useMemo() позволяет запоминать функции без необходимости их вызова при каждом новом рендеринге:

const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);

А еще — возвращает мемоизированное значение.

Ефективний курс від laba: Фінансовий менеджер.
Оптимізуйте фінансовий розвиток компанії.

Функция, которая передается хуком useMemo , запускается при рендере.

useEffect()

Хук эффекта — useEffect() — выполняет в компонентах функций такие эффекты как вызов API, запросов и подобные:

useEffect(didUpdate);

Функция, которую передает useEffect() , запускается только после фиксации рендера на экране.

Пример. Установка компонентом заголовка документа после обновления DOM:

import React, < useState, useEffect >from 'react'; function Example() < const [count, setCount] = useState(0); // По принципу componentDidMount и componentDidUpdate: useEffect(() => < // Обновляем заголовок документа, используя API браузера document.title = `Вы нажали $раз`; >); return ( 
Вы нажали раз
 setCount(count + 1)>> Нажми на меня 
 ); >

React запускает функции с эффектами после каждого рендера.

useReduce()

Хук useReduce() — альтернатива хуку useState() , но используется для сложной логики состояния, управляет внутренним состоянием более сложного компонента:

function Todos() < const [todos, dispatch] = useReducer(todosReducer); // .

useRef()

Хук useRef() создает изменяемую переменную (упрощает доступ к элементам React и узлам DOM):

const refContainer = useRef(initialValue);

Хук возвращает ref-объект, который будет сохраняться в течение времени жизни самого компонента.

Пример. Доступ к потомку:

function TextInputWithFocusButton() < const inputEl = useRef(null); const onButtonClick = () =>< // `current` указывает на смонтированный элемент `input` inputEl.current.focus(); >; return ( <> type="text" /> >Установить фокус на поле ввода ); >

Хук useRef() содержит изменяемое значение .current . При каждом рендере хук useRef() дает один и тот же объект с ref .

Ефективний курс від mate.academy: Frontend.
Розблокуйте світ веб-розробки.

useImperativeHandle()

Хук useImperativeHandle() настраивает объект при использовании ref , передающийся родительскому компоненту.

Пример. Использование useImperativeHandle с forwardRef:

function FancyInput(props, ref) < const inputRef = useRef(); useImperativeHandle(ref, () =>( < focus: () => < inputRef.current.focus(); >>)); return . />; > FancyInput = forwardRef(FancyInput)

Хук useImperativeHandle() контролирует возвращаемое значение. Довольно часто этот хук используют в библиотеках компонентов, где нужна кастомизация поведения элементов DOM.

useDebugValue()

Хук useDebugValue() отображает значение для отладки.

Пример. Создание своего React-хука:

import React, from 'react' function useRandomNumber(min, max) < const [number, setNumber] = useState(null); useEffect(() =>< const range = Math.random() * (max - min) + min setNumber(Math.floor(range)) >, []) useDebugValue(number > 50 ? 'Number more the 50' : 'Number less then 50'); return number; > const UseDebugValuePage = () => < const number = useRandomNumber(1, 100) return ( 
useDebugValue
 
Random number:
 ) > export default UseDebugValuePage

Хук useDebugValue() будет вызван тогда, когда будет открыт React DevTools.

useLayoutEffect()

Хук useLayoutEffect() — альтернатива хука useEffect() , но вызывается в DOM после изменений в структуре:

import React, from 'react' const UseLayoutEffectPage = () => < const ref = React.useRef() useEffect(() =>< ref.current.value = 'New value' console.log('useEffect'); >) useLayoutEffect(() => < console.log(ref.current.value) >) return ( 
useLayoutEffect
 value='Old value' />
 ) > export default UseLayoutEffectPage

Хук useLayoutEffect() запускается в React только после фиксации в DOM всех обновлений.

Правила хуков

Хуки — это тоже функции JavaScript , но чтобы их правильно использовать, нужно следовать кое-каким правилам:

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

Как создать хуки?

Пусть в компоненте, принадлежащем чату (приложению), отображается уведомление о нахождении пользователя «В сети»:

import React, < useState, useEffect >from 'react'; function FriendStatus(props) < const [isOnline, setIsOnline] = useState(null); useEffect(() => < function handleStatusChange(status) < setIsOnline(status.isOnline); >ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange); return () => < ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange); >; >); if (isOnline === null) < return 'Загрузка. '; >return isOnline ? 'В сети' : 'Не в сети'; >

Давайте сделаем имена пользователей из списка контактов, которые находятся онлайн, зелеными.

Чтобы решить эту задачу, в компонент FriendListItem можно скопировать логику, которая приведена выше:

import React, < useState, useEffect >from 'react'; function FriendListItem(props) < const [isOnline, setIsOnline] = useState(null); useEffect(() => < function handleStatusChange(status) < setIsOnline(status.isOnline); >ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange); return () => < ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange); >; >); return ( >> ); >

Конечно, этот способ совсем не простой и короткий.

Поделимся логикой с FriendStatus и FriendListItem . В React существует два способа разделения логики:

• render props;
• компоненты высшего порядка.

Но использование хуков избавляет от добавления дополнительных функций в дерево компонентов.

Разделить логику между двумя функциями JavaScript можно, если извлечь ее в еще одну, третью функцию.

Первый пользовательский хук — useFriendStatus() :

import < useState, useEffect >from 'react'; function useFriendStatus(friendID) < const [isOnline, setIsOnline] = useState(null); useEffect(() => < function handleStatusChange(status) < setIsOnline(status.isOnline); >ChatAPI.subscribeToFriendStatus(friendID, handleStatusChange); return () => < ChatAPI.unsubscribeFromFriendStatus(friendID, handleStatusChange); >; >); return isOnline; >

Этот хук подписывает нас на статус пользователя. friendID является здесь аргументом:

function useFriendStatus(friendID) < const [isOnline, setIsOnline] = useState(null); // . return isOnline; >

Наша изначальная цель — удалить повторяющуюся логику из FriendStatus и FriendListItem .

Когда логика извлечена из useFriendStatus , можно ее использовать:

function FriendStatus(props) < const isOnline = useFriendStatus(props.friend.id); if (isOnline === null) < return 'Loading. '; >return isOnline ? 'Online' : 'Offline'; > function FriendListItem(props) < const isOnline = useFriendStatus(props.friend.id); return ( >> ); >

Что здесь произошло? Мы извлекли код из двух функций и поместили в отдельную функцию.

Важно! Используйте use в начале каждого хука. Это нужно для автоматической проверки правил хуков.

Хуки, используемые в двух компонентах, не имеют одинакового состояния. Каждый вызов хука изолирован.

Как мы уже говорили, хуки — это те же функции. А потому можно передавать информацию между ними.

Давайте рассмотрим пример использования компонента, демонстрирующего, находится ли пользователь сейчас онлайн:

const friendList = [ < id: 1, name: 'Ольга' >, < id: 2, name: 'Жанна' >, < id: 3, name: 'Елизавета' >, ]; function ChatRecipientPicker() < const [recipientID, setRecipientID] = useState(1); const isRecipientOnline = useFriendStatus(recipientID); return ( <> /> onChange= setRecipientID(Number(e.target.value))> > ( value=> ))> ); >

Идентификатор пользователя сохраняется в recipientID и обновляется в случае выбора в другого пользователя.

Хук useState() возвращает значение recipientID , а значит его можно передать в useFriendStatus в качестве аргумента:

const [recipientID, setRecipientID] = useState(1); const isRecipientOnline = useFriendStatus(recipientID);

Так можно узнать, находится ли пользователь в сети.

Пользовательские хуки гибкие, их можно использовать в связке друг с другом.

Ограничения при использовании хуков

При использовании хуков существуют свои ограничения. Их нельзя использовать в классах, внутри условий, вложенных функций и циклов. Именно ограничения отличают хуки от простых функций. Хуки созданы для функциональных компонентов, их можно использовать на первом уровне вложенности. Эти ограничения существуют в самом React во избежание трудно отлаживаемых ошибок, благодаря этому есть возможность определять, какие хуки вызываются, и отслеживать их.

Например, в одном компоненте можно использовать сразу несколько хуков эффектов или состояний:

function Form() < // 1. Use the name state variable const [name, setName] = useState('Mary'); // 2. Use an effect for persisting the form useEffect(function persistForm() < localStorage.setItem('formData', name); >); // 3. Use the surname state variable const [surname, setSurname] = useState('Poppins'); // 4. Use an effect for updating the title useEffect(function updateTitle() < document.title = name + ' ' + surname; >); // . >

React определяет порядок, при котором вызываются хуки. Именно так он узнает, какому useState() какое состояние соответствует. Поскольку в примере порядок вызовов одинаков при каждом рендере, он является рабочим:

// ------------ // First render // ------------ useState('Mary') // 1. Initialize the name state variable with 'Mary' useEffect(persistForm) // 2. Add an effect for persisting the form useState('Poppins') // 3. Initialize the surname state variable with 'Poppins' useEffect(updateTitle) // 4. Add an effect for updating the title // ------------- // Second render // ------------- useState('Mary') // 1. Read the name state variable (argument is ignored) useEffect(persistForm) // 2. Replace the effect for persisting the form useState('Poppins') // 3. Read the surname state variable (argument is ignored) useEffect(updateTitle) // 4. Replace the effect for updating the title // .

Но что получится, если поместить хук в условие?

// �� We're breaking the first rule by using a Hook in a condition if (name !== '') < useEffect(function persistForm() < localStorage.setItem('formData', name); >); >

Условие (name !== '') имеет статус true для первого рендера. Запускаем хук. Но при следующем рендеринге пользователь может очистить форму, и тогда условие будет false. Порядок вызовов хука изменен:

useState('Mary') // 1. Read the name state variable (argument is ignored) // useEffect(persistForm) // �� This Hook was skipped! useState('Poppins') // �� 2 (but was 3). Fail to read the surname state variable useEffect(updateTitle) // �� 3 (but was 4). Fail to replace the effect

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

Компоненты чаще всего определяются как обычные функции:

function ClickButtonHook(props) < const [count, setCount] = React.useState(0); const press= () =>setCount(count + props.increment); return 
>Count 
Counter:  
Increment:
 ; >

Также они могут определяться в виде стрелочных функций:

const ClickButtonHook = (props)=> < const [count, setCount] = React.useState(0); const press= () =>setCount(count + props.increment); return 
>Count 
Counter:  
Increment:
 ; >

Как подключать хуки

При условии, если компоненты расположены в отдельных файлах, встроенные хуки можно подключить, используя такой способ:

import React, < useState >from "react"; function ClickButtonHook(props) < const [count, setCount] = React.useState(0); const press= () =>setCount(count + props.increment); return 
>Count 
Counter:  
Increment:
 ; >

Заключение

В сравнении с классами, у хуков есть ряд своих преимуществ. Упрощается логика жизненного цикла, появляются возможности гибкой оптимизации (мемоизация), нет необходимости сохранять имена методов и работать с прототипами.

Кастомные хуки позволяют быстрее и легче шейрить логику (она сразу закладывается в хуки). Это ведет к уменьшению вложенности дерева компонентов. React получает возможность пристальнее отслеживать изменения в компонентах.

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

Без них такая логика при наличии нескольких побочных эффектов в компоненте разбивалась бы на разные методы жизненного цикла. А благодаря мемоизации компоненты не будут обновлены или пересозданы. В memo можно поместить все функциональные компоненты.

Но наравне с широкими возможностями хуки имеют и ограничения. Стоит хорошо разобраться в том, как они работают, особенно понять, что такое мемоизация. Только тогда можно научиться писать читабельный и лаконичных код с использованием хуков.

Win32 API. Hooks (хуки)

Hook - это некоторая точка в Microsoft Windows механизме обработки сообщений, где приложение может подключить подпрограмму для наблюдения за потоком сообщений в системе и обработки сообщений некоторых типов до того, как они попадут в целевую оконную процедуру. Этот краткий обзор описывает Windows hook-точки и объясняет, как использовать их в базирующейся на Win32 прикладной программе.

О Hook-точках

Hook-точки имеют тенденцию замедлять систему, потому что они увеличивают суммарное время обработки, за которое система должна выполнить ее для каждого сообщения. Вы должны устанавливать hook-точку, только тогда, когда это необходимо и удалять ее как можно скорее.

Цепочки hook-точек

Windows содержит много различных типов hook-точек; каждый тип предоставляет доступ к различным видам Windows - механизма обработки сообщений. Например, прикладная программа может использовать hook-точку WH_MOUSE, чтобы отслеживать в потоке обмена сообщениями сообщения для мыши.

Windows поддерживает отдельную цепочку hook-точек для каждого типа hook-точки. Цепочка hook-точек (hook chain) - список указателей на специальные, определяемые программой функции повторного вызова называемые подключаемыми процедурами (hook procedure). Когда попадается сообщение, который связано со специфическим типом hook-точки, Windows передает это сообщение в каждую подключаемую процедуру, вызываемую одну за другой в цепочке hook-точек. Действие, которое может выбрать подключаемая процедура, зависит от типа включенной hook-точки. Подключаемые процедуры для некоторых типов hook-точек могут только отслеживать сообщения; другие могут изменять сообщения или останавливать их продвижение по цепочке, не давая достигать им следующей подключаемой процедуры или окна назначения.

Подключаемые процедуры (Hook procedures)

Чтобы воспользоваться преимуществом специфического типа hook-точки, разработчик предоставляет подключаемую процедуру и использует функцию SetWindowsHookEx, чтобы установить ее в цепочку, связанную с hook-точкой. Подключаемая процедура должна иметь следующий синтаксис:

LRESULT CALLBACK HookProc
( 
int nCode, 
WPARAM wParam, 
LPARAM lParam
)

HookProc - метка - заместитель для определяемого программой названия процедуры.

Параметр nCode - код hook-точки, который подключаемая процедура использует, чтобы определить действие на исполнение. Значение кода hook-точки зависит от ее типа; каждый тип имеет свой собственный характерный набор кодов hook-точки. Значения параметров wParam и lParam зависят от кода hook-точки, но они обычно содержат информацию о сообщении, которое было отправлено или передано.

Функция SetWindowsHookEx всегда устанавливает подключаемую процедуру в начале цепочки hook-точек. Когда происходит событие, которое контролируется нестандартным типом hook-точки, Windows вызывает процедуру в начале цепочки hook-точек, связанную с hook-точкой. Каждая фильтр - процедура в цепочке решает, передать ли событие в следующую процедуру. Подключаемая процедура передает событие в следующую процедуру, путем вызова функции CallNextHookEx.

Обратите внимание !, что подключаемые процедуры для некоторых типов hook-точек могут только отслеживать сообщения. Windows передает сообщения в каждую фильтр - процедуру, независимо от того, есть или нет нестандартные вызовы процедуры CallNextHookEx.

Подключаемая процедура может быть глобальной, контролируя сообщения для всех потоков в системе, или она может быть для конкретного потока, контролируя сообщения только для отдельного потока. Глобальная фильтр - процедура может быть вызвана применительно к любой прикладной программе, так что процедура должна быть в отдельном модуле динамически подключаемой библиотеки (DLL). Конкретный поток вызывает подключаемую процедуру только применительно к связанному потоку. Если прикладная программа устанавливает фильтр - процедуру для одного из своих собственных потоков, подключаемая процедура может быть или в том же самом модуле, как остальная часть кода приложения, или в динамически подключаемой библиотеке (DLL). Если прикладная программа устанавливает фильтр - процедуру для потока другой прикладной программы, процедура должна быть в динамически подключаемой библиотеке (DLL). За большей информацией обратитесь к статье. Библиотеки Динамической связи.

Примечание: Глобальные hook-точки Вы должны использовать только для целей отладки программы; но так или иначе, Вы должны избегать их. Глобальные hook-точки наносят ущерб поведению системы и являются причиной конфликтов с другими прикладными программами, которые используют тот же самый тип глобальной hook-точки.

Типы hook-точек

Каждый тип hook-точки дает возможность прикладной программе контролировать различные аспекты механизма обработки сообщений Windows. Следующие разделы описывают типы hook-точек, доступных в Windows.

Hook-точки WH_CALLWNDPROC и WH_CALLWNDPROCRET

Hook-точки WH_CALLWNDPROC и WH_CALLWNDPROCRET дают Вам возможность контролировать сообщения, отправленные оконным процедурам функцией SendMessage. Windows вызывает подключаемую процедуру WH_CALLWNDPROC перед передачей сообщения в принимающую оконную процедуру, а после того, как оконная процедура обработала сообщение, вызывает подключаемую процедуру WH_CALLWNDPROCRET.

Hook-точка WH_CALLWNDPROCRET передает адрес структуры CWPRETSTRUCT в подключаемую процедуру. Структура содержит возвращаемое значение из оконной процедуры, которая обработала сообщение, а также параметры сообщения, связанные с ним. Деление на подклассы окон не работает для сообщений, установленных между процессами.

Для получения дополнительной информации, см. функции CallWndProc и CallWndRetProc.

Hook-точка WH_CBT

Windows вызывает подключаемую процедуру WH_CBT перед активизацией, созданием, разрушением, уменьшением, максимизированием, перемещением, или установкой размеров окна; перед завершением системной команды; перед удалением события мыши или клавиатуры из системной очереди сообщений; перед установкой фокуса ввода; или перед синхронизацией системной очереди сообщений. Значение, возвращаемое подключаемой процедурой, определяет, позволяет ли Windows или не допускает одно из этих действий. Hook-точка WH_CBT предназначена прежде всего для основной компьютерной подготовки (CBT) прикладной программы.

Для получения дополнительной информации, см. функцию CBTProc.

Hook-точка WH_DEBUG

Windows вызывает подключаемую процедуру WH_DEBUG перед вызванными подключаемыми процедурами, связанными с любой другой hook-точкой в системе. Вы можете использовать эту hook-точку, чтобы определить, позволено ли системе вызывать подключаемые процедуры, связанные с другими типами hook-точек.

Для получения дополнительной информации, см. функцию DebugProc.

Hook-точка WH_FOREGROUNDIDLE

Hook-точка WH_FOREGROUNDIDLE позволяет вам выполнять низкоприоритетные задачи в тот период, когда приоритетный поток не используется.

Windows вызывает подключаемую процедуру WH_FOREGROUNDIDLE тогда, когда приоритетный поток прикладной программы собирается стать неактивным.

За большей информацией обратитесь к статье Функция ForegroundIdleProc.

Hook-точка WH_GETMESSAGE

Hook-точка WH_GETMESSAGE дает возможность прикладной программе контролировать сообщения, которые функция GetMessage или PeekMessage намереваются возвратить. Вы можете использовать hook-точку WH_GETMESSAGE, чтобы контролировать вводимые данные от мыши и клавиатуры и другие сообщения, зарегистрированные в очереди сообщений.

Для получения дополнительной информации, см. статью Функция GetMsgProc.

Hook-точка WH_JOURNALPLAYBACK

Hook-точка WH_JOURNALPLAYBACK дает возможность прикладной программе вставлять сообщения в системную очередь сообщений. Вы можете использовать эту hook-точку, чтобы воспроизвести ряд событий от мыши и клавиатуры, занесенных в список ранее при помощи использования hook-точки WH_JOURNALRECORD. Нормальный ввод данных от мыши и клавиатуры блокируется то тех пор, пока установлена hook-точка WH_JOURNALPLAYBACK. Hook-точка WH_JOURNALPLAYBACK является глобальной hook-точкой , то есть не может быть использована как hook-точка, определяемая потоком.

Hook-точка WH_JOURNALPLAYBACK возвращает значение блокировки времени. Это значение сообщает системе, сколько миллисекунд необходимо ждать перед обработкой текущего сообщения от hook-точки воспроизведения. Это дает возможность hook-точке управлять величиной времени воспроизводимых событий.

Для получения дополнительной информации, см. статью Функция JournalPlaybackProc.

Hook-точка WH_JOURNALRECORD

Hook-точка WH_JOURNALRECORD дает Вам возможность контролировать и занести в список входящие события. Как правило, Вы используете эту hook-точку, чтобы записать в список последовательности событий от мыши и клавиатуры, чтобы воспроизвести их позже, используя hook-точку WH_JOURNALPLAYBACK. Hook-точка WH_JOURNALRECORD - глобальная hook-точка, это означает, что она не может быть использована как hook-точка, определяемая потоком.

Для получения дополнительной информации, см. статью Функция JournalRecordProc.

Hook-точка WH_KEYBOARD

Hook-точка WH_KEYBOARD дает возможность прикладной программе контролировать поток сообщений для сообщений WM_KEYDOWN и WM_KEYUP, которые функция GetMessage или PeekMessage намеревается возвратить. Вы можете использовать hook-точку WH_KEYBOARD, чтобы контролировать ввод с клавиатуры, переданный в очередь сообщений.

Для получения дополнительной информации, см. статью о функции KeyboardProc.

Hook-точка WH_MOUSE

Hook-точка WH_MOUSE дает возможность Вам контролировать сообщения мыши, которые функция GetMessage или PeekMessage намеревается возвратить. Вы можете использовать hook-точку WH_MOUSE, чтобы контролировать ввод мыши, переданный в очередь сообщений.

Для получения дополнительной информации, см. статью о функции MouseProc.

Hook-точки WH_MSGFILTER и WH_SYSMSGFILTER

Hook-точки WH_MSGFILTER и WH_SYSMSGFILTER дают возможность Вам контролировать сообщения, которые будут обработаны меню, линейкой прокрутки, окном сообщений или диалоговым окном, и обнаруживать, когда другое окно собирается стать активным в результате нажима пользователем комбинации клавиш ALT+TAB или ALT+ESC. Hook-точка WH_MSGFILTER может контролировать только сообщения переданные в меню, линейку прокрутки, окну сообщений или блоку диалога, созданному прикладной программой, которая установила подключаемую процедуру. Hook-точка WH_SYSMSGFILTER контролирует такие сообщения для всех прикладных программ.

Hook-точки WH_MSGFILTER и WH_SYSMSGFILTER дают возможность Вам выполнить фильтрацию сообщений в ходе модальных циклов, которые является эквивалентными фильтрации производимой в основном цикле сообщений. Например, прикладная программа часто проверяет новое сообщение в основном цикле между временем поиска своего сообщения в очереди и временем, когда она посылает сообщение, выполнив специальную обработку, как это требуется. Однако в ходе модального цикла, система извлекает и распределяет сообщения без предоставления прикладной программе возможности фильтровать сообщения в ее главном цикле сообщений. Если прикладная программа устанавливает подключаемую процедуру WH_MSGFILTER или WH_SYSMSGFILTER, система вызывает процедуру в ходе модального цикла.

Прикладная программа может вызывать hook-точку WH_MSGFILTER непосредственно, вызывая функцию CallMsgFilter. Используя эту функцию, прикладная программа может использовать тот же самый код, чтобы фильтровать сообщения в ходе модальных циклов, поскольку он используется в основном цикле сообщений. Поступив так, вы инкапсулируйте операции фильтрации в подключаемой процедуре WH_MSGFILTER и вызываете CallMsgFilter между обращениями к функциям GetMessage и DispatchMessage.

while (GetMessage(&msg, (HWND) NULL, 0, 0))
 if (!CallMsgFilter(&qmsg, 0)) 
DispatchMessage(&qmsg);
>

Последний параметр CallMsgFilter просто передают в подключаемую процедуру; Вы можете ввести любое значение. Подключаемая процедура, определив константу типа MSGF_MAINLOOP, может использовать это значение, чтобы определить, кем процедура была вызвана.

Для получения дополнительной информации, см. статью о функции MessageProc и SysMsgProc.

Hook-точки WH_SHELL

Оболочка прикладной программы может использовать hook-точку WH_SHELL, чтобы принять важные предупреждения. Windows вызывает подключаемую процедуру WH_SHELL тогда, когда оболочка прикладной программы собирается быть активной и когда окно верхнего уровня создается или разрушается.

Для получения дополнительной информации, см. статью о функции ShellProc.

Справочник по hook-точкам

Ниже перечисленные функции, структуры и сообщения связаны с hook-точками.

Функции hook-точек

Следующие функции используются с hook-точками.

Функция CallMsgFilter

Функция CallMsgFilter передает заданное сообщение и код hook-точки в подключаемые процедуры, связанные с hook-точками WH_MSGFILTER и WH_SYSMSGFILTER. Подключаемая процедура WH_SYSMSGFILTER или WH_MSGFILTER является определяемой программой функцией повторного вызова, которая исследует и, необязательно, модифицирует сообщения для диалогового окна, окна сообщений, меню или линейки прокрутки.

BOOL CallMsgFilter
( 
LPMSG lpMsg, // указатель на структуру с данными сообщения 
int nCode // код hook-точки
);

Параметры
lpMsg
Указатель на структуру MSG, содержащую сообщение, которое будет передано в подключаемые процедуры.
nCode
Устанавливает определяемый программой код, использованный подключаемой процедурой, чтобы определить, как обрабатывать сообщение. Код не должен иметь того же самого значения, что и определяемые системой коды hook-точек (MSGF_ и HC _) связанных с hook-точками WH_MSGFILTER и WH_SYSMSGFILTER.

Возвращаемые значения
Если прикладная программа затем должно обработать сообщение, возвращаемое значение нулевое.
Если прикладная программа затем не обрабатывает сообщение, возвращаемое значение отлично от нуля.

Замечания
Windows вызывает CallMsgFilter, чтобы дать возможность прикладным программам проверять и управлять потоком сообщений в ходе внутренней обработки диалоговых окон, окон сообщений, меню и линеек прокрутки или, когда пользователь активизирует другое окно, нажимая комбинацию клавиш ALT+TAB.
Прикладная программа устанавливает подключаемую процедуру, используя функцию SetWindowsHookEx.

Смотри также
MessageProc, MSG, SetWindowsHookEx, SysMsgProc

Размещение и совместимость CallMsgFilter

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека user32.lib 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется

Функция CallNextHookEx

Функция CallNextHookEx передает информацию hook-точки в следующую подключаемую процедуру в текущей цепочке hook-точек. Эта функция заменяет функцию DefHookProc.

LRESULT CallNextHookEx
( 
HHOOK hhk, // дескриптор текущей hook-точки 
int nCode, // код hook-точки, передаваемый в подключаемую процедуру 
WPARAM wParam, // значение, передаваемое в подключаемую процедуру 
LPARAM lParam // значение, передаваемое в подключаемую процедуру
);

Параметры
hhk
Идентифицирует текущую hook-точку. Прикладная программа принимает этот дескриптор в результате предыдущего вызова функции SetWindowsHookEx.
nCode
Определяет код hook-точки, переданный в текущую подключаемую процедуру. Следующая фильтр - процедура использует этот код, чтобы определить, как обрабатывать информацию hook-точки.
wParam
Определяет значение wParam, переданное в текущую подключаемую процедуру. Значение этого параметра зависит от типа hook-точки, связанной с текущей цепочкой hook-точек.
lParam
Определяет значение lParam, переданное в текущую подключаемую процедуру. Значение этого параметра зависит от типа hook-точки, связанной с текущей цепочкой hook-точек.

Возвращаемые значения
Если функция завершается успешно, возвращаемое значение - величина, возвращенная следующей подключаемой процедурой в цепочке. Текущая фильтр - процедура должна также возвратить это значение. Значение возвращаемой величины зависит от типа hook-точки. Для получения дополнительной информации смотри описания индивидуальных подключаемых процедур.

Замечания
Подключаемые процедуры устанавливаются в цепочки конкретных типов hook-точек. Функция CallNextHookEx вызывает следующую hook-точку в цепочке.
Вызов CallNextHookEx необязателен. Фильтр - процедура может вызывать эту функцию или до или после обработки информации hook-точки. Если подключаемая процедура не вызывает CallNextHookEx, Windows не вызывает Фильтр - процедуры установленные до того, как была установлена текущая подключаемая процедура.

Смотри также
SetWindowsHook, SetWindowsHookEx, UnhookWindowsHook, UnhookWindowsHookEx

Размещение и совместимость CallNextHookEx

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека user32.lib 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется

Функция CallWndProc

Подключаемая процедура CallWndProc -это определяемая программой или определенная библиотекой функция повторного вызова, которую система вызывает всякий раз, когда вызывается функция SendMessage. Перед передачей сообщения в целевую оконную процедуру, система передает сообщение в фильтр - процедуру. Подключаемая процедура может исследовать сообщение; она не может изменить его.

CallWndProc - метка - заместитель для определяемого программой или определенного библиотекой имени функции.

LRESULT CALLBACK CallWndProc
( 
int nCode, // код hook-точки 
WPARAM wParam, // флажок текущей обработки 
LPARAM lParam // адрес структуры с данными сообщения
);

Параметры
nCode
Определяет должна ли подключаемая процедура обрабатывать сообщение. Если nCode - HC_ACTION, фильтр - процедура должна обработать сообщение. Если nCode - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки и должна возвратить значение, возвращенное CallNextHookEx.
wParam
Определяет, не отправлено ли сообщение текущим процессом. Если сообщение посылается текущим процессом, оно отлично от нуля; иначе, оно значение ПУСТО (NULL).
lParam
Указатель на структуру CWPSTRUCT, которая содержит подробности о сообщении.

Возвращаемые значения
Величина возвращаемого значения должна быть нуль.

Замечания
Подключаемая процедура CallWndProc может исследовать сообщение, но она не может изменить его. После того как фильтр - процедура возвратит управление системе, сообщение передается в оконную процедуру.
Прикладная программа устанавливает подключаемую процедуру, определяя тип hook-точки WH_CALLWNDPROC и адрес фильтр - процедуры при вызове функции SetWindowsHookEx.
Hook-точка WM_CALLWNDPROC вызывается в контексте потока, который вызывает SendMessage, а не потока, который принимает сообщение.

Смотри также
CallNextHookEx, CWPSTRUCT, SendMessage, SetWindowsHookEx

Размещение и совместимость CallWndProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определенная пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция CallWndRetProc

[Теперь поддерживается Windows NT]

Подключаемая процедура CallWndRetProc -это определяемая программой или определенная библиотекой функция повторного вызова, которую система вызывает всякий раз, когда вызывается функция SendMessage. Перед передачей сообщения в оконную процедуру предназначения, система передает сообщение в фильтр - процедуру. Подключаемая процедура может исследовать сообщение; она не может изменить его.

LRESULT CALLBACK CallWndRetProc
( 
int nCode, // код hook-точки 
WPARAM wParam, // флажок текущей обработки 
LPARAM lParam // адрес структуры с данными сообщения
);

Параметры
nCode
Определяет должна ли подключаемая процедура обрабатывать сообщение. Если nCode - HC_ACTION, фильтр - процедура должна обработать сообщение. Если nCode - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки и должна возвратить значение, возвращенное CallNextHookEx.
wParam
Определяет, не отправлено ли сообщение текущим процессом. Если сообщение отправляется текущим процессом, оно отлично от нуля; иначе, оно значение ПУСТО (NULL).
lParam
Указатель на структуру CWPRETSTRUCT, которая содержит подробности о сообщении.

Возвращаемые значения
Величина возвращаемого значения должна быть нуль.

Замечания
Прикладная программа устанавливает подключаемую процедуру, определяя тип hook-точки WH_CALLWNDPROCRET и адрес фильтр - процедуры при вызове функции SetWindowsHookEx. CallWndRetProc - метка - заместитель для определяемого программой или определенного библиотекой имени функции.

Смотри также
CallNextHookEx, CallWndProc, CWPRETSTRUCT, SendMessage, SetWindowsHookEx.

Размещение и совместимость CallWndRetProc

Windows NT Да 
Win95 Да 
Win32s Нет 
Импортируемая библиотека Определенная пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC 

Функция CBTProc

Подключаемая процедура CBTProc - это определяемая программой или определенная библиотекой функция повторного вызова, которую вызывает система перед активизацией, созданием, разрушением, уменьшением, увеличением, перемещением, или установлением размеров окна; перед завершением системной команды; перед удалением события мыши или клавиатуры из системной очереди сообщений; перед установкой фокуса клавиатуры; или перед синхронизацией системной очереди сообщений. Значение, возвращаемое подключаемой процедурой, определяет, разрешит или запретит операционная система Windows одно из этих действий. Прикладная программа машинной подготовки (computer-based training) (CBT) использует эту фильтр - процедуру, чтобы принять полезные уведомления от системы.

LRESULT CALLBACK CBTProc
( 
int nCode, // код hook-точки 
WPARAM wParam, // зависит от кода hook-точки 
LPARAM lParam // зависит от кода hook-точки
);

Параметры
nCode
Определяет код, который подключаемая процедура использует, чтобы установить, как обрабатывать сообщение. Этот параметр может быть одним из следующих значений:

• HCBT_ACTIVATE - Система собирается активизировать окно
• HCBT_CLICKSKIPPED - Система удаляет сообщение мыши из системной очереди сообщений. После приема этого кода hook-точки, CBT приложение должно установить подключаемую процедуру WH_JOURNALPLAYBACK в ответ на сообщение мыши.
• HCBT_CREATEWND - Окно готовится быть созданным. Система вызывает подключаемую процедуру перед отправкой сообщения WM_CREATE или WM_NCCREATE окну. Если фильтр - процедура возвращает значение, отличающееся от нуля, система разрушает окно; функция CreateWindow возвращает значение NULL (ПУСТО), но сообщение WM_DESTROY не отправляется окну. Если подключаемая процедура возвращает значение ноль, окно создается как обычно.Окно было создано во время уведомления HCBT_CREATEWND, но его конечный размер и позицию не возможно было определить, а его родительское окно не возможно было установить. Система имеет возможность оправить сообщения недавно созданному окну, несмотря на то, что оно еще не приняло сообщения WM_CREATE или WM_NCCREATE. Она имеет также возможность изменить и позицию недавно созданного окна в Z-последовательности, изменяя член hwndInsertAfter структуры CBT_CREATEWND.
• HCBT_DESTROYWND - Окно собирается быть разрушенным.
• HCBT_KEYSKIPPED - Система удалила сообщение клавиатуры из системной очереди сообщений. После приема этого кода hook-точки, прикладная программа CBT должна установить подключаемую процедуру WH_JOURNALPLAYBACK в ответ на сообщение клавиатуры.
• HCBT_MINMAX - Окно намеревается быть свернутым или развернутым.
• HCBT_MOVESIZE - Окно намеревается быть перемещенным или изменить свои размеры.
• HCBT_QS - Система извлекла сообщение WM_QUEUESYNC из системной очереди сообщений.
• HCBT_SETFOCUS - Окно собирается принять фокус клавиатуры.
• HCBT_SYSCOMMAND - Системная команда собирается быть завершенной. Это позволяет прикладной программе CBT предотвратить переключение задач посредством комбинаций "горячих клавиш -"hot key".

Если nCode - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки и должна возвратить значение, возвращенное CallNextHookEx.

wParam
Зависит от параметра nCode. За подробностями обратитесь в. следующий раздел Замечаний.
lParam
Зависит от параметра nCode. За подробностями обратитесь в. следующий раздел Замечаний.

Возвращаемые значения
Для действий, соответствующих ниже перечисленным кодам hook-точек CBT, величина возвращаемого значения должна быть 0, чтобы позволить операцию, или 1, чтобы запретит ее:

HCBT_ACTIVATE
HCBT_CREATEWND
HCBT_DESTROYWND
HCBT_MINMAX
HCBT_MOVESIZE
HCBT_SETFOCUS
HCBT_SYSCOMMAND

Для операций, соответствующих ниже перечисленным кодам hook-точек CBT, величина возвращаемого значения игнорируется:

HCBT_CLICKSKIPPED
HCBT_KEYSKIPPED
HCBT_QS

Замечания
Подключаемая процедура не должна устанавливать фильтр - процедуру WH_JOURNALPLAYBACK кроме как в ситуациях, описанных в предшествующем перечне кодов hook-точек.
Эта подключаемая процедура должна быть в динамически подключаемой библиотеке (DLL). Прикладная программа устанавливает фильтр - процедуру, определяя тип hook-точки WH_CBT и адрес подключаемой процедуры при вызове функции SetWindowsHookEx.
Нижеследующая таблица описывает параметры wParam и lParam для каждого кода hook-точки HCBT_:

Код	wParam	lParam
HCBT_ACTIVATE	Определяет дескриптор окна, собирающегося быть активизированным.	Определяет дальний указатель на структуру CBTACTIVATESTRUCT, содержащую дескриптор активного окна и определяет, не изменяется ли активность из-за щелчка мыши.
HCBT_CLICKSKIPPED	Идентифицирует сообщение мыши, удаленное из системной очереди сообщений.	Определяет дальний указатель на структуру MOUSEHOOKSTRUCT, содержащей код местоположения курсора и дескриптор окна, для которого предназначено сообщение мыши. Значение HCBT_CLICKSKIPPED отправляется подключаемой процедуре CBTProc только тогда, если установлена hook-точка WH_MOUSE. За перечнем кодов местоположения курсора, обратитесь к статье WM_NCHITTEST.
HCBT_CREATEWND	Определяет дескриптор нового окна.	Определяет дальний указатель на структуру CBT_CREATEWND, содержащую параметры инициализации для окна. Параметры включают в себя координаты и размеры окна. Изменяя эти параметры, подключаемая процедура CBTProc может установить начальный размер и позицию окна.
HCBT_DESTROYWND	Определяет дескриптор окна, собирающегося быть разрушенным.	Не определяется и должен быть установлен в нуль.
HCBT_KEYSKIPPED	Идентифицирует код виртуальной клавиши.	Определяет повторный счет, скэн-код, код клавиши перехода, предыдущее состояние клавиши и код контекста. Значение HCBT_KEYSKIPPED отправляется подключаемой процедуре CBTProc только тогда, если установлена hook-точка WH_KEYBOARD. Для получения дополнительной информации, см. сообщение WM_KEYDOWN или WM_KEYUP.
HCBT_MINMAX	Определяет дескриптор свертываемого или развертываемого окна.	Определяет младшее слово значения показа окна (SW _), определенное операцией. Для получения списка значений показа окна, см. ShowWindow. Старшее слово не определяется.
HCBT_MOVESIZE	Определяет дескриптор окна, которое будет перемещено или установлено с другими размерами.	Определяет дальний указатель на структуру RECT, содержащую координаты окна. Изменяя значения в структуре, подключаемая процедура CBTProc может устанавливать конечные координаты окна.
HCBT_QS	Не определяется и должен быть установлен в нуль.	Не определяется и должен быть установлен в нуль.
HCBT_SETFOCUS	Определяет дескриптор окна, получающего фокус клавиатуры.	Определяет дескриптор окна, теряющего фокус клавиатуры.
HCBT_SYSCOMMAND	Определяет значение системной команды (SC_), которое устанавливается командой системы. Для получения дополнительной информации о значениях системных команд, см. WM_SYSCOMMAND.	lСодержит те же самые данные что и значение lParam сообщения WM_SYSCOMMAND: Если команда системного меню выбрана мышью, младшее слово содержит x-координату курсора, в экранных координатах, а старшее слово содержит y-координату; иначе, параметр не используется.

CBTProc - метка - заместитель для определяемого программой или определенного библиотекой имени функции.

Смотри также
CallNextHookEx, CreateWindow, SetWindowsHookEx, WM_SYSCOMMAND

Размещение и совместимость CBTProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определенная пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция DebugProc

Подключаемая процедура DebugProc - определяемая программой или определенная библиотекой функция повторного вызова, к которой Windows обращается перед вызовом фильтр - процедур, связанных с любым другим типом hook-точки. Система передает информацию о hook-точке, которая будет вызвана, подключаемой процедуре DebugProc, которая исследует эту информацию и решает, позволить ли hook-точке быть вызванной.

LRESULT CALLBACK DebugProc
( 
int nCode, // код hook-точки 
WPARAM wParam, // тип hook-точки,собирающейся быть вызванной 
LPARAM lParam // адрес структуры с информацией об отладке
);

Параметры
nCode
Определяет, должна ли подключаемая процедура обрабатывать сообщение. Если nCode - HC_ACTION, фильтр - процедура должна обработать сообщение. Если nCode - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки и должна возвратить значение, возвращенное CallNextHookEx.
wParam
Определяет тип hook-точки, собирающейся быть вызванной. Этот параметр может быть одним из следующих значений:

• WH_CALLWNDPROC - Устанавливает подключаемую процедуру, которая отслеживает сообщения, отправленные оконной процедуре. Для получения дополнительной информации, см. описание фильтр - процедуры CallWndProc.
• WH_CALLWNDPROCRET - Устанавливает подключаемую процедуру, которая отслеживает сообщения, которые только что были обработаны оконной процедурой. Для получения дополнительной информации, см. описание фильтр - процедуры CallWndRetProc.
• WH_CBT - Устанавливает подключаемую процедуру, которая принимает уведомления, полезные для машинной подготовки (CBT) прикладной программы. Для получения дополнительной информации, см. описание подключаемой процедуры CBTProc.
• WH_DEBUG - Устанавливает фильтр - процедуру, полезную для отладки других подключаемых процедур. Для получения дополнительной информации, см. описание подключаемой процедуры DebugProc.
• WH_GETMESSAGE - Устанавливает подключаемую процедуру, которая отслеживает сообщения, задержанные в очереди сообщений. Для получения дополнительной информации, см. описание фильтр - процедуры GetMsgProc.
• WH_JOURNALPLAYBACK - Устанавливает подключаемую процедуру, которая регистрирует сообщения, предварительно записанные фильтр - процедурой WH_JOURNALRECORD. Для получения дополнительной информации, см. описание подключаемой процедуры JournalPlaybackProc.
• WH_JOURNALRECORD - Устанавливает подключаемую процедуру, которая заносит в список входящие сообщения, зарегистрированные в системной очереди сообщений. Эта hook-точка полезна для записи макрокоманд. Для получения дополнительной информации, см. описание подключаемой процедуры JournalRecordProc.
• WH_KEYBOARD - Устанавливает подключаемую процедуру, которая отслеживает сообщения о нажатиях клавиш. Для получения дополнительной информации, см. описание фильтр - процедуры KeyboardProc.
• WH_MOUSE - Устанавливает подключаемую процедуру, которая отслеживает сообщения мыши. Для получения дополнительной информации, см. описание фильтр - процедуры MouseProc.
• WH_MSGFILTER - Устанавливает подключаемую процедуру, которая отслеживает сообщения, сгенерированные в результате события ввода данных в диалоговом окне, окне сообщений, меню или в линейке прокрутки. Фильтр - процедура отслеживает эти сообщения только для прикладной программы, которая установила подключаемую процедуру. Для получения дополнительной информации, см. описание фильтр - процедуры MessageProc.
• WH_SHELL - Устанавливает подключаемую процедуру, которая принимает уведомление полезное для оболочки прикладной программы. Для получения дополнительной информации, см. описание фильтр - процедуры ShellProc.
• WH_SYSMSGFILTER - Устанавливает подключаемую процедуру, которая отслеживает сообщения, сгенерированные в результате события ввода данных в блоке диалога, окне сообщений, меню, или линейке прокрутки. Подключаемая процедура контролирует эти сообщения для всех прикладных программ в системе. Для получения дополнительной информации, см. описание подключаемой процедуры SysMsgProc.

lParam
Указывает на структуру DEBUGHOOKINFO, которая содержит параметры для передачи в подключаемую процедуру назначения.

Возвращаемые значения
Чтобы предохранить систему от вызова hook-точки, величина возвращаемого значения должна быть значением отличным от нуля. Иначе, подключаемая процедура должна передать информацию hook-точки в функцию CallNextHookEx.

Замечания
Прикладная программа устанавливает эту подключаемую процедуру, при помощи определения типа hook-точки как WH_DEBUG и указателя на фильтр - процедуру при вызове функции SetWindowsHookEx.
CallWndProc и CallWndRetProc - метки - заместители для определяемых программой или определенных библиотекой имен функции.

Смотри также
CallNextHookEx, CallWndProc, CallWndRetProc, CBTProc, DEBUGHOOKINFO, GetMsgProc, JournalPlaybackProc, JournalRecordProc, KeyboardProc, MessageProc, MouseProc, SetWindowsHookEx, ShellProc, SysMsgProc

Размещение и совместимость DebugProc

Windows NT Да 
Win95 Нет 
Win32s Нет 
Импортируемая библиотека Определенная пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC 

Функция ForegroundIdleProc

Подключаемую процедуру ForegroundIdleProc - определяемую программой функцию повторного вызова система вызывает всякий раз тогда, когда 32-разрядный поток первого плана собирается стать ожидающим.

DWORD ForegroundIdleProc
( 
int code, // код hook-точки 
DWORD wParam, // не используется 
LONG lParam // не используется
);

Параметры
code
Определяет, должна ли подключаемая процедура обрабатывать сообщение. Если code является HC_ACTION, фильтр - процедура должна обработать сообщение. Если code - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки и должна возвратить значение, возвращенное CallNextHookEx.
wParam
Не используется
lParam
Не используется

Замечания
Прикладная программа устанавливает эту подключаемую процедуру, при помощи определения типа hook-точки как WH_FOREGROUNDIDLE и указателя на подключаемую процедуру при вызове функции SetWindowsHookEx.
ForegroundIdleProc - метка - заместитель для определяемого программой имени функции.
Это - hook-точка устанавливается потоком.

Смотри также
CallNextHookEx, SetWindowsHookEx

Размещение и совместимость ForegroundIdleProc

Windows NT Да 
Win95 Нет 
Win32s Нет 
Импортируемая библиотека Определенная пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция GetMsgProc

Подключаемая процедура GetMsgProc - определяемая программой или определенная библиотекой функция повторного вызова, которую система вызывает всякий раз, когда функция GetMessage извлекает сообщение из очереди сообщений прикладной программы. Перед передачей извлеченного сообщения в оконную процедуру назначения, система передает сообщение в подключаемую процедуру.

LRESULT CALLBACK GetMsgProc
( 
int code, // код hook-точки 
WPARAM wParam, // флажок удаления 
LPARAM lParam // адрес структуры с сообщением
);

Параметры
code
Определяет, должна ли подключаемая процедура обрабатывать сообщение. Если code - HC_ACTION, фильтр - процедура должна обработать сообщение. Если code - меньше чем нуль, фильтр - процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки и должна возвратить значение, возвращенное CallNextHookEx.
wParam
Определяет, было ли сообщение удалено из очереди. Этот параметр может быть одним из следующих значений:

• PM_NOREMOVE - Определяет, что сообщение не было удалено из очереди. (Прикладная программа вызвала функцию PeekMessage, установив флажок PM_NOREMOVE.)
• PM_REMOVE - Определяет, что сообщение было удалено из очереди. (Прикладная программа вызвала GetMessage, или она вызвала функцию PeekMessage, установив флажок PM_REMOVE.)

lParam
Указывает на структуру MSG, которая содержит подробности о сообщении.

Возвращаемые значения
Возвращаемое значение должно быть ноль.

Замечания
Подключаемая процедура GetMsgProc может исследовать или изменить сообщение. После того, как фильтр - процедура возвратит управление системе, функция GetMessage возвращает значение сообщения, вместе с любыми изменениями, в прикладную программу, которая первоначально вызвала её.
Прикладная программа устанавливает эту подключаемую процедуру, определяя тип hook-точки как WH_GETMESSAGE и адрес подключаемой процедуры при вызове функции SetWindowsHookEx.
GetMsgProc - метка - заместитель для определяемого программой или определенного библиотекой имени функции.

Смотри также
CallNextHookEx, GetMessage, MSG, PeekMessage, SetWindowsHookEx

Размещение и совместимость GetMsgProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определяется пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC 

Функция JournalPlaybackProc

Подключаемая процедура JournalPlaybackProc - функция повторного вызова, которая вставляет сообщения от мыши и клавиатуры в системную очередь сообщений. Как правило, прикладная программа использует эту фильтр - процедуру, чтобы воспроизвести ряд сообщений мыши и клавиатуры, предварительно записанных подключаемой процедурой JournalRecordProc. Пока устанавливается фильтр - процедура JournalPlaybackProc, ввод данных от обычной мыши и от клавиатуры заблокирован.

LRESULT CALLBACK JournalPlaybackProc
( 
int code, // код hook-точки 
WPARAM wParam, // не определяется 
LPARAM lParam // адрес обрабатываемого сообщения
);

Параметры
code
Определяет код, который подключаемая процедура использует, чтобы определить, как обрабатывать сообщение. Этот параметр может быть одно из следующих значений:

• HC_GETNEXT - Подключаемая процедура должна копировать текущее сообщение от мыши или клавиатуры в структуре EVENTMSG, указанной параметром lParam.
• HC_NOREMOVE - Прикладная программа вызвала функцию PeekMessage с wRemoveMsg установленным в PM_NOREMOVE, указывая этим, что сообщение не удалено из очереди сообщений после обработки PeekMessage.
• HC_SKIP - Подключаемая процедура должна приготовиться копировать следующее сообщение от мыши или клавиатуры в структуре EVENTMSG, указанной lParam. После приема кода HC_GETNEXT, фильтр - процедура должна скопировать сообщение в структуру.
• HC_SYSMODALOFF - Системно - модальное диалоговое окно было разрушено. Подключаемая процедура должна продолжить воспроизводить сообщения.
• HC_SYSMODALON - Системно - модальное диалоговое окно отображается на экране. Пока блок диалога не разрушен, подключаемая процедура должна прекратить воспроизводить сообщения.

Если code - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки и должна возвратить значение, возвращенное CallNextHookEx.
wParam
Устанавливается в значение ПУСТО (NULL).
lParam
Указывает на структуру EVENTMSG, которая предоставляет сообщение, обрабатываемое подключаемой процедурой. Этот параметр допустим, только тогда, когда параметра code равен HC_GETNEXT.

Возвращаемые значения
Чтобы заставить систему ждать перед обработкой сообщения, величина возвращаемого значения должна быть количеством времени, в тактах системных часов, количество которых система должна ждать. (Это значение может быть подсчитано, путем вычисления разности между членами time текущего и предыдущего входящих сообщений.) Чтобы обработать сообщение немедленно, величина возвращаемого значения должна быть нулевая. Величина возвращаемого значения используется, только тогда, если код hook-точки - HC_GETNEXT; иначе, она игнорируется.

Замечания
Подключаемая процедура JournalPlaybackProc должна копировать входящее сообщение в параметр lParam. Сообщение, должно быть предварительно записано при помощи использования фильтр - процедуры JournalRecordProc, которая не должна изменять сообщение.
Чтобы извлекать то же самое сообщение снова и снова, подключаемая процедура может быть вызвана несколько раз с параметром code установленным в HC_GETNEXT без промежуточного вызова code установленным в HC_SKIP.
Если code - HC_GETNEXT и величина возвращаемого значения больше чем нуль, система бездействует количество миллисекунд, заданных величиной возвращаемого значения. Когда система продолжит свою работу, она снова вызывает подключаемую процедуру с установкой code в HC_GETNEXT, чтобы извлечь то же самое сообщение. Величина возвращаемого значения этого нового вызова JournalPlaybackProc должна быть нулевая; иначе, система возвратится в состояние бездействия на число миллисекунд, заданных величиной возвращаемого значения, вызовет JournalPlaybackProc снова, и так далее по кругу. Система, будет находиться в состоянии зависания.
В отличие от большинства других глобальных подключаемых процедур, фильтр - процедуры JournalRecordProc и JournalPlaybackProc всегда вызываются в контексте потока, который устанавливает hook-точку.
После возвращения фильтр - процедурой управления системе, сообщение продолжает обрабатываться. Если code - HC_SKIP, подключаемая процедура должна приготовиться возвратить следующее зарегистрированное сообщение о событии при своем следующем вызове.
Прикладная программа устанавливает подключаемую процедуру JournalPlaybackProc, путем определения типа hook-точки как WH_JOURNALPLAYBACK и адреса подключаемой процедуры при вызове функции SetWindowsHookEx.
Подключаемая процедура Win32 JournalRecordProc не должна находиться в динамически компонуемой библиотеке.
Подключаемая процедура Win32 JournalRecordProc может находиться непосредственно в прикладной программе.
Если пользователь нажимает CTRL+ESC или CTRL+ALT+DEL в ходе воспроизведения протокола, система останавливает считывание, отцепляет процедуру считывания протокола и отсылает сообщение WM_CANCELJOURNAL в ведущую протокол прикладную программу.
Если подключаемая процедура возвращает сообщение в диапазоне от WM_KEYFIRST до WM_KEYLAST, применяются следующие условия:

• Член paramL структуры EVENTMSG определяет код виртуальной клавиши, которая была нажата.
• Член paramH структуры EVENTMSG определяет скэн-код.
• Не имеется никакого способа, чтобы определить повторный счет. Событие всегда принимается, чтобы предоставить одно событие связанное с клавишей.

JournalPlaybackProc - метка - заместитель для определяемого программой или определенного библиотекой имени функции.

Смотри также
CallNextHookEx, EVENTMSG, JournalRecordProc, PeekMessage, SetWindowsHookEx, WM_CANCELJOURNAL

Размещение и совместимость JournalPlaybackProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определяется пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция JournalRecordProc

Подключаемая процедура JournalRecordProc - функция повторного вызова, которая записывает сообщения, удаленные системой из системной очереди сообщений. Позже, прикладная программа может использовать подключаемую процедуру JournalPlaybackProc, чтобы воспроизвести сообщения.

LRESULT CALLBACK JournalRecordProc
( 
int code, // код hook-точки 
WPARAM wParam, // не определяется 
LPARAM lParam // адрес обрабатываемого сообщения
);

Параметры
code
Определяет, как обрабатывать сообщение. Этот параметр может быть одним из следующих значений:

• HC_ACTION - Параметр lParam указывает на структуру EVENTMSG, которая содержит информацию о сообщении, удаленном из системной очереди. Подключаемая процедура должна записать содержимое структуры, путем копирования его в буфер или файл.
• HC_SYSMODALOFF - Системно- модальное диалоговое окно было разрушено. Подключаемая процедура должна возобновить запись.
• HC_SYSMODALON - Системно- модальное диалоговое окно было разрушено. До тех пор пока диалоговое окно является разрушенным, подключаемая процедура должна прекратить запись.

Если code является меньшим чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей его обработки и должна возвратить значение, возвращенное CallNextHookEx. wParam
Определяет значение ПУСТО (NULL).
lParam
Указывает на структуру EVENTMSG, которая содержит сообщение, которое будет записано.

Возвращаемые значения
Возвращаемое значение игнорируется.

Замечания
Подключаемая процедура JournalRecordProc должна копировать, но не изменять сообщения. После того, как фильтр - процедура возвратит управление системе, обработка сообщения продолжится.
Прикладная программа устанавливает подключаемую процедуру JournalRecordProc при помощи определения типа hook-точки как WH_JOURNALRECORD и ее адреса при вызове функции SetWindowsHookEx.
Фильтр - процедура Win32 JournalRecordProc не должна находиться в динамически подключаемой библиотеке. Подключаемая процедура Win32 JournalRecordProc может находиться непосредственно в прикладной программе.
В отличие от большинства других глобальных подключаемых процедур, фильтр - процедуры JournalRecordProc и JournalPlaybackProc всегда вызываются в контексте потока, который установил hook-точку.
Прикладная программа, которая установила подключаемую процедуру JournalRecordProc, должна отслеживать виртуальный клавишный код VK_CANCEL (который реализуется у большинства клавиатур комбинацией клавиш CTRL+BREAK). Этот виртуальный клавишный код должен интерпретироваться прикладной программой как сигнал, что пользователь желает остановить запись протокола. Прикладная программа должна ответить окончанием записываемой последовательности и удалением подключаемой процедуры JournalRecordProc. Удаление важно. Оно предохраняет ведущую протокол прикладную программу от застопоривания системы, которое приводит к зависанию внутри фильтр - процедуры.
Эта роль в качестве сигнала для остановки записи протокола, означает, что комбинация клавиш CTRL+BREAK не может самостоятельно быть записана. Поскольку комбинация клавиш CTRL+C не имеет подобной роли как сигнал к ведению протокола, она может быть записана. Имеются две других комбинации клавиш, которые не могут быть записаны: CTRL+ESC и CTRL+ALT+DEL. Эти две комбинации клавиш заставляют систему остановить все ведущие протокол действия (запись или считывание), удалить все ведущие протокол hook-точки и известить о сообщении WM_CANCELJOURNAL ведущую протокол прикладную программу.
JournalRecordProc является меткой-заместителем для определяемого программой или определяемого библиотекой имени функции.

Смотри также
CallNextHookEx, EVENTMSG, JournalPlaybackProc, SetWindowsHookEx, WM_CANCELJOURNAL

Размещение и совместимость JournalRecordProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определяется пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция KeyboardProc

Подключаемая процедура KeyboardProc является определяемой программой или библиотекой функцией повторного вызова, которую система вызывает всякий раз, когда прикладная программа вызывает функцию GetMessage или PeekMessage и имеется сообщение клавиатуры (WM_KEYUP или WM_KEYDOWN), которое надо обработать.

LRESULT CALLBACK KeyboardProc
( 
int code, // код hook-точки 
WPARAM wParam, // код виртуальной клавиши 
LPARAM lParam // информация о сообщении нажатой клавиши
);

Параметры
code
Определяет код, который подключаемая процедура использует, чтобы определить, как обработать сообщение. Этот параметр может быть одним из следующих значений:

• HC_ACTION - Параметры wParam и lParam содержат информацию о сообщении нажатой клавиши.
• HC_NOREMOVE - Параметры wParam и lParam содержат информацию о сообщении нажатой клавиши, но сообщение нажатой клавиши не удаляется из очереди сообщений. (Прикладная программа вызвала функцию PeekMessage, установив флажок PM_NOREMOVE.)

Если code - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки, а возвратить должна значение возвращенное CallNextHookEx.
wParam
Определяет виртуальный код клавиши, которая создала сообщение нажатой клавиши.
lParam
Определяет счет повторений, скэн-код, флажок расширенной - клавиши, контекстный код, флажок предыдущего состояния клавиши и флажок переходного состояния. Этот параметр может быть комбинацией следующих значений:

• 0-15 - Определяет счет повторений. Значением является число нажатий клавиши, которое повторено в результате пользовательского удерживания нажатия клавиши.
• 16-23 - Определяет скэн-код. Значение зависит от фирмы-изготовителя оборудования (OEM).
• 24 - Определяет, является ли клавиша расширенной клавишей, типа функциональной или клавиши на цифровой клавиатуре. Если клавиша является расширенной, это значение равно 1, иначе, оно - 0.
• 25-28 - Зарезервировано.
• 29 - Определяет код контекста. Это значение является 1, если нажата клавиша ALT; иначе, оно - 0.
• 30 - Определяет предыдущее состояние клавиши. Это значение является 1, если клавиша была нажата перед отправкой сообщения. Оно - 0, если клавиша была не нажата.
• 31 - Определяет переходное состояние. Это значение 0, если клавиша нажимается и 1, если клавиша отпускается.

Для получения дополнительной информации о параметре lParam, см. Флажки сообщения нажатия клавиши.

Возвращаемые значения
Чтобы предохранить Windows от передачи сообщения по остальной части цепочки hook-точек или в целевую оконную процедуру, величина возвращаемого значения должна быть значением отличным от нуля. Чтобы позволить Windows передавать сообщение в целевую оконную процедуру, в обход оставшихся в цепочке процедур, величина возвращаемого значения должна быть нулевая.

Замечания
Прикладная программа устанавливает подключаемую процедуру, путем определения типа hook-точки как WH_KEYBOARD и ее адреса при вызове функции SetWindowsHookEx.
KeyboardProc - метка - заместитель для определяемого программой или определенного библиотекой имени функции.

Смотри также
CallNextHookEx, GetMessage, PeekMessage, SetWindowsHookEx, WM_KEYUP, WM_KEYDOWN

Размещение и совместимость KeyboardProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определяется пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция MessageProc

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

LRESULT CALLBACK MessageProc
( 
int code, // код hook-точки 
WPARAM wParam, // не определен 
LPARAM lParam // адрес структуры с данными сообщения
);

Параметры
code
Определяет тип события ввода, которое генерировало сообщение. Этот параметр может быть одним из следующих значений:

• MSGF_DDEMGR - Произошло событие ввода, в то время как Библиотека Управления Динамического обмена данными (DDEML- Dynamic Data Exchange Management Library.) ожидала для окончания работы синхронизацию групповой операции (транзакции). Для получения дополнительной информации о DDEML, см. Библиотеку Управления Динамическим обменом данными.
• MSGF_DIALOGBOX - Произошло событие ввода в окне сообщений или диалоговом окне.
• MSGF_MENU - Произошло событие ввода в меню.
• MSGF_NEXTWINDOW - Произошло событие ввода в результате нажима пользователем комбинации клавиш ALT+TAB, чтобы включить другое окно.
• MSGF_SCROLLBAR - Произошло событие ввода в линейке прокрутки.

Если code является меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей его обработки и должна возвратить значение, возвращенное CallNextHookEx.
wParam
Устанавливает значение ПУСТО (NULL).
lParam
Указывает на структуру MSG
.

Возвращаемые значения
Если подключаемая процедура обрабатывает сообщение, то возвращаемое значение должно быть значением отличным от нуля. Иначе, оно должно быть нуль.

Замечания
Прикладная программа устанавливает подключаемую процедуру, путем определения типа hook-точки как WH_MSGFILTER и ее адреса при вызове функции SetWindowsHookEx.
Если прикладная программа, которая использует DDEML и выполняет синхронные передачи данных, сообщения должны обрабатываться перед тем, как они распределены, она должна использовать hook-точку WH_MSGFILTER.
MessageProc - метка - заместитель для определяемого программой имени функции.

Смотри также
CallNextHookEx, SetWindowsHookEx, MSG

Размещение и совместимость MessageProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определется пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция MouseProc

Подключаемая процедура MouseProc является определяемая программой или определенная библиотекой функцией повторного вызова, которую система вызывает всякий раз, когда прикладная программа вызывает функцию GetMessage или PeekMessage и имеется сообщение мыши, которое надо обработать.

LRESULT CALLBACK MousedProc
( 
int nCode, // код hook-точки 
WPARAM wParam, // идентификатор сообщения 
LPARAM lParam // координаты мыши
);

Параметры
nCode
Определяет код, который подключаемая процедура использует, чтобы определить, как обработать сообщение. Этот параметр может быть одним из следующих значений:

• HC_ACTION - Параметры wParam и lParam содержат информацию о сообщении мыши.
• HC_NOREMOVE - Параметры wParam и lParam содержат информацию о сообщении мыши, но сообщение мыши не удаляется из очереди сообщений. (Прикладная программа вызвала функцию PeekMessage, установив флажок PM_NOREMOVE.)

Если nCode - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки, а возвратить должна значение возвращенное CallNextHookEx.
wParam
Определяет идентификатор сообщения мыши.
lParam
Указывает на структуру MOUSEHOOKSTRUCT.

Возвращаемые значения
Чтобы дать возможность системе обработать сообщение, величина возвращаемого значения должна быть нулевая. Чтобы сбросить сообщение, величина возвращаемого значения должна быть значением отличным от нуля.

Замечания
Подключаемая процедура не должна устанавливать функцию повторного вызова JournalPlaybackProc.
Прикладная программа устанавливает подключаемую процедуру, путем определения типа hook-точки как WH_MOUSE и ее адреса при вызове функции SetWindowsHookEx.
MouseProc - метка - заместитель для определяемого программой или определенного библиотекой имени функции.

Смотри также
CallNextHookEx, GetMessage, JournalPlaybackProc, MOUSEHOOKSTRUCT, PeekMessage, SetWindowsHookEx

Размещение и совместимость MouseProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определется пользователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция SetWindowsHookEx

Функция SetWindowsHookEx устанавливает определяемую программой подключаемую процедуру в цепочку hook-точек. Прикладная программа устанавливает фильтр - процедуру, чтобы контролировать некоторые типы событий в системе. Подключаемая процедура может контролировать события связанные или с конкретным потоком или со всеми потоками в системе. Эта функция заменяет функцию SetWindowsHook.

HHOOK SetWindowsHookEx
( 
int idHook, // тип hook-точки, которая устанавливается 
HOOKPROC lpfn, // адрес подключаемой процедуры 
HINSTANCE hMod, // дескриптор экземпляра прикладной программы 
DWORD dwThreadId // идентификация потока, который устанавливает hook-точку
);

Параметры
idHook
Определяет тип подключаемой процедуры, которая будет установлена. Этот параметр может быть одним из следующих значений:

• WH_CALLWNDPROC - Устанавливает подключаемую процедуру, которая контролирует сообщения до того, как система отправит их оконной процедуре предназначения. Для получения дополнительной информации, см. подключаемую процедуру CallWndProc.
• WH_CALLWNDPROCRET - Устанавливает подключаемую процедуру, которая контролирует сообщения после того, как они были обработаны оконной процедурой предназначения. Для получения дополнительной информации, см. подключаемую процедуру CallWndRetProc.
• WH_CBT - Устанавливает подключаемую процедуру, которая принимает уведомления, полезные для машинной подготовки (CBT) прикладной программы. Для получения дополнительной информации, см. подключаемую процедуру CBTProc.
• WH_DEBUG - Устанавливает подключаемую процедуру, полезную для отладки других фильтр - процедур. Для получения дополнительной информации, см. подключаемую процедуру DebugProc.
• WH_GETMESSAGE - Устанавливает подключаемую процедуру, которая контролирует сообщения, задержанные в очереди сообщений. Для получения дополнительной информации, см. подключаемую процедуру GetMsgProc.
• WH_JOURNALPLAYBACK - Устанавливает подключаемую процедуру, которая задерживает сообщения, предварительно записанные подключаемой процедурой WH_JOURNALRECORD. Для получения дополнительной информации, см. подключаемую процедуру JournalPlaybackProc.
• WH_JOURNALRECORD - Устанавливает подключаемую процедуру, которая записывает входящие сообщения, задерживаемые в системной очереди сообщений. Эта hook-точка полезна для регистрации макрокоманд. Для получения дополнительной информации, см. подключаемую процедуру JournalRecordProc.
• WH_KEYBOARD - Устанавливает подключаемую процедуру, которая контролирует сообщения нажатия клавиш. Для получения дополнительной информации, см. подключаемую процедуру KeyboardProc.
• WH_MOUSE - Устанавливает подключаемую процедуру, которая контролирует сообщения мыши. Для получения дополнительной информации, см. подключаемую процедуру MouseProc.
• WH_MSGFILTER - Устанавливает подключаемую процедуру, которая контролирует сообщения, созданные в результате события ввода в диалоговом окне, окне сообщений, меню или линейке прокрутки. Для получения дополнительной информации, см. подключаемую процедуру MessageProc.
• WH_SHELL - Устанавливает подключаемую процедуру, которая принимает уведомления, полезные для оболочки прикладных программ. Для получения дополнительной информации, см. подключаемую процедуру ShellProc.
• WH_SYSMSGFILTER - Устанавливает подключаемую процедуру, которая контролирует сообщения, созданные в результате события ввода диалоговом окне, окне сообщений, меню или линейке прокрутки. Фильтр - процедура контролирует эти сообщения для всех прикладных программ в системе. Для получения дополнительной информации, см. подключаемую процедуру SysMsgProc.

lpfn
Указывает на подключаемую процедуру. Если параметр dwThreadId нулевой или он определяет идентификатор потока, созданного другим процессом, параметр lpfn должен указывать на фильтр - процедуру в динамически компонуемой библиотеке (DLL). Иначе, lpfn может указывать на подключаемую процедуру в коде, связанном с текущим процессом.
hMod
Идентифицирует динамически подключаемую библиотеку (DLL), содержащую фильтр - процедуру, указанную lpfn параметром. Параметр hMod должен быть установлен в значение ПУСТО (NULL), если параметр dwThreadId определяет поток, созданный текущим процессом и, если подключаемая процедура внутри кода, связанного с текущим процессом.
dwThreadId
Определяет идентификатор потока, с которым подключаемая процедура должна быть связана. Если этот параметр нулевой, фильтр - процедура связана со всеми существующими потоками.

Возвращаемые значения
Если функция завершается успешно, величина возвращаемого значения - дескриптор подключаемой процедуры.
Если функция не выполняет задачу, величина возвращаемого значения ПУСТО (NULL).

Замечания
Если параметр hMod значение ПУСТО (NULL), а параметр dwThreadId нулевой или определяет идентификатор потока, созданного другим процессом, может произойти ошибка.
Формирование цепочки со следующей подключаемой процедурой (то есть вызов функции CallNextHookEx) необязателен. Прикладная программа или библиотека могут вызывать следующую фильтр - процедуру или до или после любой обработки в своей собственной подключаемой процедуре. Хотя сцепление со следующей hook-точкой необязательно, это настоятельно рекомендуется; иначе, другие прикладные программы, которые установили hook-точки, не будут принимать уведомления hook-точки и, в результате, могут повести себя неправильно.
Перед завершением, прикладная программа должна вызвать функцию UnhookWindowsHookEx, чтобы освободить системные ресурсы, связанные с hook-точкой.
Область действия hook-точки зависит от типа hook-точки. Некоторые hook-точки могут быть установлены только с системными возможностями; другие могут также быть установлены только для конкретного потока, как показано в следующем списке:

• WH_CALLWNDPROC - Поток или система
• WH_CBT - Поток или система
• WH_DEBUG - Поток или система
• WH_GETMESSAGE - Поток или система
• WH_JOURNALPLAYBACK - Система только
• WH_JOURNALRECORD - Система только
• WH_KEYBOARD - Поток или система
• WH_MOUSE - Поток или система
• WH_MSGFILTER - Поток или система
• WH_SHELL - Поток или система
• WH_SYSMSGFILTER - Система только

Для заданного типа hook-точки, сначала вызываются hook-точки потока, затем системные hook-точки.
Системные hook-точки являются общедоступным ресурсом, и установка одной воздействует на все прикладные программы. Все системные функции hook-точки должны быть в библиотеках. Системные hook-точки должны быть для узкого круга прикладных программ специального назначения или использоваться как помощь в разработке прикладной программы в ходе отладки. Библиотеки, которые больше не нуждаются в hook-точке, должны удалить подключаемую процедуру.

Смотри также
CallNextHookEx, CallWndProc, CallWndRetProc, CBTProc, DebugProc, GetMsgProc, JournalPlaybackProc, JournalRecordProc, KeyboardProc, MouseProc, MessageProc, ShellProc, SysMsgProc, UnhookWindowsHookEx

Размещение и совместимость SetWindowsHookEx

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека user32.lib 
Заголовочный файл winuser.h 
Unicode WinNT 
Замечания по платформе Не имеется

Функция ShellProc

Подключаемая процедура ShellProc - определяемая программой или определенная библиотекой функция повторного вызова, которую использует оболочка прикладной программы, чтобы принимать полезные уведомления от системы.

LRESULT CALLBACK ShellProc
( 
int nCode, // код hook-точки 
WPARAM wParam, // информация, определяемая событием 
LPARAM lParam // информация, определяемая событием
);

Параметры
nCode
Определяет код hook-точки. Этот параметр может быть одним из следующих значений:

• HSHELL_ACTIVATESHELLWINDOW - Оболочка должна активизировать свое главное окно.
• HSHELL_GETMINRECT - Только для Windows 95: окно свертывается или развертывается, а система нуждается в координатах свернутого (минимизированного) прямоугольника окна. Параметр wParam содержит дескриптор окна, а параметр lParam содержит адрес структуры RECT, которая принимает координаты.
• HSHELL_LANGUAGE - Только для Windows 95: язык клавиатуры был изменен, или была загружена новая раскладка символов на клавиатуре.
• HSHELL_REDRAW - Только для Windows 95: заголовок окна в панели задач был перерисован. Параметр wParam содержит дескриптор окна.
• HSHELL_TASKMAN - Только для Windows 95: пользователь выбрал список задач. Параметр wParam не определен и должен игнорироваться. Оболочка прикладной программы, которая предоставляет список задач, должна возвратить значение ИСТИНА (TRUE), чтобы воспрепятствовать Windows запустить список его задач.
• HSHELL_WINDOWACTIVATED - Только для Windows 95: активизация была заменена в другом, не имеющем владельца, окне верхнего уровня. Параметр wParam содержит дескриптор окна.
• HSHELL_WINDOWCREATED - Было создано не имеющее владельца окно верхнего уровня. Окно существует только тогда, когда система вызывает функцию ShellProc.
• HSHELL_WINDOWDESTROYED - Не имеющее владельца окно верхнего уровня собирается быть разрушенным. Окно все еще существует когда система вызывает функцию ShellProc.

Если nCode - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки, а возвратить должна значение возвращенное CallNextHookEx.
wParam
Определяет дополнительную информацию, которую может потребовать оболочка прикладной программы. Если параметр nCode - HSHELL_ACTIVATESHELLWINDOW, то параметр wParam не используется. Если nCode - HSHELL_WINDOWCREATED или HSHELL_WINDOWDESTROYED, wParam определяет дескриптор создаваемого или разрушаемого окна, соответственно.
lParam
Windows 95:
Определяет дополнительную информацию. Точное значение зависит от значения параметра nCode. Если nCode - HSHELL_GETMINRECT, lParam - LPRECT. Если nCode - HSHELL_WINDOWSACTIVATED, lParam - fFullScreen. Если nCode - HSHELL_REDRAW, lParam - fNewFlash.
Windows NT:
Этот параметр должен быть равен нулю.

Возвращаемые значения
Возвращаемое значение должно быть равно нулю.

Замечания
Прикладная программа устанавливает подключаемую процедуру, путем определения типа hook-точки как WH_SHELL и ее адреса при вызове функции SetWindowsHookEx.
ShellProc - метка - заместитель для определяемого программой или определенного библиотекой имени функции.

Смотри также
CallNextHookEx, SendMessage, SetWindowsHookEx

Размещение и совместимость ShellProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определяется поьзователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция SysMsgProc

Подключаемая процедура SysMsgProc - определяемая библиотекой функция повторного вызова, которую система вызывает после того, как происходит событие ввода в диалоговом окне, окне сообщений меню, или линейке прокрутки, но до того, как сообщение, сгенерированное входящим событием обрабатывается. Фильтр - процедура может контролировать сообщения для любого диалогового окна, окна сообщений, меню или линейки прокрутки в системе.

LRESULT CALLBACK SysMsgProc
( 
int nCode, // флажок сообщения 
WPARAM wParam, // не определен 
LPARAM lParam // адрес структуры с данными сообщения
);

Параметры
nCode
Определяет тип события ввода, которое генерировало сообщение. Этот параметр может быть одним из следующих значений:

• MSGF_DIALOGBOX - Произошло событие ввода в окне сообщений или диалоговом окне.
• MSGF_MENU - Произошло событие ввода в меню.
• MSGF_SCROLLBAR - Произошло событие ввода в линейке прокрутки.
• MSGF_NEXTWINDOW - Произошло событие ввода в результате пользовательского нажатия комбинации клавиш ALT+TAB, чтобы активизировать другое окно.

Если nCode - меньше чем нуль, подключаемая процедура должна передать сообщение в функцию CallNextHookEx без дальнейшей обработки, а возвратить должна значение возвращенное CallNextHookEx.
wParam
Определяет значение ПУСТО (NULL)
lParam
Указывает на структуру MSG сообщения.

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

Замечания
Прикладная программа устанавливает подключаемую процедуру, путем определения типа hook-точки как WH_SYSMSGFILTER и ее адреса при вызове функции SetWindowsHookEx.
SysMsgProc - метка - заместитель для определенного библиотекой имени функции.

Смотри также
CallNextHookEx, MSG, SetWindowsHookEx

Размещение и совместимость SysMsgProc

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека Определяется поьзователем 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе HOOKPROC

Функция UnhookWindowsHookEx

Функция UnhookWindowsHookEx удаляет подключаемую процедуру, установленную в цепочку hook-точек функцией SetWindowsHookEx.

BOOL UnhookWindowsHookEx
( 
HHOOK hhk // дескриптор подключаемой процедуры, которая удаляется
);

Параметры
hhk
Идентифицирует hook-точку, которая будет удалена. Этот параметр - дескриптор hook-точки, полученный предыдущим вызовом к SetWindowsHookEx.

Возвращаемые значения
Если функция завершилась успешно, возвращается значение отличное от нуля.
Если функция потерпела неудачу, возвращаемое значение - ноль.

Замечания
Подключаемая процедура может быть в состоянии, которое вызвано другим потоком, даже после возврата значения функцией UnhookWindowsHookEx. Если одновременно не вызывается фильтр - процедура, она незамедлительно удаляется до возврата значения функцией UnhookWindowsHookEx.

Смотри также
SetWindowsHookEx, UnhookWindowsHook

Размещение и совместимость UnhookWindowsHookEx

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека user32.lib 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется

Функция DefHookProc

Функция DefHookProc устарела. Она предусмотрена только для совместимости с 16-разрядными версиями Windows. Базирующиеся на Win32 прикладные программы должны использовать функцию CallNextHookEx.

Функция SetWindowsHook

Функция SetWindowsHook устаревшая. Эта функция предусмотрена только для совместимости с 16-разрядными версиями Windows. Базирующиеся на Win32 прикладные программы должны использовать функцию SetWindowsHookEx.

Функция UnhookWindowsHook

Функция UnhookWindowsHook устаревшая, но предусмотрена для совместимости с 16-разрядными версиями Windows. Для базирующихся на Win32 прикладных программ, используйте функцию UnhookWindowsHookEx.

Структуры для hook-точек

Ниже перечисленные структуры используются с hook-точками.

Структура CBT_CREATEWND

Структура CBT_CREATEWND содержит информацию, передаваемую в подключаемую процедуру WH_CBT до того, как окно создается.

typedef struct tagCBT_CREATEWND 
 < 
LPCREATESTRUCT lpcs; 
HWND hwndInsertAfter;
> CBT_CREATEWND;

Члены структуры
lpcs
Указывает на структуру CREATESTRUCT, которая содержит параметры инициализации для окна, собирающегося быть созданным.
hwndInsertAfter
Идентифицирует окно, чья позиция в Z-последовательности предшествует позиции такого же создаваемого окна.

Смотри также
CBTProc, CREATESTRUCT, SetWindowsHookEx

Размещение и совместимость CBT_CREATEWND

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека - 
Заголовочный файл winuser.h 
Unicode WinNT 
Замечания по платформе Не имеется

Структура CBTACTIVATESTRUCT

Структура CBTACTIVATESTRUCT содержит информацию, передаваемую в подключаемую процедуру WH_CBT до того, как окно активизировано.

typedef struct tagCBTACTIVATESTRUCT 
 < 
BOOL fMouse; 
HWND hWndActive;
> CBTACTIVATESTRUCT;

Члены структуры
fMouse
Определяет, активизируется ли окно в результате щелчка мыши. Это значение - ИСТИНА (TRUE), если щелчок мыши вынуждает активизацию или ЛОЖЬ(FALSE), если этого - нет.
hWndActive
Идентифицирует активное окно.

Смотри также
SetWindowsHookEx

Размещение и совместимость CBTACTIVATESTRUCT

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека - 
Заголовочный файл winuser.h 
Unicode No 
Замечания по платформе Не имеется

Структура CWPRETSTRUCT

Структура CWPRETSTRUCT определяет параметры сообщения, посылаемые в подключаемую процедуру WH_CALLWNDPROCRET.

typedef struct tagCWPRETSTRUCT 
 < 
LRESULT lResult; 
LPARAM lParam; 
WPARAM wParam; 
DWORD message; 
HWND hwnd;
> CWPRETSTRUCT;

Члены структуры
lResult
Определяет величину возвращаемого значения оконной процедурой, которая обработала сообщение, заданное значением message.
lParam
Определяет дополнительную информацию о сообщении. Точное значение зависит от величины message.
wParam
Определяет дополнительную информацию о сообщении. Точное значение зависит от величины message.
message
Определяет сообщение.
hwnd
Идентифицирует окно, которое обработало сообщение, заданное значением message.

Смотри также
CallWndRetProc, SetWindowsHook, SetWindowsHookEx

Размещение и совместимость CWPRETSTRUCT

Windows NT Да 
Win95 Да 
Win32s Нет 
Импортируемая библиотека - 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется

Структура CWPSTRUCT

Структура CWPSTRUCT определяет параметры сообщения, посылаемые в подключаемую процедуру WH_CALLWNDPROC.

typedef struct tagCWPSTRUCT 
 // cwps 
LPARAM lParam; 
WPARAM wParam; 
UINT message; 
HWND hwnd;
> CWPSTRUCT;

Члены структуры
lParam
Определяет дополнительную информацию о сообщении. Точное предназначение зависит от значения message.
wParam
Определяет дополнительную информацию о сообщении. Точное предназначение зависит от значения message.
message
Определяет сообщение
hwnd
Идентифицирует окно, которое принимает сообщение.

Смотри также
CallWndProc, SetWindowsHook, SetWindowsHookEx

Размещение и совместимость CWPSTRUCT

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека - 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется

Структура DEBUGHOOKINFO

Структура DEBUGHOOKINFO содержит отладочную информацию.

typedef struct tagDEBUGHOOKINFO < 
DWORD idThread; 
DWORD idThreadInstaller; 
LPARAM lParam; 
WPARAM wParam; 
int code;
> DEBUGHOOKINFO;

Члены структуры
idThread
Идентифицирует поток, содержащий функцию фильтра.
idThreadInstaller
Идентифицирует поток, который установил функцию фильтра отладки.
lParam
Определяет значение, которое будет отправлено в hook-точку в параметре lParam функции повторного вызова DebugProc.
wParam
Определяет значение, которое будет отправлено в hook-точку в параметре wParam функции повторного вызова DebugProc
code
Определяет значение, которое будет отправлено в hook-точку в параметре nCode функции повторного вызова DebugProc

Смотри также
DebugProc, SetWindowsHook, SetWindowsHookEx

Размещение и совместимость DEBUGHOOKINFO

Windows NT Да 
Win95 Нет
Win32s Нет
Импортируемая библиотека - 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется

Структура EVENTMSG

Структура EVENTMSG содержит информацию об аппаратном сообщении, отправленном в системную очередь сообщений. Эта структура используется, чтобы сохранить информацию сообщения для функции повторного вызова JournalPlaybackProc.

typedef struct tagEVENTMSG 
 < 
UINT message; 
UINT paramL; 
UINT paramH; 
DWORD time; 
HWND hwnd;
> EVENTMSG;

Члены структуры
message
Определяет сообщение.
paramL
Определяет дополнительную информацию о сообщении. Точное предназначение зависит от значения message.
paramH
Определяет дополнительную информацию о сообщении. Точное предназначение зависит от значения message.
time
Определяет время, в которое сообщение было переслано.
hwnd
Идентифицирует окно, которому сообщение было передано.

Смотри также
JournalPlaybackProc, SetWindowsHookEx

Размещение и совместимость EVENTMSG.

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека - 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется

Структура MOUSEHOOKSTRUCT

Структура MOUSEHOOKSTRUCT содержит информацию о событии нажатия кнопки мыши.

typedef struct tagMOUSEHOOKSTRUCT POINT pt; 
HWND hwnd; 
UINT wHitTestCode; 
DWORD dwExtraInfo;
> MOUSEHOOKSTRUCT;

Члены структуры
pt
Определяет структуру POINT, которая содержит x- и y-координаты курсора, в экранных координатах.
hwnd
Идентифицирует окно, которое примет сообщение мыши, соответствующее событию нажатия кнопки мыши.
wHitTestCode
Определяет значение местоположения курсора. За списком значений местоположения курсора, обратитесь к описанию сообщения WM_NCHITTEST.
dwExtraInfo
Определяет дополнительную информацию, связанную с сообщением.

Смотри также
GetMessageExtraInfo, POINT, SetWindowsHook, SetWindowsHookEx, WM_NCHITTEST

Размещение и совместимость MOUSEHOOKSTRUCT

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека - 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется

Сообщения hook-точек

Следующие сообщения используются с hook-точками.

Сообщение WM_CANCELJOURNAL

Сообщение WM_CANCELJOURNAL посылается прикладной программе, когда пользователь отменяет ведущийся протокол действий прикладной программы. Сообщение посылается с дескриптором окна имеющим значение ПУСТО (NULL).

WM_CANCELJOURNAL
wParam = 0; //не используется, должно быть, нуль
lParam = 0; // не используется, должно быть, нуль 

Параметры
У этого сообщения нет параметров.

Возвращаемые значения
Это сообщение не возвращает значение. Оно, как предполагается, будет обрабатываться внутри главного цикла сообщений прикладной программы или подключаемой процедуры GetMessage, а не оконной процедуры.

Замечания
Режимы записи и воспроизведения протокола - режимы, возложенные на систему, которые позволяют прикладной программе последовательно записывать или воспроизводить ввод пользователя. Система вводит эти режимы тогда, когда прикладная программа устанавливает подключаемую процедуру JournalRecordProc или JournalPlaybackProc. Когда система находится в любом из этих режимов, ведущих протокол, прикладные программы должны делать по очереди чтение вводимых данных из входной очереди. Если какая-либо прикладная программа останавливает чтение вводимой информации, пока система находится в режиме ведения протокола, другие прикладные программы вынуждены ждать.
Чтобы гарантировать устойчивость системы, для любой прикладной программой, которой нельзя зависать, Windows NT автоматически отменяет любые ведущие протокол действия, когда пользователь нажимает CTRL+ESC или CTRL+ALT+DEL.
Система тогда отключает любые фильтр - процедуры ведущие протокол, и посылает сообщение WM_CANCELJOURNAL со значением дескриптора окна ПУСТО (NULL) в прикладную программу, которая установила ведущую протокол hook-точку.
Так как сообщение WM_CANCELJOURNAL имеет дескриптор окна ПУСТО (NULL), оно не может быть послано оконной процедуре. Имеются два способа для прикладной программы, чтобы увидеть сообщение WM_CANCELJOURNAL: Если прикладная программа запускает свой собственный главный цикл сообщений, она должна перехватить сообщение между своим вызовом GetMessage или PeekMessage и своим вызовом DispatchMessage. Если прикладная программа не запускает свой собственный главный цикл сообщений, она должна установить подключаемую процедуру GetMsgProc (через вызов SetWindowsHookEx, определяя тип hook-точки как WH_GetMessage), которая отслеживает это сообщение.
Когда прикладная программа видит сообщение WM_CANCELJOURNAL, она может предположить два обстоятельства: пользователь преднамеренно отменил режим записи или воспроизведения протокола и система уже отключила любую подключаемую процедуру записи или воспроизведения протокола.
Обратите внимание!, что комбинация клавиш, упоминаемая выше (CTRL+ESC или CTRL+ALT+DEL), заставляет систему отменить ведение протокола. Если какая либо из прикладных программ зависает, они дают пользователю средства возвращения управляемости. Виртуальный код клавиши VK_CANCEL (обычно реализованный как комбинация клавиш CTRL+BREAK) - это то, что прикладная программа, которая находится в режиме записи протокола, должна ожидать как сигнал, что пользователь желает отменить ведущее протокол действие. Разницей является то, что наблюдение за VK_CANCEL является предложенным поведением для ведущих протокол прикладных программ, принимая во внимание, что CTRL+ESC или CTRL+ALT+DEL заставляют систему отменить ведение протокола независимо от поведения прикладной программы, ведущей протокол.

Смотри также
DispatchMessage, GetMessage, JournalPlaybackProc, JournalRecordProc, GetMsgProc, PeekMessage, SetWindowsHookEx

Размещение и совместимость WM_CANCELJOURNAL

Windows NT Да 
Win95 Да 
Win32s Нет 
Импортируемая библиотека -
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется

Сообщение WM_QUEUESYNC

Сообщение WM_QUEUESYNC посылается прикладной программой машинной подготовки (CBT), чтобы отделить введенные пользователем сообщения от других сообщений, переданных через подключаемую процедуру WH_JOURNALPLAYBACK.

WM_QUEUESYNC
wParam = 0; //не используется, должно быть, нуль
lParam = 0; // не используется, должно быть, нуль 

Параметры
У этого сообщения нет параметров.

Возвращаемые значения
CBT прикладная программа должна возвратить нуль, если она обрабатывает это сообщение.

Замечания
Всякий раз, когда CBT приложение использует подключаемую процедуру WH_JOURNALPLAYBACK, первое и последнее сообщения - это WM_QUEUESYNC. Это позволяет CBT прикладной программе прерывать и проверять инициализированные пользователем сообщения без прерывания таким же образом событий, которыми оно передается.
Если прикладная программа определяет дескриптор окна ПУСТО (NULL), сообщение пересылается в очередь сообщений активного окна.

Размещение и совместимость WM_QUEUESYNC

Windows NT Да 
Win95 Да 
Win32s Да 
Импортируемая библиотека - 
Заголовочный файл winuser.h 
Unicode Нет 
Замечания по платформе Не имеется