windowTools.cpp

Go to the documentation of this file.

/* *************************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
************************************************************************************* */

#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>

#include "windowTools.h"

// donne la taille de la fenetre client
BOOL GetWindowSize(HWND hWnd,int *dx,int *dy)
{
        RECT rect;
        if (!GetClientRect(hWnd,&rect)) return FALSE;
        *dx = rect.right-rect.left;
        *dy = rect.bottom-rect.top;
        return TRUE;
}

// configure la taille d'une fenetre
BOOL SetWindowSize(HWND hWndControl,int dx,int dy)
{
        return SetWindowPos(hWndControl,NULL,0,0,dx,dy,SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOSENDCHANGING);
}

// donne la postion de la fenetre
BOOL GetWindowPos(HWND hWnd,int *x,int *y)
{
        RECT rect;
        GetWindowRect(hWnd,&rect);
        POINT pt;
        pt.x = rect.left;
        pt.y = rect.top;
        ScreenToClient(GetParent(hWnd),&pt);
        *x=pt.x;
        *y=pt.y;
        return TRUE;
}

// ajout ou retir un style d'une fenetre cf.: voir CreateWindowEx
LONG SetWindowStyle(HWND hWnd,int set,LONG dwStyle)
{
        LONG result = GetWindowLong(hWnd,GWL_STYLE);
        result |=dwStyle;
        if (!set) result-=dwStyle;
        return  SetWindowLong(hWnd,GWL_STYLE,result);
}

// place en fullscreen
void SetFullScreen(HWND hWnd,BOOL isFull,BOOL isTopMost)
{
        HWND hWndConfig = isTopMost? HWND_TOPMOST : NULL;

        static int dxOld,dyOld,xOld,yOld;
        static BOOL oldIsFull=FALSE;
        if (isFull)
        {
                if (!oldIsFull)
                {
                        GetWindowSize(hWnd,&dxOld,&dyOld);
                        GetWindowPos(hWnd,&xOld,&yOld);
                }
                oldIsFull=TRUE;
                int dx = GetSystemMetrics(SM_CXSCREEN);
                int dy = GetSystemMetrics(SM_CYSCREEN);
                SetWindowStyle(hWnd,FALSE,WS_BORDER|WS_CAPTION|WS_DLGFRAME|WS_SIZEBOX );
                SetWindowPos(hWnd,NULL,0,0,dx,dy,SWP_SHOWWINDOW); 
                SetWindowPos(hWnd,hWndConfig,0,0,dx,dy,SWP_SHOWWINDOW); // topMost
                SetActiveWindow(hWnd);
        }
        else 
        {
                oldIsFull=FALSE;
                SetWindowStyle(hWnd,TRUE,WS_BORDER|WS_CAPTION|WS_DLGFRAME|WS_SIZEBOX);
                SetWindowPos(hWnd,hWndConfig, xOld, yOld, dxOld, dyOld, 0); // topMost
                SetActiveWindow(hWnd);
        }
}

// place en fenetre un titre ou non
void SetWindowTitle(HWND hWnd,char *title,BOOL enableTitle)
{
        SetWindowStyle(hWnd,enableTitle,WS_TILEDWINDOW);
        SetWindowText(hWnd,title);                      
}

// simule un appuis de bouton
void PushButton(HWND hWnd,int idControl)
{
        SendMessage(hWnd,WM_COMMAND,idControl,0);
}

// simule un appuis sur un boutton check box
BOOL ToggleCheck(HWND hWnd,int idControl)
{
        HWND hWndCtrl = GetDlgItem(hWnd,idControl);
        BOOL state = !Button_GetCheck(hWndCtrl);
        Button_SetCheck(hWndCtrl,state);
        PushButton(hWnd,idControl);
        return state;
}

// affiche le curseur de la souris (version parallele qui peut declanché un stack overflow si trop d'interation)
/*
void ShowMouse(BOOL active)
{
        int num=ShowCursor(active);
        if (num<0&&active) ShowMouse(active);
        if (num>=0&&!active) ShowMouse(active);
}
*/
void ShowMouse(BOOL active)
{
        if (active) while (ShowCursor(TRUE)<0);
        else while (ShowCursor(FALSE)>=0);
}

// calcul le delta de taille de fenetre
BOOL GetDeltaWindow(HWND hWndParent,RECT *oldRect,int *deltaX,int *deltaY)
{
        RECT newRect;

        GetWindowRect(hWndParent,&newRect);
        *deltaX = (newRect.right-newRect.left)-(oldRect->right-oldRect->left);
        *deltaY = (newRect.bottom-newRect.top)-(oldRect->bottom-oldRect->top);

        CopyMemory(oldRect,&newRect,sizeof(RECT));
        return TRUE;
}

// configure la taille d'une fenetre par rapport au delta
BOOL SetDeltaWindowSize(HWND hWndControl,int deltaX,int deltaY)
{
        RECT rect;

        GetWindowRect(hWndControl,&rect);
        int dX = rect.right-rect.left;
        int dY= rect.bottom-rect.top;

        SetWindowPos(hWndControl,NULL,0,0,dX+deltaX,dY+deltaY,SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOSENDCHANGING);
        return TRUE;
}

// configure la position d'une fenetre par rapport au delta
BOOL SetDeltaWindowPos(HWND hWndControl,int deltaX,int deltaY)
{
        POINT point;
        RECT rect;
        GetWindowRect(hWndControl,&rect);
        point.x=rect.left;
        point.y=rect.top;
        HWND hWndParent = GetParent(hWndControl);
        ScreenToClient(hWndParent,&point);
        SetWindowPos(hWndControl,NULL,point.x+deltaX,point.y+deltaY,0,0,SWP_NOSIZE);//|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOSENDCHANGING);     
        return TRUE;
}

// expande/collaps recursivement une arborecence d'un arbre
void TreeView_ExpandAll (HWND hTree,BOOL expand,HTREEITEM rootTree)
{
        if (!rootTree) rootTree = TreeView_GetRoot(hTree);

        while (rootTree)
        {
                TreeView_Expand(hTree,rootTree,expand? TVE_EXPAND : TVE_COLLAPSE);
                HTREEITEM childTree = TreeView_GetNextItem(hTree,rootTree,TVGN_CHILD);
                if (childTree) TreeView_ExpandAll(hTree,expand,childTree);
                rootTree = TreeView_GetNextSibling(hTree,rootTree);
        } 
}

// expande/collaps jusqu'a un certain niveau d'arborecence d'un arbre
void TreeView_ExpandAll_Level (HWND hTree,BOOL expand,int levelMax,HTREEITEM rootTree)
{
        static int level=0;
        if (!rootTree) rootTree = TreeView_GetRoot(hTree);

        level++;
        if (level<levelMax)
        {
                while (rootTree)
                {
                        TreeView_Expand(hTree,rootTree,expand? TVE_EXPAND : TVE_COLLAPSE);
                        HTREEITEM childTree = TreeView_GetNextItem(hTree,rootTree,TVGN_CHILD);
                        if (childTree) TreeView_ExpandAll_Level (hTree,expand,levelMax,childTree);
                        rootTree = TreeView_GetNextSibling(hTree,rootTree);
                } 
        }
        level--;
}


/* --------------------------------------------------------------------------------------------------- 
Déplace une fenetre dans le but de la placer dans le coin le plus proche des icon de tache
--------------------------------------------------------------------------------------------------- */

void MoveToBorderTask (HWND hUpdatingWnd)
{
        if (!hUpdatingWnd) return ;

        APPBARDATA Data ; 
        memset (&Data, 0, sizeof(Data)) ;
        Data.hWnd = hUpdatingWnd ;
        SHAppBarMessage( ABM_GETTASKBARPOS , &Data) ;
        RECT r ;
        GetWindowRect (hUpdatingWnd , &r) ;

        int cx = GetSystemMetrics(SM_CXSCREEN);
        int cy = GetSystemMetrics(SM_CYSCREEN);

        if (Data.rc.top < 0 && Data.rc.left < 0 && Data.rc.right > cx) 
        { // Barre de taches en haut
                MoveWindow (hUpdatingWnd, 
                        cx - (r.right - r.left), 
                        Data.rc.bottom - Data.rc.top, 
                        r.right - r.left, 
                        r.bottom - r.top, 
                        FALSE); 
        }
        else if (Data.rc.bottom > cy && Data.rc.left < 0 && Data.rc.right > cx) 
        { // Barre de taches en bas
                MoveWindow (hUpdatingWnd, 
                        cx - (r.right - r.left), 
                        cy - (Data.rc.bottom-Data.rc.top)-(r.bottom - r.top), 
                        r.right - r.left, 
                        r.bottom - r.top, 
                        FALSE); 
        } 
        else if (Data.rc.top < 0 && Data.rc.left < 0 && Data.rc.bottom > cy) 
        { // Barre de taches à gauche
                MoveWindow (hUpdatingWnd, 
                        (Data.rc.right-Data.rc.left), 
                        cy - (r.bottom - r.top), 
                        r.right - r.left, 
                        r.bottom - r.top, 
                        FALSE); 
        }
        else if (Data.rc.top < 0 && Data.rc.bottom > cy && Data.rc.right > cx) 
        { // Barre de taches à droite
                MoveWindow (hUpdatingWnd, 
                        cx - (Data.rc.right-Data.rc.left)- (r.right - r.left), 
                        cy -(r.bottom - r.top), 
                        r.right - r.left, 
                        r.bottom - r.top, 
                        FALSE); 
        }
        else   
                MoveWindow (hUpdatingWnd, 
                cx - (r.right - r.left), 
                cy - (Data.rc.bottom-Data.rc.top)-(r.bottom - r.top), 
                r.right - r.left, 
                r.bottom - r.top, 
                FALSE); 
}     

---