void Dde_Server::Initiate ( HWND Owner, HWND Client, PDDEINIT pDdeInit ) {
/**************************************************************************
* Prepare to respond with a WM_DDE_INITIATEACK. *
**************************************************************************/
HMQ Queue = WinQueryWindowULong ( Owner, QWL_HMQ ) ;
char Text [10] ;
ULONG Size = 10 ;
int Country = 1 ;
if ( PrfQueryProfileData ( HINI_USERPROFILE, PSZ("PM_National"), PSZ("iCountry"), Text, &Size ) )
Country = atoi ( Text ) ;
CONVCONTEXT Conv ;
Conv.cb = sizeof(Conv) ;
Conv.fsContext = DDECTXT_CASESENSITIVE ;
Conv.idCountry = Country ;
Conv.usCodepage = WinQueryCp ( Queue ) ;
Conv.usLangID = 0 ;
Conv.usSubLangID = 0 ;
/**************************************************************************
* Respond if appropriate. *
**************************************************************************/
Application.Initiate ( Owner, Client, pDdeInit, Conv ) ;
}
// For frame windows, 'Show' is equivalent to 'Show & Activate'
nsresult nsFrameWindow::Show( PRBool bState)
{
if( mWnd)
{
ULONG ulFlags;
if( bState) {
ULONG ulStyle = WinQueryWindowULong( GetMainWindow(), QWL_STYLE);
ulFlags = SWP_SHOW;
/* Don't activate the window unless the parent is visible */
if (WinIsWindowVisible(WinQueryWindow(GetMainWindow(), QW_PARENT)))
ulFlags |= SWP_ACTIVATE;
if (!( ulStyle & WS_VISIBLE)) {
PRInt32 sizeMode;
GetSizeMode( &sizeMode);
if ( sizeMode == nsSizeMode_Maximized) {
ulFlags |= SWP_MAXIMIZE;
} else if ( sizeMode == nsSizeMode_Minimized) {
ulFlags |= SWP_MINIMIZE;
} else {
ulFlags |= SWP_RESTORE;
}
}
if( ulStyle & WS_MINIMIZED)
ulFlags |= (SWP_RESTORE | SWP_MAXIMIZE);
}
else
ulFlags = SWP_HIDE | SWP_DEACTIVATE;
WinSetWindowPos( GetMainWindow(), NULLHANDLE, 0L, 0L, 0L, 0L, ulFlags);
SetWindowListVisibility( bState);
}
return NS_OK;
}
nsresult os2FrameWindow::Show(bool aState)
{
uint32_t ulFlags;
if (!aState) {
ulFlags = SWP_HIDE | SWP_DEACTIVATE;
} else {
ulFlags = SWP_SHOW | SWP_ACTIVATE;
uint32_t ulStyle = WinQueryWindowULong(mFrameWnd, QWL_STYLE);
int32_t sizeMode;
mOwner->GetSizeMode(&sizeMode);
if (!(ulStyle & WS_VISIBLE)) {
if (sizeMode == nsSizeMode_Maximized) {
ulFlags |= SWP_MAXIMIZE;
} else if (sizeMode == nsSizeMode_Minimized) {
ulFlags |= SWP_MINIMIZE;
} else {
ulFlags |= SWP_RESTORE;
}
} else if (ulStyle & WS_MINIMIZED) {
if (sizeMode == nsSizeMode_Maximized) {
ulFlags |= SWP_MAXIMIZE;
} else {
ulFlags |= SWP_RESTORE;
}
}
}
WinSetWindowPos(mFrameWnd, 0, 0, 0, 0, 0, ulFlags);
SetWindowListVisibility(aState);
return NS_OK;
}
MRESULT APIENTRY OpenSaveFilterDlgProc(HWND hwnd, USHORT msg,
MPARAM mp1, MPARAM mp2)
{
if(msg == WM_HELP)
{
PFILEDLG pOpenSaveFileDlgStruct;
/*
* Get a pointer to the file dialog structure.
*/
pOpenSaveFileDlgStruct = (PFILEDLG) WinQueryWindowULong(hwnd, QWL_USER);
/*
* If this is an the File Open dialog, display the file open help
* panel.
*/
if (pOpenSaveFileDlgStruct->fl & FDS_OPEN_DIALOG)
{
//DisplayHelpPanel(PANEL_FILEOPEN);
return (MRESULT)FALSE ;
}
/*
* If this is an the File Save or Save As dialog, display the file
* Save As help panel.
*/
if (pOpenSaveFileDlgStruct->fl & FDS_SAVEAS_DIALOG)
{
//DisplayHelpPanel(PANEL_FILESAVEAS);
return (MRESULT)FALSE ;
}
}
return WinDefFileDlgProc( hwnd, msg, mp1, mp2 );
} /* End of OpenSaveFilterDlgProc */
extern MRESULT EXPENTRY ComboBox_Processor ( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) {
static PWINDOWPROC DefaultProcessor = 0 ;
switch ( msg ) {
case WM_CREATE: {
CLASSINFO ClassInfo ;
WinQueryClassInfo ( WinQueryAnchorBlock(hwnd), WC_COMBOBOX, &ClassInfo ) ;
DefaultProcessor = ClassInfo.pfnWindowProc ;
MRESULT Result = DefaultProcessor ( hwnd, msg, mp1, mp2 ) ;
HWND Entryfield = WinWindowFromID ( hwnd, CBID_EDIT ) ;
ULONG Style = WinQueryWindowULong ( hwnd, QWL_STYLE ) ;
if ( Style & CBS_DROPDOWNLIST ) {
OldComboEntry_Processor1 = WinSubclassWindow ( Entryfield, ComboEntry_Processor1 ) ;
} else {
OldComboEntry_Processor2 = WinSubclassWindow ( Entryfield, ComboEntry_Processor2 ) ;
} /* endif */
return ( Result ) ; }
case WM_CONTROL: {
USHORT Id = WinQueryWindowUShort ( hwnd, QWS_ID ) ;
SHORT Control = SHORT1FROMMP ( mp1 ) ;
SHORT Message = SHORT2FROMMP ( mp1 ) ;
switch ( Control ) {
case CBID_EDIT: {
switch ( Message ) {
case EN_SETFOCUS: {
Sys_SendMessage( OWNER(hwnd), WM_CONTROL, MPFROM2SHORT(Id,CBN_SETFOCUS), 0 ) ;
break; }
case EN_KILLFOCUS: {
Sys_SendMessage( OWNER(hwnd), WM_CONTROL, MPFROM2SHORT(Id,CBN_KILLFOCUS), 0 ) ;
break; }
} /* endswitch */
break; }
case CBID_LIST: {
switch ( Message ) {
case LN_SETFOCUS: {
Sys_SendMessage( OWNER(hwnd), WM_CONTROL, MPFROM2SHORT(Id,CBN_SETFOCUS), 0 ) ;
break; }
case LN_KILLFOCUS: {
Sys_SendMessage( OWNER(hwnd), WM_CONTROL, MPFROM2SHORT(Id,CBN_KILLFOCUS), 0 ) ;
break; }
} /* endswitch */
break; }
} /* endswitch */
break; }
case WM_MEASUREITEM:
return ( Sys_SendMessage( OWNER(hwnd), msg, mp1, mp2 ) ) ;
case WM_DRAWITEM:
return ( Sys_SendMessage( OWNER(hwnd), msg, mp1, mp2 ) ) ;
} /* endswitch */
return ( DefaultProcessor ? DefaultProcessor ( hwnd, msg, mp1, mp2 ) : 0 ) ;
}
// Top-level notebook dialog procedure -- for WM_INITDLG, expects mp2 to be a
// pointer to a notebook header structure which defines the notebook
MRESULT EXPENTRY NotebookDlgProc(HWND hDlg, ULONG msg, MPARAM mp1, MPARAM mp2)
{
int nPage;
PNBHDR pNotebookHdr;
if (msg != WM_INITDLG)
pNotebookHdr = (PNBHDR)WinQueryWindowULong(hDlg, QWL_USER);
switch(msg) {
case WM_INITDLG:
pNotebookHdr = (PNBHDR)(PVOIDFROMMP(mp2));
pNotebookHdr->hwndNB = WinWindowFromID(hDlg, pNotebookHdr->ulNotebookID);
// Save upper-level dialog handle for use by page dialog code
pNotebookHdr->hwndNBDlg = hDlg;
// Save header pointer in window data so WM_SIZE code can use it
WinSetWindowULong(hDlg, QWL_USER, (ULONG)pNotebookHdr);
// Create the notebook
if (!CreateNotebook(pNotebookHdr)) {
WinDismissDlg(hDlg, 0);
return 0;
}
// Post a message to open the notebook after initialization is complete
WinPostMsg(hDlg, WM_OPEN_NOTEBOOK, MP0, MP0);
break;
case WM_OPEN_NOTEBOOK:
// Select the first page, and set the notebook size
TurnToFirstPage(pNotebookHdr->hwndNB);
SetNotebookSize(pNotebookHdr);
break;
case WM_CONTROL:
// If user selected a new page, switch to it
if (((ULONG)pNotebookHdr != 0L) && (SHORT1FROMMP(mp1) == pNotebookHdr->ulNotebookID) && (SHORT2FROMMP(mp1) == BKN_PAGESELECTED))
SetNBPage(hDlg, (PPAGESELECTNOTIFY)mp2);
break;
case WM_CLOSE_NOTEBOOK:
// clear the notebook page array dialog handles to show the pages are no longer in use
for (nPage = 0; (nPage < pNotebookHdr->nPages); nPage++)
pNotebookHdr->PageArray[nPage].hwndPageDlg = (HWND)0L;
WinDismissDlg(hDlg, 0);
break;
default:
return WinDefDlgProc(hDlg, msg, mp1, mp2);
}
return 0;
}
// Frame_window - окно рамки.
VOID Diver_CheckWindowFrameDrawingNode( HWND Frame_window )
{
// Посылаем сообщение в очередь.
HMQ Message_queue = WinQueryWindowULong( Frame_window, QWL_HMQ );
WinPostQueueMsg( Message_queue, WM_MARK, (MPARAM) MRK_DRAW_FRAME, (MPARAM) Frame_window );
// Возврат.
return;
}
MRESULT _System DrvMountDrivesDlg( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
if (msg == WM_TIMER && mp1 == (MP)CAM_LVMTMR) {
HEV hev = WinQueryWindowULong( hwnd, QWL_USER);
if (!WinWaitEventSem( hev, 0))
WinSendMsg( hwnd, WM_COMMAND, (MP)CAM_LVMTMR, 0);
return (0);
}
if (msg == WM_COMMAND || msg == WM_SYSCOMMAND) {
ULONG ulChk;
if (!WinStopTimer( 0, hwnd, CAM_LVMTMR))
printf( "DrvMountDrivesDlg - WinStopTimer\n");
ulChk = (ULONG)WinSendDlgItemMsg( hwnd, IDC_AUTOMOUNT,
BM_QUERYCHECK, 0, 0);
DrvSetUseLvm( WinQueryWindow( hwnd, QW_OWNER), ulChk);
WindowClosed( WinQueryWindowUShort( hwnd, QWS_ID));
WinDismissDlg( hwnd, (mp1 == (MP)CAM_LVMTMR));
return (0);
}
if (msg == WM_INITDLG) {
HEV hev = (HEV)mp2;
WinSetWindowULong( hwnd, QWL_USER, hev);
LoadDlgStrings( hwnd, nlsMountDlg);
WinSendDlgItemMsg( hwnd, IDC_AUTOMOUNT, BM_SETCHECK,
(MP)(CAMDRV_IS_NOLVM ? 0 : 1), 0);
ShowDialog( hwnd, 0);
if (!WinWaitEventSem( hev, 0)) {
WindowClosed( WinQueryWindowUShort( hwnd, QWS_ID));
WinDismissDlg( hwnd, TRUE);
}
else
if (!WinStartTimer( 0, hwnd, CAM_LVMTMR, 250))
printf( "DrvMountDrivesDlg - WinStartTimer\n");
return (0);
}
if (msg == WM_FOCUSCHANGE) {
if (SHORT1FROMMP(mp2) && !WinIsWindowEnabled( hwnd)) {
WinPostMsg( WinQueryWindow( hwnd, QW_OWNER),
CAMMSG_FOCUSCHANGE, 0, 0);
return (0);
}
}
return (WinDefDlgProc( hwnd, msg, mp1, mp2));
}
//************************************************************************************************
// "Playlist API"
//************************************************************************************************
void plAddEntry(HWND hWnd, PSZ pszFilename)
{
PSTRINGLIST pFirstNode = (PSTRINGLIST)WinQueryWindowPtr(hWnd, QWP_PLAYLIST);
PSTRINGLIST pList = (PSTRINGLIST)WinQueryWindowPtr(hWnd, QWP_CURRENTENTRY);
ULONG cCount = WinQueryWindowULong(hWnd, QWL_PLAYLISTENTRIES);
if(pFirstNode == NULL)
{
// allocate node and increase nodecounter
pFirstNode = new STRINGLIST;
cCount++;
// link it to itself (ever tried biting your own tail?)
pFirstNode->next = pFirstNode;
pFirstNode->prev = pFirstNode;
// allocate stringbuffer in node and copy string to node
pFirstNode->pszString = new char[strlen(pszFilename)+1];
strcpy(pFirstNode->pszString, pszFilename);
// set some nice pointers
WinSetWindowPtr(hWnd, QWP_PLAYLIST, (PVOID)pFirstNode);
WinSetWindowPtr(hWnd, QWP_CURRENTENTRY, (PVOID)pFirstNode);
WinSetWindowULong(hWnd, QWL_PLAYLISTENTRIES, cCount);
// go no further
return;
}
// allocate the new node & increase the nodecounter
pList->next = new STRINGLIST;
cCount++;
// set the new nodes previous-pointer to the current node (are we confused yet?)
pList->next->prev = pList;
// move to the next node
pList = pList->next;
// allocate stringbuffer in node and copy string to node
pList->pszString = new char[strlen(pszFilename)+1];
strcpy(pList->pszString, pszFilename);
// link it to the first node in the list
pList->next = pFirstNode;
// link the first node's previous-pointer to the current node, since it is the last one (hello?)
pFirstNode->prev = pList;
// finish it all off with a big party!
WinSetWindowPtr(hWnd, QWP_CURRENTENTRY, (PVOID)pList);
WinSetWindowULong(hWnd, QWL_PLAYLISTENTRIES, cCount);
}
nsresult os2FrameWindow::SetSizeMode(int32_t aMode)
{
int32_t previousMode;
mOwner->GetSizeMode(&previousMode);
// save the new state
nsresult rv = mOwner->nsBaseWidget::SetSizeMode(aMode);
if (!NS_SUCCEEDED(rv)) {
return rv;
}
// Minimized windows would get restored involuntarily if we fired an
// NS_ACTIVATE when the user clicks on them. Instead, we defer the
// activation event until the window has explicitly been restored.
if (previousMode == nsSizeMode_Minimized && previousMode != aMode) {
DEBUGFOCUS(deferred NS_ACTIVATE);
ActivateTopLevelWidget();
}
ULONG ulStyle = WinQueryWindowULong(mFrameWnd, QWL_STYLE);
switch (aMode) {
case nsSizeMode_Normal:
if (ulStyle & (WS_MAXIMIZED | WS_MINIMIZED)) {
WinSetWindowPos(mFrameWnd, 0, 0, 0, 0, 0, SWP_RESTORE);
}
break;
case nsSizeMode_Minimized:
if (!(ulStyle & WS_MINIMIZED)) {
WinSetWindowPos(mFrameWnd, HWND_BOTTOM, 0, 0, 0, 0,
SWP_MINIMIZE | SWP_ZORDER | SWP_DEACTIVATE);
}
break;
case nsSizeMode_Maximized:
// Don't permit the window to be maximized when in
// fullscreen mode because it won't be restored correctly.
if (!(ulStyle & WS_MAXIMIZED) && !mChromeHidden) {
WinSetWindowPos(mFrameWnd, HWND_TOP, 0, 0, 0, 0,
SWP_MAXIMIZE | SWP_ZORDER);
}
break;
// 'nsSizeMode_Fullscreen' is defined but isn't used (as of v1.9.3)
case nsSizeMode_Fullscreen:
default:
break;
}
return NS_OK;
}
// Window - окно, Window_is_VIO - что это за окно.
ULONG Krnl_Environment_QueryCodePage( HWND Window, INT Window_is_VIO = -1 )
{
// Узнаем, что это за окно, если требуется.
if( Window_is_VIO == -1 )
{
if( IsVIOWindow( QueryFrameWindow( Window ) ) ) Window_is_VIO = 1;
else Window_is_VIO = 0;
}
// Для текстовых окон возвращаем значение по умолчанию.
if( Window_is_VIO ) return Environment_QuerySystemCodePage();
// Возвращаем страну, которая установлена для окна.
return WinQueryCp( WinQueryWindowULong( Window, QWL_HMQ ) );
}
nsresult os2FrameWindow::HideWindowChrome(bool aShouldHide)
{
// Putting a maximized window into fullscreen mode causes multiple
// problems if it's later minimized & then restored. To avoid them,
// restore maximized windows before putting them in fullscreen mode.
if (WinQueryWindowULong(mFrameWnd, QWL_STYLE) & WS_MAXIMIZED) {
WinSetWindowPos(mFrameWnd, 0, 0, 0, 0, 0, SWP_RESTORE | SWP_NOREDRAW);
}
HWND hParent;
if (aShouldHide) {
hParent = HWND_OBJECT;
mChromeHidden = true;
} else {
hParent = mFrameWnd;
mChromeHidden = false;
}
// Hide or show the frame controls.
WinSetParent(mTitleBar, hParent, FALSE);
WinSetParent(mSysMenu, hParent, FALSE);
WinSetParent(mMinMax, hParent, FALSE);
// Modify the frame style, then advise it of the changes.
if (aShouldHide) {
mSavedStyle = WinQueryWindowULong(mFrameWnd, QWL_STYLE);
WinSetWindowULong(mFrameWnd, QWL_STYLE, mSavedStyle & ~FS_SIZEBORDER);
WinSendMsg(mFrameWnd, WM_UPDATEFRAME, 0, 0);
} else {
WinSetWindowULong(mFrameWnd, QWL_STYLE, mSavedStyle);
WinSendMsg(mFrameWnd, WM_UPDATEFRAME,
MPFROMLONG(FCF_TITLEBAR | FCF_SYSMENU | FCF_MINMAX), 0);
}
return NS_OK;
}
//------------------------
// A main window procedure
//------------------------
static MRESULT EXPENTRY message::MainProc (HWND hwnd, ULONG msg, MPARAM mp1,
MPARAM mp2)
{
HWND hwndtemp;
// Must retrieve the pointer (to all the data members) from the frame since a user pointer
// can't be stored with a client window.
hwndtemp = WinQueryWindow (hwnd, QW_PARENT);
PMESSAGEDATA pmd2;
if (hwndtemp) pmd2 = (PMESSAGEDATA) WinQueryWindowULong (hwndtemp, QWL_USER);
switch (msg)
{
case WM_SIZE:
// Keep the MLE sized to fit the client.
if (pmd2)
{
WinQueryWindowPos (pmd2->hwndClient, (PSWP)&pmd2->swp);
WinSetWindowPos (pmd2->hwndMLE, HWND_TOP, pmd2->swp.x,
pmd2->swp.y, pmd2->swp.cx, pmd2->swp.cy, SWP_SIZE | SWP_MOVE);
}
break;
case WM_SETFOCUS:
// If the message window loses focus, shut it down.
// This will ensure that the function that called it will get a return and
// will have a chance to delete new memory etc.
if (pmd2)
{
if (SHORT1FROMMP (mp2) == 0)
WinSendMsg (hwnd, WM_CLOSE, NULL, NULL);
}
break;
//- case WM_CLOSE:
//- if (pmd2)
//- {
//-
//- }
//- break;
}
return WinDefWindowProc (hwnd, msg, mp1, mp2) ;
}
// Все переменные - внешние.
VOID ApplierKbdInputHook( HAB Application, PQMSG Message, PBYTE Discarding )
{
// Запоминаем значения в окне ввода пароля.
if( Applier.Settings.Script_after_Logon ) if( Applier.RTSettings.Logon_in_process )
{
// Следим за нажатиями на клавиши.
if( Message->msg == WM_CHAR )
{
// Смотрим, какая клавиша нажата.
BYTE Scan_code = CHAR4FROMMP( Message->mp1 );
SHORT State = SHORT1FROMMP( Message->mp1 );
// Если идет отжатие клавиши:
if( State & KC_KEYUP )
{
// Проверяем клавишу.
BYTE Latin_key = 0;
if( Scan_code != 0 )
if( !( State & KC_CTRL ) ) if( !( State & KC_ALT ) )
Latin_key = 1;
// Если это латинская клавиша:
if( Latin_key )
{
// Узнаем окно рамки.
HWND Frame_window = QueryFrameWindow( Message->hwnd );
// Если оно есть в списке отслеживаемых окон:
for( INT Count = APPLIER_MONITORING_LOGON_WINDOWS - 1; Count >= 0; Count -- )
if( Applier.RTDlgMemory.Logon_windows[ Count ].Window == Frame_window )
{
// Посылаем в очередь сообщение WM_MARK. Когда оно будет получено, окно подготовит значение в поле ввода.
HMQ Message_queue = WinQueryWindowULong( Frame_window, QWL_HMQ );
WinPostQueueMsg( Message_queue, WM_MARK, (MPARAM) MRK_LOGON_VALUES, (MPARAM) Frame_window );
break;
}
}
}
}
}
// Возврат.
return;
}
void PlayCompleted(HWND hWnd)
{
PSTRINGLIST pFirst = (PSTRINGLIST)WinQueryWindowPtr(hWnd, QWP_PLAYLIST);
PSTRINGLIST pList = (PSTRINGLIST)WinQueryWindowPtr(hWnd, QWP_CURRENTENTRY);
if((pList->next == pFirst) && (WinQueryWindowULong(hWnd, QWL_LOOP) == 0))
{
WinSendMsg(hWnd, WM_CLOSE, NULL, NULL);
return;
}
pList = pList->next;
WinSetWindowPtr(hWnd, QWP_CURRENTENTRY, pList);
if((BOOL)WinSendMsg(hWnd, WMU_LOAD, NULL, NULL))
{
WinSendMsg(hWnd, WMU_PLAY, NULL, NULL);
}
}
// Все переменные - внешние.
VOID RoomsSendMsgHook( HAB Application, PSMHSTRUCT Message )
{
// Если надо добавить комнаты к рабочему столу:
if( Rooms.Settings.Create_Rooms ) if( !RoomsChangeIsInProcess() )
{
// Если окно рамки становится выбранным:
if( TopFrameWindowIsActivating( Message ) )
{
// Узнаем окно рамки.
HWND Frame_window = QueryFrameWindow( Message->hwnd );
// Запоминаем комнату, в которой располагается окно.
Rooms_SetRoomProperty( Frame_window, GetCurrentOrNextRoom() );
// Делаем окно доступным для переключения.
WinPostQueueMsg( Enhancer.Modules.Changer->Message_queue, SM_SET_JUMPABLE, (MPARAM) Frame_window, (MPARAM) SWL_JUMPABLE );
}
// Если используется оболочка WPS:
if( ShellIsWPS() )
{
// Если окно оболочки скрыто:
if( GetCurrentOrNextRoom() != SHELL_ROOM )
{
// Если оно возвращается в обычное состояние или становится выбранным - надо спрятать его.
if( TopFrameWindowIsMoving( Message ) || TopFrameWindowIsActivating( Message ) )
{
// Узнаем окно рамки.
HWND Frame_window = QueryFrameWindow( Message->hwnd );
// Если это окно WPS - посылаем в очередь сообщение WM_MARK. Когда оно будет получено, окно можно будет проверить.
if( IsFolderWindow( Frame_window ) )
{
HMQ Message_queue = WinQueryWindowULong( Frame_window, QWL_HMQ );
WinPostQueueMsg( Message_queue, WM_MARK, (MPARAM) MRK_CHECK_WINDOW, (MPARAM) Frame_window );
}
}
}
}
}
// Возврат.
return;
}
// Frame_window - окно рамки. Возвращаемое значение - вид рамки.
LONG WindowTypes_FrameType( HWND Frame_window )
{
// Узнаем, как выглядит рамка окна.
ULONG Frame_style = WinQueryWindowULong( Frame_window, QWL_STYLE );
// Если окно имеет обычную рамку - возвращаем значение.
if( Frame_style & FS_SIZEBORDER ) return FT_NORMAL;
// Если это окно постоянного размера или плоское окно - смотрим, есть ли у него заголовок.
if( Frame_style & FS_DLGBORDER )
{
// Узнаем окно заголовка.
HWND TitleBar_window = WinWindowFromID( Frame_window, FID_TITLEBAR );
// Если окна заголовка нет - это плоское окно.
if( TitleBar_window == NULLHANDLE ) return FT_FLAT;
// Если окно заголовка не показано:
if( !WindowTypes_WindowIsPresent( TitleBar_window ) )
{
// Узнаем расположение окна рамки и его состояние.
SWP Window_state = {0}; WinQueryWindowPos( Frame_window, &Window_state );
// Если окно не скрыто и не уменьшено в значок - это плоское окно.
if( !( Window_state.fl & SWP_HIDE ) )
if( !( Window_state.fl & SWP_MINIMIZE ) )
return FT_FLAT;
}
// Иначе - это окно постоянного размера.
return FT_CONST;
}
// Окно может иметь рамку в 1 точку.
if( Frame_style & FS_BORDER ) return FT_POINT;
// У него может быть только заголовок.
if( WinWindowFromID( Frame_window, FID_TITLEBAR ) != NULLHANDLE ) return FT_NOFRAME;
// В другом случае считаем, что рамка не нарисована.
return FT_RECT;
}
// Window - окно, для которого надо отключить заставку.
VOID Patcher_DisableAnimation( HWND Window )
{
// Если окно неизвестно - возврат.
if( Window == NULLHANDLE ) return;
// Узнаем свойства окна.
ULONG Window_style = WinQueryWindowULong( Window, QWL_STYLE );
// Если заставка отключена - возврат.
if( !( Window_style & WS_ANIMATE ) ) return;
// Отключаем заставку.
Window_style = Window_style & ~WS_ANIMATE;
// Устанавливаем свойства рамки окна.
WinSetWindowULong( Window, QWL_STYLE, Window_style );
// Возврат.
return;
}
/**********************************************************************
* Function: SrcSelDlgProc
* Info : dialog event handler for source file selection
* Result : TRUE or FALSE
**********************************************************************/
MRESULT EXPENTRY SrcSelDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
static PFILEDLG pFileDlg;
MRESULT rc = FALSE;
USHORT Val;
switch (msg)
{
case WM_INITDLG:
CenterWindow(hwnd);
/* Get pointer to FILEDLG structure */
pFileDlg = (PFILEDLG) WinQueryWindowULong(hwnd, QWL_USER);
break;
case WM_HELP:
DisplayHelp(IDL_SRCFILE_HELP);
break;
case WM_COMMAND:
switch(Val = SHORT1FROMMP(mp1))
{
case DID_APPLY_PB:
if (NO_ERROR == CopyClipBoardData2TempFile())
{
pFileDlg->lReturn = DID_APPLY_PB;
WinDismissDlg(hwnd, TRUE);
return (MRESULT) TRUE;
}
break;
}
/* fall through for appropriate DID_OK handling by default windows proc! */
default:
rc = WinDefFileDlgProc (hwnd, msg, mp1, mp2);
}
return rc;
}
MRESULT EXPENTRY wndFrameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
HWND hwndClient = WinQueryWindow( hwnd, QW_BOTTOM );
PGROPDATA pGrop = (PGROPDATA)WinQueryWindowULong( hwndClient, 0 );
switch( msg )
{
case WM_ADJUSTFRAMEPOS:
if ( !pGrop->fInternalResize && !pGrop->pVideoSys->fFreeWinSize &&
( (pGrop->stUserMode.ulFlags & GROP_MODEFL_RESIZABLE) == 0 ) &&
( (((PSWP)mp1)->fl & (SWP_SIZE | SWP_MINIMIZE)) == SWP_SIZE ) )
{
RECTL rectl;
rectl.xLeft = 0;
rectl.yBottom = 0;
rectl.xRight = pGrop->stUserMode.ulWidth;
rectl.yTop = pGrop->stUserMode.ulHeight;
WinCalcFrameRect( hwnd, &rectl, FALSE );
((PSWP)mp1)->cx = rectl.xRight - rectl.xLeft;
((PSWP)mp1)->cy = rectl.yTop - rectl.yBottom;
}
break;
case WM_MINMAXFRAME:
if ( (((PSWP)mp1)->fl & SWP_MINIMIZE) != 0 )
// To avoid call GROPCALLBACK.fnSize() on window minimization...
pGrop->lSkipWinResize++;
if ( ( (((PSWP)mp1)->fl & SWP_MAXIMIZE) != 0 ) && !pGrop->fInternalResize &&
!pGrop->pVideoSys->fFreeWinSize &&
( (pGrop->stUserMode.ulFlags & GROP_MODEFL_RESIZABLE) == 0 ) )
((PSWP)mp1)->fl &= ~(SWP_MAXIMIZE | SWP_MOVE);
break;
}
return pGrop->fnOldFrameWinProc( hwnd, msg, mp1, mp2 );
}
MRESULT EXPENTRY WndProc( HWND hWnd,ULONG iMessage,
MPARAM mParam1, MPARAM mParam2)
{
Window *pWindow = (Window *)WinQueryWindowULong(hWnd,0);
MRESULT res;
if (pWindow == 0) {
if (iMessage == WM_CREATE) {
pWindow = (Window *)Application::tempthis;
WinSetWindowULong(hWnd,0,(ULONG)pWindow);
res = pWindow->wndProc(hWnd,iMessage,mParam1,mParam2);
} else
return WinDefWindowProc(hWnd,iMessage,mParam1,mParam2);
} else
res = pWindow->wndProc(hWnd,iMessage,mParam1,mParam2);
if( pWindow != 0 && pWindow->killMe )
{
WinSetWindowULong(hWnd,0,(ULONG)0L);
delete pWindow;
}
return res;
}
nsresult os2FrameWindow::SetSizeMode(PRInt32 aMode)
{
PRInt32 previousMode;
mOwner->GetSizeMode(&previousMode);
// save the new state
nsresult rv = mOwner->nsBaseWidget::SetSizeMode(aMode);
// Minimized windows would get restored involuntarily if we fired an
// NS_ACTIVATE when the user clicks on them. Instead, we defer the
// activation event until the window has explicitly been restored.
if (previousMode == nsSizeMode_Minimized && previousMode != aMode) {
DEBUGFOCUS(deferred NS_ACTIVATE);
ActivateTopLevelWidget();
}
// nothing to do in these cases
if (!NS_SUCCEEDED(rv) || !mChromeHidden || aMode == nsSizeMode_Maximized) {
return rv;
}
ULONG ulStyle = WinQueryWindowULong(mFrameWnd, QWL_STYLE);
// act on the request if the frame isn't already in the requested state
if (aMode == nsSizeMode_Minimized) {
if (!(ulStyle & WS_MINIMIZED)) {
WinSetWindowPos(mFrameWnd, HWND_BOTTOM, 0, 0, 0, 0,
SWP_MINIMIZE | SWP_ZORDER | SWP_DEACTIVATE);
}
} else
if (ulStyle & (WS_MAXIMIZED | WS_MINIMIZED)) {
WinSetWindowPos(mFrameWnd, 0, 0, 0, 0, 0, SWP_RESTORE);
}
return NS_OK;
}
static MRESULT EXPENTRY newLaunchPadButtonProc(HWND hwnd, ULONG msg,MPARAM mp1,MPARAM mp2 )
{
POINTL ptl;
HWND hwndMenu;
WPObject * wpObject;
LPObject* lpo;
PDRAGINFO pDragInfo;
static BOOL bDrawn=FALSE;
static DRAGITEM DragItem;
static DRAGIMAGE DragImage;
static DRAGINFO *DragInfo;
switch (msg)
{
case WM_PAINT:
lpo=(LPObject*)WinQueryWindowULong(hwnd,QWL_USER);
if(lpo) {
BTNCDATA btCtrl={0};
WNDPARAMS wndParams={0};
// memset(&btCtrl,0,sizeof(btCtrl));
btCtrl.cb=sizeof(btCtrl);
if(somIsObj(lpo->wpObject)) {
btCtrl.hImage=lpo->wpObject->wpQueryIcon();
// memset(&wndParams,0,sizeof(wndParams));
wndParams.fsStatus=WPM_CTLDATA;
wndParams.cbCtlData=btCtrl.cb;
wndParams.pCtlData=&btCtrl;
WinSendMsg(hwnd,WM_SETWINDOWPARAMS,
MPFROMP(&wndParams),0);
}
}
break;
case WM_CONTEXTMENU:
if(!SHORT2FROMMP(mp2)) {
lpo=(LPObject*)WinQueryWindowULong(hwnd,QWL_USER);
if(lpo) {
wpObject=lpo->wpObject;
if(somIsObj(wpObject)) {
ptl.y=0;
ptl.x=0;
hwndMenu=wpObject->wpDisplayMenu(hwnd,hwnd,&ptl,MENU_OBJECTPOPUP,0);
}
return (MRESULT) TRUE;
}
}/* end of if(!SHORT2FROMMP(mp2)) */
break;
case DM_DRAGOVER:
{
BOOL bReturn=FALSE;
TRY_LOUD(LP_DRAGOVER) {
lpo=(LPObject*)WinQueryWindowULong(hwnd,QWL_USER);
if(lpo) {
wpObject=lpo->wpObject;
if(somIsObj(wpObject)) {
char chrClassName[10];
LONG lLength;
pDragInfo=(PDRAGINFO) mp1;
hwndMenu=pDragInfo->hwndSource;
lLength=sizeof(chrClassName);
WinQueryClassName(hwndMenu, lLength, chrClassName);
if(strcmp(chrClassName,"#37"))
hwndMenu=NULL;/* Source isn't a container */
if(!bDrawn) {
HPS hps;
RECTL rectl;
SWP swp;
/* Draw the rect */
hps=DrgGetPS(hwnd);
WinQueryWindowPos(hwnd,&swp);
rectl.xLeft=1;
rectl.yBottom=1;
rectl.xRight=swp.cx-1;
rectl.yTop=swp.cy-1;
//WinDrawBorder(hps,&rectl, 3, 3, 0, 0, DB_STANDARD|DB_PATINVERT);
DrgReleasePS(hps);
//bDrawn=TRUE;
}
bReturn=TRUE;
}
}
}
CATCH(LP_DRAGOVER)
{
} END_CATCH;
if(bReturn)
return wpObject->wpDragOver(hwndMenu,(PDRAGINFO) mp1);
break;
}
case DM_DRAGLEAVE:
{
RECTL rectl;
SWP swp;
HPS hps;
/* Remove target emphasis here */
hps=DrgGetPS(hwnd);
WinQueryWindowPos(hwnd,&swp);
rectl.xLeft=1;
rectl.yBottom=1;
rectl.xRight=swp.cx-1;
rectl.yTop=swp.cy-1;
// WinDrawBorder(hps,&rectl,3, 3, 0, 0, DB_STANDARD|DB_PATINVERT);
bDrawn=FALSE;
DrgReleasePS(hps);
return (MRESULT) FALSE;
}
case DM_DROP:
{
BOOL bReturn=FALSE;
char chrClassName[10];
LONG lLength;
PDRAGITEM pDragItem;
TRY_LOUD(LP_DROP) {
/* A drop on a toolbar button */
lpo=(LPObject*)WinQueryWindowULong(hwnd,QWL_USER);
if(lpo) {
wpObject=lpo->wpObject;
if(somIsObj(wpObject)) {
pDragInfo=(PDRAGINFO) mp1;
pDragItem=DrgQueryDragitemPtr(pDragInfo, 0);
hwndMenu=pDragInfo->hwndSource;
lLength=sizeof(chrClassName);
WinQueryClassName(hwndMenu, lLength, chrClassName);
if(strcmp(chrClassName,"#37"))
hwndMenu=NULL;/* Source isn't a container */
bReturn=TRUE;
}
}
}
CATCH(LP_DROP)
{
} END_CATCH;
if(bReturn)
return wpObject->wpDrop(hwndMenu,(PDRAGINFO) mp1, pDragItem);
break;
}
case WM_COMMAND:
TRY_LOUD(LP_COMMAND) {
lpo=(LPObject*)WinQueryWindowULong(hwnd,QWL_USER);
if(lpo) {
wpObject=lpo->wpObject;
if(somIsObj(wpObject)) {
if((SHORT)0x6d==SHORT1FROMMP(mp1)) {
/* Delete menu item */
if(wpObject->wpDelete(CONFIRM_DELETE|CONFIRM_DELETEFOLDER ) == OK_DELETE)
lpo->lpParent->lpRemoveButton(lpo);
}
else
wpObject->wpMenuItemSelected(NULL, SHORT1FROMMP(mp1));
}/* end of if(somIsObj(wpObject)) */
}
}
CATCH(LP_COMMAND)
{
} END_CATCH;
return (MRESULT) FALSE;
default:
break;
}
// call the standard flyover button procedure to handle the rest of the messages
return (newButtonProc)(hwnd,msg,mp1,mp2);
};
static MRESULT EXPENTRY launchPadWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
WPFolder* thisPtr;
launchPad * lp;
LPObject *lpo;
static USHORT id=0;//Initialisation new in V1.00a
switch(msg)
{
#if 0
case DM_ENDCONVERSATION:
case DM_DRAGFILECOMPLETE:
case DM_DROPNOTIFY:
case DM_FILERENDERED:
case DM_RENDERCOMPLETE:
break;
return (MRESULT)FALSE;
case WM_ENDDRAG:
break;
return (MRESULT)TRUE;
#endif
case WM_PAINT:
{
RECTL rcl;
launchPad * lp;
HPS hps=WinBeginPaint(hwnd,NULLHANDLE, &rcl);
WinFillRect(hps, &rcl, SYSCLR_DIALOGBACKGROUND);
lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER);
if(lp) {
if(lp->lpQueryNumObjects()==0) {
WinQueryWindowRect(hwnd,&rcl);
WinDrawBorder(hps,&rcl,1,1,SYSCLR_WINDOWFRAME,SYSCLR_DIALOGBACKGROUND, DB_STANDARD);
}
}
WinEndPaint(hps);
return (MRESULT) 0;
}
case DM_DRAGOVER:
return handleDragOver(hwnd, mp1, mp2);
case DM_DROP:
{
ULONG ulCount;
ULONG ulNumberOfObjects;
PDRAGITEM pDragItem;
SOMClass *folderClass;
WPObject * wpObject;
PDRAGINFO pDragInfo;
TRY_LOUD(LP_FRAMEDROP) {
/* A new object dropped on the launchpad */
pDragInfo=(PDRAGINFO)mp1;
if(DrgAccessDraginfo(pDragInfo)) {
/* Get number of items */
ulNumberOfObjects = DrgQueryDragitemCount( pDragInfo);
if(ulNumberOfObjects>1){
/* Free the draginfo */
DrgDeleteDraginfoStrHandles(pDragInfo);
DrgFreeDraginfo(pDragInfo);
}
else {
ulCount=0;
pDragItem=DrgQueryDragitemPtr( pDragInfo, ulCount);
wpObject=(WPObject*)OBJECT_FROM_PREC(DrgQueryDragitemPtr( pDragInfo, ulCount)->ulItemID);
lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER);
if(lp) {
if(somIsObj(wpObject)) {
POINTL ptl;
int numB;
SWP swp;
WinQueryWindowPos(hwnd,&swp);
ptl.x=pDragInfo->xDrop;
ptl.y=pDragInfo->yDrop;
/* Pos in window coords */
WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1);
numB=(ptl.x-xButtonOffset)/(swp.cy+xButtonDelta);
numB=((ptl.x-numB*swp.cy) > swp.cy/2 ? numB+1: numB);
/* Do a link */
lp->lpAddButton(wpObject, numB);
handleDragLeave(hwnd, mp1, mp2);
}
}
DrgDeleteDraginfoStrHandles(pDragInfo);
DrgFreeDraginfo(pDragInfo);
}
}
handleDragLeave(hwnd, mp1, mp2);
}
CATCH(LP_FRAMEDROP)
{
} END_CATCH;
break;
}
case DM_DRAGLEAVE:
return handleDragLeave(hwnd, mp1, mp2);
break;
case WM_COMMAND:
if(SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON) {
/* It's a push button */
lpo=(LPObject*)WinQueryWindowULong(WinWindowFromID(hwnd,SHORT1FROMMP(mp1)),QWL_USER);
if(lpo) {
if(somIsObj(lpo->wpObject))
lpo->wpObject->wpViewObject(NULLHANDLE, OPEN_DEFAULT,0);
}
}
return (MRESULT)FALSE;
/***********************************************/
/* Stuff for fly over help */
case WM_MOUSEMOVE:
launchPad * lp;
lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER);
if(lp) {
if(lp->lpQueryNumObjects()!=0) {
break;
}
}
#if 0
tempID=WinQueryWindowUShort(hwnd,QWS_ID);/* get the id of the window under the pointer */
if(id!=tempID) { // New Button?
WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,tempID,(ULONG)iTBFlyOverDelay); // New timer for delay
id=tempID; // Save ID
}
else {
if(!hwndBubbleWindow)
WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,tempID,(ULONG)iTBFlyOverDelay); // New timer for delay
}
#endif
if(!hwndBubbleWindow)
WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, 2,(ULONG)iTBFlyOverDelay); // New timer for delay
break;
case WM_DESTROY:
WinStopTimer(WinQueryAnchorBlock(hwnd),hwnd,1);//Stop timer if running
if(hwndBubbleWindow)
WinDestroyWindow(hwndBubbleWindow);/* close the bubblewindow */
hwndBubbleWindow=0;
/* Stop delay timer if running */
WinStopTimer(WinQueryAnchorBlock(hwnd),hwnd, 2);
break;
case WM_NEWBUBBLE:
ULONG bubbleEnabled;
HWND hwndStore;
POINTL ptl;
RECTL rclWork;
LONG ulWinTextLen;
POINTL aptlPoints[TXTBOX_COUNT];
LONG deltaX,deltaY;
HPS hps;
RECTL rcl;
/* we have to build a new information window */
if(hwndBubbleWindow){// if(){...} new in V1.00a
WinDestroyWindow(hwndBubbleWindow);/* close the bubblewindow */
hwndBubbleWindow=NULL;
}
// Query the pointer position
WinQueryPointerPos(HWND_DESKTOP,&ptl);
WinMapWindowPoints(HWND_DESKTOP,hwnd,&ptl,1);
WinQueryWindowRect(hwnd,&rclWork);
if(!hwndBubbleWindow
&& WinPtInRect(WinQueryAnchorBlock(hwnd),&rclWork,&ptl)
&& bTBFlyOverEnabled) {
static HWND hwndBubbleClient;
ULONG style=FCF_BORDER|FCF_NOBYTEALIGN;
char winText[255];
/* Get window text for size calculating */
lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER);
if(lp) {
strncpy(winText, lp->lpQueryFlyOverText(), sizeof(winText));
winText[sizeof(winText)-1]=0;
}
ulWinTextLen=(LONG)strlen(winText); // Query text length
/* Delete 'Returns' in object title */
char *pBuchst;
char *pRest;
pRest=winText;
while((pBuchst=strchr(pRest,13))!=NULL) {
*pBuchst=' ';
pBuchst++;
if(*pBuchst==10)
*pBuchst=' ';
pRest=pBuchst;
}
/* Create help window */
hwndBubbleWindow=WinCreateStdWindow(HWND_DESKTOP,
0,
&style,
WC_STATIC,
"",
SS_TEXT|DT_CENTER|DT_VCENTER,
NULLHANDLE,
400,
&hwndBubbleClient);
hwndShadow=WinCreateWindow(HWND_DESKTOP,
WC_STATIC,
"",
SS_TEXT|DT_CENTER|DT_VCENTER,
0, 0,
0, 0,
hwndBubbleWindow,
hwndBubbleWindow,
401,
NULLHANDLE,
NULLHANDLE);
oldProc=WinSubclassWindow(hwndShadow, shadowProc);
// Set the font for the help
WinSetPresParam(hwndBubbleClient,PP_FONTNAMESIZE,
sizeof(chrTBFlyFontName),
chrTBFlyFontName);
/* Calculate text size in pixel */
hps=WinBeginPaint(hwndBubbleClient,(HPS)NULL,(PRECTL)NULL);
GpiQueryTextBox(hps,ulWinTextLen,winText,TXTBOX_COUNT,aptlPoints);
WinEndPaint(hps);
/* Set colors */
WinSetPresParam(hwndBubbleClient,
PP_BACKGROUNDCOLOR,sizeof(rgbTBFlyBackground) ,
&rgbTBFlyBackground );
WinSetPresParam(hwndBubbleClient,
PP_FOREGROUNDCOLOR,sizeof(rgbTBFlyForeground) ,
&rgbTBFlyForeground );
/* Calculate bubble positon and show bubble */
WinQueryPointerPos(HWND_DESKTOP,&ptl);//Query pointer position in the desktop window
WinQueryWindowRect(HWND_DESKTOP,&rcl);//Query desktop size
aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x+7+xVal+ptl.x
> rcl.xRight
? deltaX=-aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x-xVal-xVal-7
: deltaX=0 ;
aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y+2+yVal+ptl.y
> rcl.yTop
? deltaY=-aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y-2*yVal-7
: deltaY=0 ;
WinSetWindowPos(hwndBubbleWindow,
HWND_TOP,
ptl.x+xVal+deltaX,ptl.y+yVal+deltaY,
aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x+8,
aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y+2,
SWP_ZORDER|SWP_SIZE|SWP_MOVE|SWP_SHOW);
WinSetWindowPos(hwndShadow,
hwndBubbleWindow,
ptl.x+xVal+deltaX+5
,ptl.y+yVal+deltaY-5,
aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x+8,
aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y+2,
SWP_ZORDER|SWP_SIZE|SWP_MOVE|SWP_SHOW);
/* Set bubble text */
WinSetWindowText(hwndBubbleClient,winText);
WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,1,35);
} // end if(!hwndBubbleWindow)
break;
case WM_TIMER:
switch (SHORT1FROMMP(mp1))
{
case 1: //Intervall timer
{
POINTL ptl;
RECTL rclWork;
/* Test pointer position */
WinQueryPointerPos(HWND_DESKTOP, &ptl);
WinMapWindowPoints(HWND_DESKTOP, hwnd,&ptl, 1);
WinQueryWindowRect(hwnd, &rclWork);
if(!WinPtInRect(WinQueryAnchorBlock(hwnd),&rclWork,&ptl))
{ // Window has changed
WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, 1); // stop the running timer
if(hwndBubbleWindow)
WinDestroyWindow(hwndBubbleWindow);/* close the bubblewindow */
hwndBubbleWindow=0;
id=0;
}
break;
}
case 2:// delay over
{//our own timer.
POINTL ptl;
RECTL rclWork;
WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, 2);//Stop the delay timer
/* Check the pointer position */
WinQueryPointerPos(HWND_DESKTOP,&ptl);
WinMapWindowPoints(HWND_DESKTOP,hwnd,&ptl,1);
WinQueryWindowRect(hwnd,&rclWork);
if(WinPtInRect(WinQueryAnchorBlock(hwnd),&rclWork,&ptl))
WinPostMsg(hwnd,WM_NEWBUBBLE,NULL,NULL);//Request a help window
return (MRESULT)FALSE;
}
default:
break;
}
break;
default:
break;
}
return pfnwpOldLPProc(hwnd, msg, mp1, mp2);
}
static MRESULT handleDragOver(HWND hwnd, MPARAM mp1, MPARAM mp2)
{
MRESULT mResult;
ULONG ulNumberOfObjects;
PDRAGINFO pDragInfo;
HPS hps;
RECTL rectl;
SWP swp;
mResult = MRFROM2SHORT( DOR_NODROPOP, DO_LINK);
/* Get access to the dragInfo */
pDragInfo=(PDRAGINFO)mp1;
DrgAccessDraginfo(pDragInfo);
/* Get number of items */
ulNumberOfObjects = DrgQueryDragitemCount( pDragInfo);
if(ulNumberOfObjects>1) {
/* Free the draginfo */
DrgFreeDraginfo(pDragInfo);
return MRFROM2SHORT( DOR_NODROPOP, DO_LINK);
}
switch(pDragInfo->usOperation)
{
case DO_DEFAULT:
case DO_LINK:
if(!bDrawn) {
POINTL ptl;
launchPad * lp;
ptl.x=SHORT1FROMMP(mp2);
ptl.y=SHORT2FROMMP(mp2);
/* Pos in window coords */
WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1);
hps=DrgGetPS(hwnd);
WinQueryWindowPos(hwnd,&swp);
rectl.xLeft=swp.cx;//-swp.cy;
lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER);
if(lp) {
if(lp->lpQueryNumObjects()==0) {
rectl.xLeft=0;
}
}
rectl.yTop=swp.cy-1;
rectl.yBottom=1;
if(ptl.x<rectl.xLeft) {
int numB;
numB=(ptl.x-xButtonOffset)/(swp.cy+xButtonDelta);
rectl.xLeft=((ptl.x-numB*swp.cy) > swp.cy/2 ? numB+1: numB);
rectl.xLeft*=(swp.cy+xButtonDelta);
rectl.xLeft-=(xButtonDelta)-xButtonOffset+xButtonDelta;
rectl.xRight=rectl.xLeft+(xButtonDelta*2);
}
else {
rectl.xRight=swp.cx-1;
}
rclDrawn=rectl;
WinDrawBorder(hps,&rectl, 2, 2, 0, 0, DB_STANDARD|DB_PATINVERT);
bDrawn=TRUE;
DrgReleasePS(hps);
}
mResult = MRFROM2SHORT( DOR_DROP, DO_LINK);
break;
default:
break;
}
/* Free the draginfo */
DrgFreeDraginfo(pDragInfo);
return mResult;
}
BOOL launchPad::lpFillPad()
{
HOBJECT hObject;
char chrSetup[CCHMAXPATH];
WPFolder* wpFolder;
LPObject *lpoTemp;
SWP swp;
HWND hwndTemp;
BTNCDATA btCtrl;
WNDPARAMS wndParams;
ULONG ulStyle;
int a;
LONG lXSize;
HENUM hEnum;
HWND hwndClient;
LONG lCxSave;
/* Remove Buttons from pad */
lpClearPad();
/* Resize the pad for all objects */
if(!WinQueryWindowPos(hwndLaunchPad, &swp))
return FALSE;
lCxSave=swp.cx;
lXSize=(ulNumObjects == 0 ? swp.cy : (ulNumObjects) * (swp.cy+xButtonDelta) +2*xButtonOffset);
lpSetLaunchPadPos( NULLHANDLE,0,0, lXSize , swp.cy, SWP_SIZE);
/* Move all controls on the right */
/* Move all client windows so they keep their distance to the left border */
hEnum=WinBeginEnumWindows(WinQueryWindow(hwndLaunchPad,QW_PARENT));
while((hwndClient=WinGetNextWindow(hEnum))!=NULLHANDLE) {
SWP swpClient;
WinQueryWindowPos(hwndClient,&swpClient);
if(swpClient.x > swp.x)
WinSetWindowPos(hwndClient, NULLHANDLE, swpClient.x+(lXSize-lCxSave), swpClient.y, 0, 0, SWP_MOVE);
}/* while */
WinEndEnumWindows(hEnum);
lpoTemp=lpoObjectList;
for(a=ulNumObjects;a>0 && lpoTemp; a--)
{
/* Create Buttons */
if((hwndTemp=WinCreateWindow(hwndLaunchPad, WC_BUTTON, lpoTemp->chrName, WS_VISIBLE, xButtonOffset+(a-1)*(swp.cy+xButtonDelta), 1, swp.cy-2, swp.cy-2,
hwndLaunchPad, HWND_TOP, a*100,
NULLHANDLE, NULLHANDLE))!=NULLHANDLE)
{
/* Change Style to mini icon */
ulStyle=WinQueryWindowULong(hwndTemp,QWL_STYLE);
ulStyle|=(BS_MINIICON);
ulStyle&=~BS_TEXT;
if(WinSetWindowULong(hwndTemp,QWL_STYLE,ulStyle)) {
memset(&btCtrl,0,sizeof(btCtrl));
btCtrl.cb=sizeof(btCtrl);
btCtrl.hImage=lpoTemp->hPtr;
memset(&wndParams,0,sizeof(wndParams));
wndParams.fsStatus=WPM_CTLDATA;
wndParams.cbCtlData=btCtrl.cb;
wndParams.pCtlData=&btCtrl;
WinSendMsg(hwndTemp,WM_SETWINDOWPARAMS,
MPFROMP(&wndParams),0);
/* Subclass button for flyover help */
oldButtonProc2=WinSubclassWindow(hwndTemp, newLaunchPadButtonProc);
/* Set the class pointer into the window words */
WinSetWindowULong(hwndTemp,QWL_USER,(ULONG)lpoTemp);//Save object ptr.
}
}
lpoTemp=lpoTemp->lpoNext;
}
return TRUE;
}
/*---------------------------------------------------
* Process dialog messages
*--------------------------------------------------*/
MRESULT _System KLSetupHKeys::dlg_proc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
{
switch ( msg )
{
case WM_INITDLG:
{
KLSetupHKeys* instance = (KLSetupHKeys*)mp2;
SET_TEXT( hwnd, ID_KEY_TEXT, MSG_KEYPROMPT );
KLApp::do_warpsans( hwnd, ID_KEY_TEXT );
WinSetWindowULong( hwnd, QWL_USER, (ULONG)instance );
instance->hk_exclude = hkey_exclude( hwnd );
break;
}
case WM_DESTROY:
{
KLSetupHKeys* instance = (KLSetupHKeys*)WinQueryWindowULong( hwnd, QWL_USER );
hkey_exclude( instance->hk_exclude );
instance->hk_exclude = NULLHANDLE;
}
case WM_COMMAND:
if( SHORT1FROMMP(mp1) == DID_CANCEL )
WinDismissDlg( hwnd, FALSE );
return MRFROMLONG(TRUE);
case WM_CLOSE:
WinDismissDlg( hwnd, FALSE );
return MRFROMLONG(TRUE);
case WM_CHAR:
if( !( CHARMSG(&msg)->fs & KC_KEYUP )
&& CHARMSG(&msg)->vkey != VK_NUMLOCK
&& CHARMSG(&msg)->vkey != VK_ESC
&& CHARMSG(&msg)->vkey != VK_PRINTSCRN
&& CHARMSG(&msg)->vkey != VK_PAUSE
&& CHARMSG(&msg)->vkey != VK_SHIFT
&& CHARMSG(&msg)->vkey != VK_CTRL
&& CHARMSG(&msg)->vkey != VK_ALT
&& CHARMSG(&msg)->vkey != VK_CAPSLOCK
&& CHARMSG(&msg)->vkey != VK_SCRLLOCK
&& CHARMSG(&msg)->scancode
)
{
KLSetupHKeys* instance = (KLSetupHKeys*)WinQueryWindowULong( hwnd, QWL_USER );
if( instance )
{
instance->hk_state = 0;
instance->hk_scancode = CHARMSG(&msg)->scancode;
if( CHARMSG(&msg)->fs & KC_CTRL ) instance->hk_state |= KLHotkey::control;
if( CHARMSG(&msg)->fs & KC_ALT ) instance->hk_state |= KLHotkey::alt;
if( CHARMSG(&msg)->fs & KC_SHIFT ) instance->hk_state |= KLHotkey::shift;
instance->hk_assigned->assign( instance->hk_scancode, instance->hk_state );
}
WinDismissDlg( hwnd, TRUE );
return MRFROMLONG(TRUE);
}
break;
}
return WinDefDlgProc( hwnd, msg, mp1, mp2 );
}
static MRESULT EXPENTRY LinkLabelProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
{
linkData *ld = (linkData *)WinQueryWindowULong( hwnd, QWL_USER );
switch ( msg )
{
case WM_PAINT:
{
FONTMETRICS fm;
FATTRS fat;
HPS hps;
ULONG style;
char *text = (char *)malloc( MAXTEXTLEN );
WinQueryWindowText( hwnd, MAXTEXTLEN, text);
hps = WinBeginPaint( hwnd , 0L , 0L );
GpiQueryFontMetrics( hps , sizeof( FONTMETRICS ) , &fm );
memset( &fat , 0 , sizeof( fat ) );
fat.usRecordLength = sizeof( FATTRS );
fat.lMatch = fm.lMatch;
fat.fsSelection = FATTR_SEL_UNDERSCORE;
strcpy( fat.szFacename , fm.szFacename );
GpiDeleteSetId( hps , 1 );
GpiCreateLogFont( hps , 0 , 1 , &fat );
GpiSetCharSet( hps , 1 );
WinQueryWindowRect( hwnd , &ld->textRect );
style = WinQueryWindowULong( hwnd, QWL_STYLE );
style &= DT_LEFT|DT_CENTER|DT_RIGHT|DT_TOP|DT_VCENTER|DT_BOTTOM;
WinDrawText( hps, -1, text, &ld->textRect,
CLR_BLUE, SYSCLR_DIALOGBACKGROUND,
style | DT_ERASERECT | DT_UNDERSCORE );
WinDrawText( hps, -1, text, &ld->textRect,
CLR_BLUE, SYSCLR_DIALOGBACKGROUND,
style | DT_QUERYEXTENT | DT_UNDERSCORE );
WinEndPaint( hps );
free( text );
}
return (MRESULT)FALSE;
case WM_MOUSEMOVE:
{
if ( handPtr != NULLHANDLE )
{
POINTL ptl;
ptl.x = SHORT1FROMMP( mp1 );
ptl.y = SHORT2FROMMP( mp1 );
if ( WinPtInRect( WinQueryAnchorBlock( hwnd ), &ld->textRect, &ptl) )
{
WinSetPointer( HWND_DESKTOP, handPtr );
return (MRESULT)FALSE;
}
}
}
break;
case WM_BUTTON1CLICK:
{
PROGDETAILS pd;
char *text;
POINTL ptl;
if ( strcmp( browserExe, "" ) == 0 ) break;
ptl.x = SHORT1FROMMP( mp1 );
ptl.y = SHORT2FROMMP( mp1 );
if ( !WinPtInRect( WinQueryAnchorBlock( hwnd ), &ld->textRect, &ptl) )
break;
if ( ld->url == NULL )
{
text = (char *)malloc( MAXTEXTLEN );
WinQueryWindowText( hwnd, MAXTEXTLEN, text);
}
else text = strdup( ld->url );
pd.Length = sizeof( PROGDETAILS );
pd.progt.progc = PROG_DEFAULT;
pd.progt.fbVisible = SHE_VISIBLE;
pd.pszTitle = NULL;
pd.pszExecutable = browserExe;
pd.pszParameters = NULL;
pd.pszStartupDir = ( browserDir[0] == 0 ) ? NULL : browserDir;
pd.pszIcon = NULL;
pd.pszEnvironment = NULL;
pd.swpInitial.fl = SWP_ACTIVATE;
pd.swpInitial.cy = 0;
pd.swpInitial.cx = 0;
pd.swpInitial.y = 0;
pd.swpInitial.x = 0;
pd.swpInitial.hwndInsertBehind = HWND_TOP;
pd.swpInitial.hwnd = NULLHANDLE;
pd.swpInitial.ulReserved1 = 0;
pd.swpInitial.ulReserved2 = 0;
WinStartApp( NULLHANDLE , &pd , text , NULL , 0 );
free( text );
}
break;
case WM_DESTROY:
ld->labelProc( hwnd, msg, mp1, mp2 );
if ( ld->url != NULL ) free( ld->url );
free( ld );
return (MRESULT)FALSE;
}
return ld->labelProc( hwnd, msg, mp1, mp2 );
}
MRESULT EXPENTRY AreaSettingsProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
{
extern WINDOWPOSITIONS windowpositions;
extern HWND hwndhelp;
char pchTemp[200];
char pchTitle[250];
HWND notebook=NULLHANDLE;
MRESULT resultbuf=0;
int rc;
switch(message)
{
case WM_INITDLG:
notebook=WinWindowFromID(parent,IDD_AREASETTINGS+1);
AddCancelItem(parent);
InsertSettingsPages(notebook, (PVOID) mp2);
WinSetWindowULong(parent, QWL_USER, ((PAREAPAR)mp2)->bMultiple);
RestoreWinPos(parent, &windowpositions.areasetuppos, TRUE, TRUE);
WinAssociateHelpInstance(hwndhelp, parent);
break;
case WM_ADJUSTFRAMEPOS:
SizeToClient(anchor, (PSWP) mp1, parent, IDD_AREASETTINGS+1);
break;
case WM_QUERYTRACKINFO:
/* Default-Werte aus Original-Prozedur holen */
resultbuf=WinDefDlgProc(parent,message,mp1,mp2);
/* Minimale Fenstergroesse einstellen */
((PTRACKINFO)mp2)->ptlMinTrackSize.x=255;
((PTRACKINFO)mp2)->ptlMinTrackSize.y=190;
return resultbuf;
case WM_CLOSE:
if (!WinQueryWindowULong(parent, QWL_USER))
{
/* Message an alle Windows schicken */
rc = SendToAllPages(WinWindowFromID(parent, IDD_AREASETTINGS+1), APM_REQCLOSE, NULL, NULL);
if (rc == 1)
return (MRESULT) FALSE;
if (rc == 2)
{
SendToAllPages(WinWindowFromID(parent, IDD_AREASETTINGS+1), APM_CANCEL, NULL, NULL);
WinDismissDlg(parent, DID_CANCEL);
}
else
WinDismissDlg(parent, DID_OK);
}
else
WinDismissDlg(parent, DID_OK);
QueryWinPos(parent, &(windowpositions.areasetuppos));
WinAssociateHelpInstance(hwndhelp, WinQueryWindow(parent, QW_OWNER));
return (MRESULT) FALSE;
case APM_SETTITLE:
if (!((PCHAR) mp1)[0])
LoadString(IDST_AP_EMPTYTITLE, 250, pchTitle);
else
{
LoadString(IDST_AP_TITLE, 200, pchTemp);
sprintf(pchTitle, pchTemp, (PCHAR) mp1);
}
WinSetWindowText(parent, pchTitle);
break;
case WM_COMMAND:
if (SHORT1FROMMP(mp1) == IDM_AS_CANCEL)
{
SendToAllPages(WinWindowFromID(parent, IDD_AREASETTINGS+1), APM_CANCEL, NULL, NULL);
WinDismissDlg(parent, DID_CANCEL);
}
return (MRESULT) FALSE;
default:
break;
}
return WinDefDlgProc(parent,message,mp1,mp2);
}
//==============================================================================
// WndProc - this function vectors WndProc (window processing) message handling
// requests to the correct message handler
//==============================================================================
MRESULT EXPENTRY _export WndProc(HWND hWnd, ULONG iMessage, MPARAM mParam1, MPARAM mParam2)
{
Window *pWindow = (Window *)WinQueryWindowULong(hWnd,0);
if (pWindow == 0) {
if (iMessage == WM_CREATE) {
pWindow = Main::tempthis;
WinSetWindowULong(hWnd,0,(ULONG)pWindow);
return pWindow->WndProc(hWnd,iMessage,mParam1,mParam2);
}
else return WinDefWindowProc(hWnd,iMessage,mParam1,mParam2);
}
else return pWindow->WndProc(hWnd,iMessage,mParam1,mParam2);
}