test: classchg.c File Reference

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# classchg.c File Reference

`#include "precomp.h"`

Go to the source code of this file.

## Functions

BOOL | VisWindow (PWND, DWORD)
BOOL | xxxSetClassIconEnum (PWND pwnd, LPARAM lParam)
PCURSOR | xxxSetClassIcon (PWND pwnd, PCLS pcls, PCURSOR pCursor, int gcw)
BOOL | DestroyClassSmIcon (PCLS pcls)
VOID | xxxCreateClassSmIcon (PCLS pcls)
LONG | xxxSetWindowStyle (PWND pwnd, int gwl, DWORD styleNew)

## Function Documentation

BOOL DestroyClassSmIcon | ( | PCLS | pcls | ) |

Definition at line 146 of file classchg.c.

References _DestroyCursor(), BOOL, CSF_CACHEDSMICON, tagCLS::CSF_flags, CURSOR_ALWAYSDESTROY, FALSE, TRUE, and Unlock.

Referenced by DestroyClass(), xxxRecreateSmallIcons(), and xxxSetClassIcon().

    00148 {
    00149
    00150     /*
    00151      * If we don't have a cached icon, then no work.
    00152      */
    00153     if (pcls->CSF_flags & CSF_CACHEDSMICON) {
    00154         if (pcls->spicnSm) {
    00155             _DestroyCursor(pcls->spicnSm, CURSOR_ALWAYSDESTROY);
    00156             Unlock(&pcls->spicnSm);
    00157         }
    00158         pcls->CSF_flags &= ~CSF_CACHEDSMICON;
    00159         return TRUE;
    00160     }
    00161
    00162     return FALSE;
    00163 }

BOOL VisWindow | ( | PWND | ,
|  | DWORD |
| ) |

Definition at line 475 of file classchg.c.

References BOOL, and FTopLevel.

Referenced by xxxSetWindowStyle().

    00478 {
    00479     return(FTopLevel(pwnd) &&
    00480             !(style & WS_MINIMIZE) &&
    00481             (style & WS_VISIBLE));
    00482 }

VOID xxxCreateClassSmIcon | ( | PCLS | pcls | ) |

Definition at line 172 of file classchg.c.

References CSF_CACHEDSMICON, tagCLS::CSF_flags, tagCLS::cWndReferenceCount, Lock, PtoH, PTR_TO_ID, SYSMET, VOID(), and xxxClientCopyImage().

Referenced by xxxCreateWindowEx(), xxxRecreateSmallIcons(), and xxxSetClassIcon().

    00174 {
    00175     PCURSOR pcur;
    00176
    00177     UserAssert(pcls->cWndReferenceCount > 0);
    00178     UserAssert(pcls->spicn);
    00179     UserAssert(!pcls->spicnSm);
    00180
    00181     pcur = xxxClientCopyImage(PtoH(pcls->spicn),
    00182             pcls->spicn->rt == PTR_TO_ID(RT_ICON) ? IMAGE_ICON : IMAGE_CURSOR,
    00183             SYSMET(CXSMICON),
    00184             SYSMET(CYSMICON),
    00185             LR_DEFAULTCOLOR | LR_COPYFROMRESOURCE);
    00186
    00187     Lock(&pcls->spicnSm, pcur);
    00188     if (pcls->spicnSm)
    00189         pcls->CSF_flags |= CSF_CACHEDSMICON;
    00190 }

PCURSOR xxxSetClassIcon | ( | PWND | pwnd,
|  | PCLS | pcls,
|  | PCURSOR | pCursor,
|  | int | gcw
| ) |

Definition at line 56 of file classchg.c.

References BOOL, BWL_ENUMLIST, CheckLock, CSF_CACHEDSMICON, tagCLS::CSF_flags, tagCLS::cWndReferenceCount, DestroyClassSmIcon(), FALSE, HMRevalidateHandleNoRip, Lock, NULL, tagDESKTOP::pDeskInfo, PtiCurrent, PtoH, tagTHREADINFO::rpdesk, tagDESKTOPINFO::spwnd, tagWND::spwndChild, ThreadLock, ThreadUnlock, TRUE, xxxCreateClassSmIcon(), xxxInternalEnumWindow(), and xxxSetClassIconEnum().

Referenced by SetClassCursor().

    00061 {
    00062     PTHREADINFO pti = PtiCurrent();
    00063     PCURSOR     pCursorOld;
    00064     HCURSOR     hCursorOld;
    00065     TL          tlpwndChild;
    00066     BOOL        fRedraw;
    00067
    00068     CheckLock(pwnd);
    00069
    00070     /*
    00071      * Save old icon
    00072      */
    00073     pCursorOld = ((gcw == GCLP_HICON) ? pcls->spicn : pcls->spicnSm);
    00074
    00075     if (pCursorOld != pCursor) {
    00076
    00077         fRedraw = TRUE;
    00078
    00079         hCursorOld = PtoH(pCursorOld);
    00080
    00081         /*
    00082          * Set new icon
    00083          */
    00084         if (gcw == GCLP_HICON) {
    00085
    00086             /*
    00087              * Destroy private cached small icon first.
    00088              */
    00089             if (pcls->spicnSm && !DestroyClassSmIcon(pcls))
    00090                 fRedraw = FALSE;
    00091
    00092             Lock(&(pcls->spicn), pCursor);
    00093
    00094         } else {
    00095
    00096             /*
    00097              * We don't allow apps to see the small icons we create from
    00098              * their big icons.  They can see their own.  Saves memory
    00099              * leak problems and is easier.
    00100              */
    00101             if (pcls->CSF_flags & CSF_CACHEDSMICON) {
    00102                 DestroyClassSmIcon(pcls);
    00103                 hCursorOld = NULL;
    00104             }
    00105
    00106             Lock(&(pcls->spicnSm), pCursor);
    00107         }
    00108
    00109         if (pcls->spicn && !pcls->spicnSm)
    00110             xxxCreateClassSmIcon(pcls);
    00111
    00112         if (fRedraw) {
    00113
    00114             if (pcls->cWndReferenceCount > 1) {
    00115                 ThreadLock(pti->rpdesk->pDeskInfo->spwnd->spwndChild, &tlpwndChild);
    00116                 xxxInternalEnumWindow(pti->rpdesk->pDeskInfo->spwnd->spwndChild,
    00117                                       xxxSetClassIconEnum,
    00118                                       (LPARAM)pcls,
    00119                                       BWL_ENUMLIST);
    00120                 ThreadUnlock(&tlpwndChild);
    00121             } else {
    00122                 xxxSetClassIconEnum(pwnd, (LPARAM)pcls);
    00123             }
    00124         }
    00125
    00126         /*
    00127          * Revalidate the old cursor
    00128          */
    00129         if (hCursorOld != NULL) {
    00130             pCursorOld = HMRevalidateHandleNoRip(hCursorOld);
    00131         } else {
    00132             pCursorOld = NULL;
    00133         }
    00134     }
    00135
    00136     return(pCursorOld);
    00137 }

BOOL xxxSetClassIconEnum | ( | PWND | pwnd,
|  | LPARAM | lParam
| ) |

Definition at line 26 of file classchg.c.

References _GetProp(), tagSERVERINFO::atomIconSmProp, BOOL, CheckLock, DestroyWindowSmIcon(), gpsi, MAKEINTATOM, tagWND::pcls, PROPF_INTERNAL, TestWF, TRUE, WFSMQUERYDRAGICON, and xxxRedrawTitle().

Referenced by xxxSetClassIcon().

    00029 {
    00030     CheckLock(pwnd);
    00031
    00032     if (pwnd->pcls == (PCLS)lParam) {
    00033         /*
    00034          * If the window doesn't have a small icon or it comes from
    00035          * WM_QUERYDRAGICON, redraw the title.  In the WM_QUERYDRAGICON
    00036          * case, get rid of the small icon so redrawing the title will
    00037          * create it if necessary.
    00038          */
    00039         if (TestWF(pwnd, WFSMQUERYDRAGICON))
    00040             DestroyWindowSmIcon(pwnd);
    00041
    00042         if (!_GetProp(pwnd, MAKEINTATOM(gpsi->atomIconSmProp),PROPF_INTERNAL))
    00043             xxxRedrawTitle(pwnd, DC_ICON);
    00044     }
    00045
    00046     return TRUE;
    00047 }

LONG xxxSetWindowStyle | ( | PWND | pwnd,
|  | int | gwl,
|  | DWORD | styleNew
| ) |

Definition at line 203 of file classchg.c.

References BOOL, CheckLock, ClrWF, DecVisWindows(), FNID_EDIT, GetAppCompatFlags2(), GETFNID, GETPTI, IDC_DEFAULT, IncVisWindows(), IsWinEventNotifyDeferredOK, NeedsWindowEdge(), NULL, PpiCurrent, PWNDDESKTOP, SetWF, tagWND::spmenu, tagWND::spwndParent, TestWF, TestwndChild, TRUE, UnlockWndMenu(), UnsetLayeredWindow(), VER40, VisWindow(), WEFWINDOWEDGE, WFCHILD, WFCPRESENT, WFINDESTROY, WFMINIMIZED, WFMPRESENT, WFWIN40COMPAT, xxxRedrawFrame(), xxxSendMessage(), xxxSetLayeredWindow(), and zzzInvalidateDCCache().

Referenced by xxxSetWindowData().

    00207 {
    00208     STYLESTRUCT sty;
    00209     BOOL        fWasChild;
    00210     BOOL        fIsChild;
    00211
    00212     CheckLock(pwnd);
    00213     UserAssert(IsWinEventNotifyDeferredOK());
    00214
    00215     /*
    00216      * HACK-O-RAMA
    00217      * A STYLESTRUCT currently has just one field: a DWORD for the style.
    00218      * Therefore, conveniently, we can pass a pointer into the stack for
    00219      * LPARAM.  But, if we add stuff, we'll have to change this.
    00220      */
    00221     sty.styleOld = ((gwl == GWL_STYLE) ? pwnd->style : pwnd->ExStyle);
    00222     sty.styleNew = styleNew;
    00223
    00224     /*
    00225      * Note that we don't do validation before _and_ after.  It is sufficient
    00226      * to do our stuff at the end.
    00227      */
    00228
    00229     /*
    00230      * We break Quicken 2.0 if we send the messages.  That's why we version
    00231      * switch them.
    00232      */
    00233
    00234     /*
    00235      * Send a WM_STYLECHANGING message to the window, so it can muck with
    00236      * the style bits.  Like validate some stuff.
    00237      */
    00238     if (TestWF(pwnd, WFWIN40COMPAT)) {
    00239         xxxSendMessage(pwnd, WM_STYLECHANGING, gwl, (LPARAM)(LPSTYLESTRUCT)&sty);
    00240     }
    00241
    00242     /*
    00243      * Now do our own validation.
    00244      */
    00245     if (gwl == GWL_STYLE) {
    00246
    00247         BOOL fWasVisWindow;
    00248
    00249         /*
    00250          * If this is an edit control that has ES_PASSWORD set and
    00251          * the caller does not own it and is trying to reset it,
    00252          * fail the call.
    00253          */
    00254         if ((PpiCurrent() != GETPTI(pwnd)->ppi) &&
    00255                 (GETFNID(pwnd) == FNID_EDIT) &&
    00256                 (sty.styleOld & ES_PASSWORD) &&
    00257                 !(sty.styleNew & ES_PASSWORD)) {
    00258             RIPERR0(ERROR_ACCESS_DENIED,
    00259                     RIP_WARNING,
    00260                     "Access denied in xxxSetWindowStyle");
    00261
    00262             return 0;
    00263         }
    00264
    00265         /* Listbox ownerdraw style check was moved to the client side (client\ntstubs.c) */
    00266
    00267         /*
    00268          * Do proper validation on style bits
    00269          */
    00270         if (pwnd->spwndParent == PWNDDESKTOP(pwnd))
    00271             sty.styleNew |= WS_CLIPSIBLINGS;
    00272
    00273         /*
    00274          * If the clipping-ness is changing, invalidate the dc cache.
    00275          */
    00276         if ((sty.styleNew & (WS_CLIPCHILDREN | WS_CLIPSIBLINGS)) !=
    00277             (sty.styleOld & (WS_CLIPCHILDREN | WS_CLIPSIBLINGS))) {
    00278
    00279             /*
    00280              * No need to DeferWinEventNotify() - pwnd is locked
    00281              */
    00282             zzzInvalidateDCCache(pwnd, IDC_DEFAULT);
    00283         }
    00284
    00285         /*
    00286          * This breaks all Paradox dialogs 1.0-5.0 that have combos.  They
    00287          * enumerate all child windows, add on minimized, then sit in a peek
    00288          * loop.  After that they enumerate all child windows and remove
    00289          * WS_MINIMIZE--except the code below won't let them.
    00290          *
    00291          * Result is weird painting and an inability to use the dialog any
    00292          * more short of dismissing it
    00293          *
    00294          * Temp fix:  Check for child window first.
    00295          */
    00296
    00297         /*
    00298          * if this window is REALLY minimized (minimized bit is set and caption
    00299          * present bit is removed), then don't allow app to remove the minimize
    00300          * bit -- this fixes FoxBlow's attempt at being the OS -- jeffbog
    00301          */
    00302         if (!TestWF(pwnd, WFCHILD) &&
    00303                 TestWF(pwnd, WFMINIMIZED) &&
    00304                 !TestWF(pwnd, WFCPRESENT) &&
    00305                 !(sty.styleNew & WS_MINIMIZE)) {
    00306
    00307             sty.styleNew |= WS_MINIMIZE;
    00308         }
    00309
    00310         /*
    00311          * If we're changing the child bit, deal with spmenu appropriately.
    00312          * If we're turning into a child, change spmenu to an id. If we're
    00313          * turning into a top level window, turn spmenu into a menu.
    00314          */
    00315         fWasChild = TestwndChild(pwnd);
    00316
    00317         pwnd->style = sty.styleNew;
    00318
    00319         fIsChild = TestwndChild(pwnd);
    00320
    00321         /*
    00322          * If we turned into a top level window, change spmenu to NULL.
    00323          * If we turned into a child from a top level window, unlock spmenu.
    00324          */
    00325         if (fWasChild && !fIsChild)
    00326             pwnd->spmenu = NULL;
    00327
    00328         if (!fWasChild && fIsChild) {
    00329             ClrWF(pwnd, WFMPRESENT);
    00330             UnlockWndMenu(pwnd, &pwnd->spmenu);
    00331         }
    00332
    00333         /*
    00334          * If the visible, child, or minimized style is changing,
    00335          * then update the cVisWindows count
    00336          */
    00337         fWasVisWindow = VisWindow(pwnd, sty.styleOld);
    00338         if (fWasVisWindow != VisWindow(pwnd, sty.styleNew))
    00339         {
    00340
    00341 #if DBG
    00342             if (TestWF(pwnd, WFINDESTROY)) {
    00343                 RIPMSG1(RIP_ERROR, "xxxSetWindowStyle: window INDESTROY 0x%08X", pwnd);
    00344             }
    00345 #endif
    00346
    00347 //            IncDecVisWindows(pwnd, !fWasVisWindow);
    00348             if (fWasVisWindow)
    00349                 DecVisWindows(pwnd);
    00350             else
    00351                 IncVisWindows(pwnd);
    00352         }
    00353     } else {
    00354         /*
    00355          * First, see if the app might be setting bits that it really
    00356          * doesn't know about.  If so, replace those bits with the
    00357          * current values.
    00358          */
    00359         if (GetAppCompatFlags2(VER40) & GACF2_NO50EXSTYLEBITS) {
    00360             sty.styleNew &= WS_EX_VALID40;
    00361         } else {
    00362             /*
    00363              * Don't let aplications set unused extended bits
    00364              * Mcostea #237449
    00365              */
    00366 #if DBG
    00367             if (sty.styleNew & ~WS_EX_ALLVALID) {
    00368                 RIPMSG0(RIP_WARNING, "Trying to set reserved exStyle bits in SetWindowLong");
    00369             }
    00370 #endif
    00371             sty.styleNew &= WS_EX_ALLVALID;
    00372         }
    00373         /*
    00374          * Is someone trying to toggle the WS_EX_TOPMOST style bit?
    00375          */
    00376         if ((sty.styleOld & WS_EX_TOPMOST) != (sty.styleNew & WS_EX_TOPMOST)) {
    00377
    00378 #if DBG
    00379             /*
    00380              * Rip in debug about this
    00381              */
    00382             RIPMSG0(RIP_WARNING, "Can't change WS_EX_TOPMOST with SetWindowLong");
    00383 #endif
    00384
    00385             /*
    00386              * BACKWARDS COMPATIBILITY HACK
    00387              * If stuff is getting stored in the high word, then it must be
    00388              * Lotus 123-W sticking a FAR pointer in this field.  So don't
    00389              * modify it.
    00390              */
    00391             if (TestWF(pwnd, WFWIN40COMPAT) || !HIWORD(sty.styleNew)) {
    00392
    00393                 /*
    00394                  * Don't let the bit be flipped
    00395                  */
    00396                 sty.styleNew &= ~WS_EX_TOPMOST;
    00397                 sty.styleNew |= (sty.styleOld & WS_EX_TOPMOST);
    00398             }
    00399         }
    00400
    00401         {
    00402             /*
    00403              * Check pwnd->ExStyle directly since sty.styleOld can now be
    00404              * different from the real state of the window, because of the
    00405              * callbacks in this function from the time sty.styleOld was
    00406              * remembered and up to now. We must call the layering functions
    00407              * based on the real state of the layering bit.
    00408              */
    00409             BOOL fWasSprite = (pwnd->ExStyle & WS_EX_LAYERED);
    00410             BOOL fSprite = (sty.styleNew & WS_EX_LAYERED);
    00411
    00412             if (fWasSprite && !fSprite) {
    00413                 if (!UnsetLayeredWindow(pwnd)) {
    00414                     return 0;
    00415                 }
    00416             } else if (!fWasSprite && fSprite) {
    00417                 if (!xxxSetLayeredWindow(pwnd, TRUE)) {
    00418                     return 0;
    00419                 }
    00420             }
    00421         }
    00422
    00423 #ifdef REDIRECTION
    00424         {
    00425             BOOL fWasRedirected = (pwnd->ExStyle & WS_EX_REDIRECTED);
    00426             BOOL fRedirected = (sty.styleNew & WS_EX_REDIRECTED);
    00427
    00428             if (fWasRedirected && !fRedirected) {
    00429                 if (!UnsetRedirectedWindow(pwnd)) {
    00430                     return 0;
    00431                 }
    00432             } else if (!fWasRedirected && fRedirected) {
    00433                 if (!SetRedirectedWindow(pwnd)) {
    00434                     return 0;
    00435                 }
    00436             }
    00437         }
    00438 #endif // REDIRECTION
    00439
    00440         /*
    00441          * The bits we use internally should be preserved
    00442          */
    00443         pwnd->ExStyle = sty.styleNew | (sty.styleOld & ~WS_EX_ALLVALID);
    00444         if ((sty.styleOld ^ sty.styleNew)
    00445             & (WS_EX_LEFTSCROLLBAR | WS_EX_RIGHT | WS_EX_RTLREADING | WS_EX_LAYOUTRTL)) {
    00446             xxxRedrawFrame(pwnd);
    00447         }
    00448     }
    00449
    00450     /*
    00451      * See if we still need the 3D edge since the window styles changed.
    00452      */
    00453     if (NeedsWindowEdge(pwnd->style, pwnd->ExStyle, TestWF(pwnd, WFWIN40COMPAT)))
    00454         SetWF(pwnd, WEFWINDOWEDGE);
    00455     else
    00456         ClrWF(pwnd, WEFWINDOWEDGE);
    00457
    00458     /*
    00459      * Send a WM_STYLECHANGED message
    00460      */
    00461     if (TestWF(pwnd, WFWIN40COMPAT))
    00462         xxxSendMessage(pwnd, WM_STYLECHANGED, gwl, (LPARAM)(LPSTYLESTRUCT)&sty);
    00463
    00464     return(sty.styleOld);
    00465 }