dom/base/nsBarProps.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Travis Bogard <travis@netscape.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "nsCOMPtr.h"
  40 #include "nscore.h"
  41 #include "nsBarProps.h"
  42 #include "nsGlobalWindow.h"
  43 #include "nsStyleConsts.h"
  44 #include "nsIDocShell.h"
  45 #include "nsIScriptSecurityManager.h"
  46 #include "nsIScrollable.h"
  47 #include "nsIWebBrowserChrome.h"
  48 #include "nsIDOMWindowInternal.h"
  49 #include "nsDOMClassInfo.h"
  50
  51 //
  52 //  Basic (virtual) BarProp class implementation
  53 //
  54 nsBarProp::nsBarProp() : mBrowserChrome(nsnull)
  55 {
  56 }
  57
  58 nsBarProp::~nsBarProp()
  59 {
  60 }
  61
  62
  63 DOMCI_DATA(BarProp, nsBarProp)
  64
  65 // QueryInterface implementation for BarProp
  66 NS_INTERFACE_MAP_BEGIN(nsBarProp)
  67   NS_INTERFACE_MAP_ENTRY(nsIDOMBarProp)
  68   NS_INTERFACE_MAP_ENTRY(nsISupports)
  69   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(BarProp)
  70 NS_INTERFACE_MAP_END
  71
  72
  73 NS_IMPL_ADDREF(nsBarProp)
  74 NS_IMPL_RELEASE(nsBarProp)
  75
  76
  77 NS_IMETHODIMP
  78 nsBarProp::SetWebBrowserChrome(nsIWebBrowserChrome* aBrowserChrome)
  79 {
  80   mBrowserChrome = aBrowserChrome;
  81   return NS_OK;
  82 }
  83
  84 NS_IMETHODIMP
  85 nsBarProp::GetVisibleByFlag(PRBool *aVisible, PRUint32 aChromeFlag)
  86 {
  87   *aVisible = PR_FALSE;
  88   NS_ENSURE_TRUE(mBrowserChrome, NS_OK);
  89
  90   PRUint32 chromeFlags;
  91
  92   NS_ENSURE_SUCCESS(mBrowserChrome->GetChromeFlags(&chromeFlags),
  93                     NS_ERROR_FAILURE);
  94   if(chromeFlags & aChromeFlag)
  95     *aVisible = PR_TRUE;
  96
  97   return NS_OK;
  98 }
  99
 100 NS_IMETHODIMP
 101 nsBarProp::SetVisibleByFlag(PRBool aVisible, PRUint32 aChromeFlag)
 102 {
 103   NS_ENSURE_TRUE(mBrowserChrome, NS_OK);
 104
 105   PRBool   enabled = PR_FALSE;
 106
 107   nsCOMPtr<nsIScriptSecurityManager>
 108            securityManager(do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID));
 109   if (securityManager)
 110     securityManager->IsCapabilityEnabled("UniversalBrowserWrite", &enabled);
 111   if (!enabled)
 112     return NS_OK;
 113
 114   PRUint32 chromeFlags;
 115
 116   NS_ENSURE_SUCCESS(mBrowserChrome->GetChromeFlags(&chromeFlags),
 117                     NS_ERROR_FAILURE);
 118   if(aVisible)
 119     chromeFlags |= aChromeFlag;
 120   else
 121     chromeFlags &= ~aChromeFlag;
 122   NS_ENSURE_SUCCESS(mBrowserChrome->SetChromeFlags(chromeFlags),
 123                     NS_ERROR_FAILURE);
 124
 125   return NS_OK;
 126 }
 127
 128 //
 129 // MenubarProp class implementation
 130 //
 131
 132 nsMenubarProp::nsMenubarProp()
 133 {
 134 }
 135
 136 nsMenubarProp::~nsMenubarProp()
 137 {
 138 }
 139
 140 NS_IMETHODIMP
 141 nsMenubarProp::GetVisible(PRBool *aVisible)
 142 {
 143   return nsBarProp::GetVisibleByFlag(aVisible,
 144                                      nsIWebBrowserChrome::CHROME_MENUBAR);
 145 }
 146
 147 NS_IMETHODIMP
 148 nsMenubarProp::SetVisible(PRBool aVisible)
 149 {
 150   return nsBarProp::SetVisibleByFlag(aVisible,
 151                                      nsIWebBrowserChrome::CHROME_MENUBAR);
 152 }
 153
 154 //
 155 // ToolbarProp class implementation
 156 //
 157
 158 nsToolbarProp::nsToolbarProp()
 159 {
 160 }
 161
 162 nsToolbarProp::~nsToolbarProp()
 163 {
 164 }
 165
 166 NS_IMETHODIMP
 167 nsToolbarProp::GetVisible(PRBool *aVisible)
 168 {
 169   return nsBarProp::GetVisibleByFlag(aVisible,
 170                                      nsIWebBrowserChrome::CHROME_TOOLBAR);
 171 }
 172
 173 NS_IMETHODIMP
 174 nsToolbarProp::SetVisible(PRBool aVisible)
 175 {
 176   return nsBarProp::SetVisibleByFlag(aVisible,
 177                                      nsIWebBrowserChrome::CHROME_TOOLBAR);
 178 }
 179
 180 //
 181 // LocationbarProp class implementation
 182 //
 183
 184 nsLocationbarProp::nsLocationbarProp()
 185 {
 186 }
 187
 188 nsLocationbarProp::~nsLocationbarProp()
 189 {
 190 }
 191
 192 NS_IMETHODIMP
 193 nsLocationbarProp::GetVisible(PRBool *aVisible)
 194 {
 195   return
 196     nsBarProp::GetVisibleByFlag(aVisible,
 197                                 nsIWebBrowserChrome::CHROME_LOCATIONBAR);
 198 }
 199
 200 NS_IMETHODIMP
 201 nsLocationbarProp::SetVisible(PRBool aVisible)
 202 {
 203   return
 204     nsBarProp::SetVisibleByFlag(aVisible,
 205                                 nsIWebBrowserChrome::CHROME_LOCATIONBAR);
 206 }
 207
 208 //
 209 // PersonalbarProp class implementation
 210 //
 211
 212 nsPersonalbarProp::nsPersonalbarProp()
 213 {
 214 }
 215
 216 nsPersonalbarProp::~nsPersonalbarProp()
 217 {
 218 }
 219
 220 NS_IMETHODIMP
 221 nsPersonalbarProp::GetVisible(PRBool *aVisible)
 222 {
 223   return
 224     nsBarProp::GetVisibleByFlag(aVisible,
 225                                 nsIWebBrowserChrome::CHROME_PERSONAL_TOOLBAR);
 226 }
 227
 228 NS_IMETHODIMP
 229 nsPersonalbarProp::SetVisible(PRBool aVisible)
 230 {
 231   return
 232     nsBarProp::SetVisibleByFlag(aVisible,
 233                                 nsIWebBrowserChrome::CHROME_PERSONAL_TOOLBAR);
 234 }
 235
 236 //
 237 // StatusbarProp class implementation
 238 //
 239
 240 nsStatusbarProp::nsStatusbarProp()
 241 {
 242 }
 243
 244 nsStatusbarProp::~nsStatusbarProp()
 245 {
 246 }
 247
 248 NS_IMETHODIMP
 249 nsStatusbarProp::GetVisible(PRBool *aVisible)
 250 {
 251   return nsBarProp::GetVisibleByFlag(aVisible,
 252                                      nsIWebBrowserChrome::CHROME_STATUSBAR);
 253 }
 254
 255 NS_IMETHODIMP
 256 nsStatusbarProp::SetVisible(PRBool aVisible)
 257 {
 258   return nsBarProp::SetVisibleByFlag(aVisible,
 259                                      nsIWebBrowserChrome::CHROME_STATUSBAR);
 260 }
 261
 262 //
 263 // ScrollbarsProp class implementation
 264 //
 265
 266 nsScrollbarsProp::nsScrollbarsProp(nsGlobalWindow *aWindow)
 267 {
 268   mDOMWindow = aWindow;
 269   nsISupports *supwin = static_cast<nsIScriptGlobalObject *>(aWindow);
 270   mDOMWindowWeakref = do_GetWeakReference(supwin);
 271 }
 272
 273 nsScrollbarsProp::~nsScrollbarsProp()
 274 {
 275 }
 276
 277 NS_IMETHODIMP
 278 nsScrollbarsProp::GetVisible(PRBool *aVisible)
 279 {
 280   *aVisible = PR_TRUE; // one assumes
 281
 282   nsCOMPtr<nsIDOMWindow> domwin(do_QueryReferent(mDOMWindowWeakref));
 283   if (domwin) { // dom window not deleted
 284     nsCOMPtr<nsIScrollable> scroller =
 285       do_QueryInterface(mDOMWindow->GetDocShell());
 286
 287     if (scroller) {
 288       PRInt32 prefValue;
 289       scroller->GetDefaultScrollbarPreferences(
 290                   nsIScrollable::ScrollOrientation_Y, &prefValue);
 291       if (prefValue == nsIScrollable::Scrollbar_Never) // try the other way
 292         scroller->GetDefaultScrollbarPreferences(
 293                     nsIScrollable::ScrollOrientation_X, &prefValue);
 294
 295       if (prefValue == nsIScrollable::Scrollbar_Never)
 296         *aVisible = PR_FALSE;
 297     }
 298   }
 299
 300   return NS_OK;
 301 }
 302
 303 NS_IMETHODIMP
 304 nsScrollbarsProp::SetVisible(PRBool aVisible)
 305 {
 306   PRBool   enabled = PR_FALSE;
 307
 308   nsCOMPtr<nsIScriptSecurityManager>
 309            securityManager(do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID));
 310   if (securityManager)
 311     securityManager->IsCapabilityEnabled("UniversalBrowserWrite", &enabled);
 312   if (!enabled)
 313     return NS_OK;
 314
 315   /* Scrollbars, unlike the other barprops, implement visibility directly
 316      rather than handing off to the superclass (and from there to the
 317      chrome window) because scrollbar visibility uniquely applies only
 318      to the window making the change (arguably. it does now, anyway.)
 319      and because embedding apps have no interface for implementing this
 320      themselves, and therefore the implementation must be internal. */
 321
 322   nsCOMPtr<nsIDOMWindow> domwin(do_QueryReferent(mDOMWindowWeakref));
 323   if (domwin) { // dom window must still exist. use away.
 324     nsCOMPtr<nsIScrollable> scroller =
 325       do_QueryInterface(mDOMWindow->GetDocShell());
 326
 327     if (scroller) {
 328       PRInt32 prefValue;
 329
 330       if (aVisible) {
 331         prefValue = nsIScrollable::Scrollbar_Auto;
 332       } else {
 333         prefValue = nsIScrollable::Scrollbar_Never;
 334       }
 335
 336       scroller->SetDefaultScrollbarPreferences(
 337                   nsIScrollable::ScrollOrientation_Y, prefValue);
 338       scroller->SetDefaultScrollbarPreferences(
 339                   nsIScrollable::ScrollOrientation_X, prefValue);
 340     }
 341   }
 342
 343   /* Notably absent is the part where we notify the chrome window using
 344      mBrowserChrome->SetChromeFlags(). Given the possibility of multiple
 345      DOM windows (multiple top-level windows, even) within a single
 346      chrome window, the historical concept of a single "has scrollbars"
 347      flag in the chrome is inapplicable, and we can't tell at this level
 348      whether we represent the particular DOM window that makes this decision
 349      for the chrome.
 350
 351      So only this object (and its corresponding DOM window) knows whether
 352      scrollbars are visible. The corresponding chrome window will need to
 353      ask (one of) its DOM window(s) when it needs to know about scrollbar
 354      visibility, rather than caching its own copy of that information.
 355   */
 356
 357   return NS_OK;
 358 }
 359