diff options
author | ben@chromium.org <ben@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2010-07-02 20:03:34 +0000 |
---|---|---|
committer | ben@chromium.org <ben@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2010-07-02 20:03:34 +0000 |
commit | 83421477bc9698c3f0c9de41764eb85dfc162ba7 (patch) | |
tree | 5bd1d315da95e1c907e3145574d3b3ce18a056ae /gfx | |
parent | 78fa96de8a0a6112d5aea2a42241427f6becc9c8 (diff) | |
download | chromium_src-83421477bc9698c3f0c9de41764eb85dfc162ba7.zip chromium_src-83421477bc9698c3f0c9de41764eb85dfc162ba7.tar.gz chromium_src-83421477bc9698c3f0c9de41764eb85dfc162ba7.tar.bz2 |
Move WindowImpl to gfx so I can use it there for canvas unit tests.
BUG=none
TEST=none
Review URL: http://codereview.chromium.org/2813042
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@51554 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'gfx')
-rw-r--r-- | gfx/gfx.gyp | 6 | ||||
-rw-r--r-- | gfx/window_impl.cc | 226 | ||||
-rw-r--r-- | gfx/window_impl.h | 113 |
3 files changed, 345 insertions, 0 deletions
diff --git a/gfx/gfx.gyp b/gfx/gfx.gyp index 592901c..668ac00 100644 --- a/gfx/gfx.gyp +++ b/gfx/gfx.gyp @@ -113,7 +113,13 @@ 'icon_util.h', 'native_theme_win.cc', 'native_theme_win.h', + 'window_impl.cc', + 'window_impl.h' ], + 'include_dirs': [ + '..', + '<(DEPTH)/third_party/wtl/include', + ], }], ['OS=="linux" or OS=="freebsd" or OS=="openbsd"', { 'dependencies': [ diff --git a/gfx/window_impl.cc b/gfx/window_impl.cc new file mode 100644 index 0000000..86eecce --- /dev/null +++ b/gfx/window_impl.cc @@ -0,0 +1,226 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "gfx/window_impl.h" + +#include <list> + +#include "base/singleton.h" +#include "base/string_util.h" +#include "base/win_util.h" + +namespace gfx { + +static const DWORD kWindowDefaultChildStyle = + WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS; +static const DWORD kWindowDefaultStyle = WS_OVERLAPPEDWINDOW; +static const DWORD kWindowDefaultExStyle = 0; + +/////////////////////////////////////////////////////////////////////////////// +// WindowImpl class tracking. + +// Several external scripts rely explicitly on this base class name for +// acquiring the window handle and will break if this is modified! +// static +const wchar_t* const WindowImpl::kBaseClassName = L"Chrome_WidgetWin_"; + +// WindowImpl class information used for registering unique windows. +struct ClassInfo { + UINT style; + HBRUSH background; + + explicit ClassInfo(int style) + : style(style), + background(NULL) {} + + // Compares two ClassInfos. Returns true if all members match. + bool Equals(const ClassInfo& other) const { + return (other.style == style && other.background == background); + } +}; + +class ClassRegistrar { + public: + ~ClassRegistrar() { + for (RegisteredClasses::iterator i = registered_classes_.begin(); + i != registered_classes_.end(); ++i) { + UnregisterClass(i->name.c_str(), NULL); + } + } + + // Puts the name for the class matching |class_info| in |class_name|, creating + // a new name if the class is not yet known. + // Returns true if this class was already known, false otherwise. + bool RetrieveClassName(const ClassInfo& class_info, std::wstring* name) { + for (RegisteredClasses::const_iterator i = registered_classes_.begin(); + i != registered_classes_.end(); ++i) { + if (class_info.Equals(i->info)) { + name->assign(i->name); + return true; + } + } + + name->assign(std::wstring(WindowImpl::kBaseClassName) + + IntToWString(registered_count_++)); + return false; + } + + void RegisterClass(const ClassInfo& class_info, + const std::wstring& name, + ATOM atom) { + registered_classes_.push_back(RegisteredClass(class_info, name, atom)); + } + + private: + // Represents a registered window class. + struct RegisteredClass { + RegisteredClass(const ClassInfo& info, + const std::wstring& name, + ATOM atom) + : info(info), + name(name), + atom(atom) { + } + + // Info used to create the class. + ClassInfo info; + + // The name given to the window. + std::wstring name; + + // The ATOM returned from creating the window. + ATOM atom; + }; + + ClassRegistrar() : registered_count_(0) { } + friend struct DefaultSingletonTraits<ClassRegistrar>; + + typedef std::list<RegisteredClass> RegisteredClasses; + RegisteredClasses registered_classes_; + + // Counter of how many classes have been registered so far. + int registered_count_; + + DISALLOW_COPY_AND_ASSIGN(ClassRegistrar); +}; + +/////////////////////////////////////////////////////////////////////////////// +// WindowImpl, public + +WindowImpl::WindowImpl() + : window_style_(0), + window_ex_style_(kWindowDefaultExStyle), + class_style_(CS_DBLCLKS), + hwnd_(NULL) { +} + +WindowImpl::~WindowImpl() { +} + +void WindowImpl::Init(HWND parent, const gfx::Rect& bounds) { + if (window_style_ == 0) + window_style_ = parent ? kWindowDefaultChildStyle : kWindowDefaultStyle; + + // Ensures the parent we have been passed is valid, otherwise CreateWindowEx + // will fail. + if (parent && !::IsWindow(parent)) { + NOTREACHED() << "invalid parent window specified."; + parent = NULL; + } + + int x, y, width, height; + if (bounds.IsEmpty()) { + x = y = width = height = CW_USEDEFAULT; + } else { + x = bounds.x(); + y = bounds.y(); + width = bounds.width(); + height = bounds.height(); + } + + hwnd_ = CreateWindowEx(window_ex_style_, GetWindowClassName().c_str(), NULL, + window_style_, x, y, width, height, + parent, NULL, NULL, this); + DCHECK(hwnd_); + + // The window procedure should have set the data for us. + DCHECK(win_util::GetWindowUserData(hwnd_) == this); +} + +HICON WindowImpl::GetDefaultWindowIcon() const { + return NULL; +} + +// static +bool WindowImpl::IsWindowImpl(HWND hwnd) { + wchar_t tmp[128]; + if (!::GetClassName(hwnd, tmp, 128)) + return false; + + std::wstring class_name(tmp); + return class_name.find(kBaseClassName) == 0; +} + +LRESULT WindowImpl::OnWndProc(UINT message, WPARAM w_param, LPARAM l_param) { + LRESULT result = 0; + + // Handle the message if it's in our message map; otherwise, let the system + // handle it. + if (!ProcessWindowMessage(hwnd_, message, w_param, l_param, result)) + result = DefWindowProc(hwnd_, message, w_param, l_param); + + return result; +} + +// static +LRESULT CALLBACK WindowImpl::WndProc(HWND hwnd, + UINT message, + WPARAM w_param, + LPARAM l_param) { + if (message == WM_NCCREATE) { + CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(l_param); + WindowImpl* window = reinterpret_cast<WindowImpl*>(cs->lpCreateParams); + DCHECK(window); + win_util::SetWindowUserData(hwnd, window); + window->hwnd_ = hwnd; + return TRUE; + } + + WindowImpl* window = reinterpret_cast<WindowImpl*>( + win_util::GetWindowUserData(hwnd)); + if (!window) + return 0; + + return window->OnWndProc(message, w_param, l_param); +} + +std::wstring WindowImpl::GetWindowClassName() { + ClassInfo class_info(initial_class_style()); + std::wstring name; + if (Singleton<ClassRegistrar>()->RetrieveClassName(class_info, &name)) + return name; + + // No class found, need to register one. + WNDCLASSEX class_ex; + class_ex.cbSize = sizeof(WNDCLASSEX); + class_ex.style = class_info.style; + class_ex.lpfnWndProc = &WindowImpl::WndProc; + class_ex.cbClsExtra = 0; + class_ex.cbWndExtra = 0; + class_ex.hInstance = NULL; + class_ex.hIcon = GetDefaultWindowIcon(); + class_ex.hCursor = LoadCursor(NULL, IDC_ARROW); + class_ex.hbrBackground = reinterpret_cast<HBRUSH>(class_info.background + 1); + class_ex.lpszMenuName = NULL; + class_ex.lpszClassName = name.c_str(); + class_ex.hIconSm = class_ex.hIcon; + ATOM atom = RegisterClassEx(&class_ex); + DCHECK(atom); + + Singleton<ClassRegistrar>()->RegisterClass(class_info, name, atom); + + return name; +} + +} // namespace gfx diff --git a/gfx/window_impl.h b/gfx/window_impl.h new file mode 100644 index 0000000..228e9096 --- /dev/null +++ b/gfx/window_impl.h @@ -0,0 +1,113 @@ +// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef GFX_WINDOW_IMPL_H_ +#define GFX_WINDOW_IMPL_H_ + +#include <atlbase.h> +#include <atlapp.h> +#include <atlmisc.h> +#include <atlcrack.h> + +#include <string> + +#include "base/logging.h" +#include "gfx/native_widget_types.h" +#include "gfx/rect.h" + +namespace gfx { + +// An interface implemented by classes that use message maps. +// ProcessWindowMessage is implemented by the BEGIN_MESSAGE_MAP_EX macro. +class MessageMapInterface { + public: + // Processes one message from the window's message queue. + virtual BOOL ProcessWindowMessage(HWND window, + UINT message, + WPARAM w_param, + LPARAM l_param, + LRESULT& result, + DWORD msg_mad_id = 0) = 0; +}; + +/////////////////////////////////////////////////////////////////////////////// +// +// WindowImpl +// A convenience class that encapsulates the details of creating and +// destroying a HWND. This class also hosts the windows procedure used by all +// Windows. +// +/////////////////////////////////////////////////////////////////////////////// +class WindowImpl : public MessageMapInterface { + public: + WindowImpl(); + virtual ~WindowImpl(); + + // Initializes the Window with a parent and an initial desired size. + void Init(HWND parent, const gfx::Rect& bounds); + + // Retrieves the default window icon to use for windows if none is specified. + virtual HICON GetDefaultWindowIcon() const; + + // Returns the HWND associated with this Window. + HWND hwnd() const { return hwnd_; } + + // Sets the window styles. This is ONLY used when the window is created. + // In other words, if you invoke this after invoking Init, nothing happens. + void set_window_style(DWORD style) { window_style_ = style; } + DWORD window_style() const { return window_style_; } + + // Sets the extended window styles. See comment about |set_window_style|. + void set_window_ex_style(DWORD style) { window_ex_style_ = style; } + DWORD window_ex_style() const { return window_ex_style_; } + + // Sets the class style to use. The default is CS_DBLCLKS. + void set_initial_class_style(UINT class_style) { + // We dynamically generate the class name, so don't register it globally! + DCHECK_EQ((class_style & CS_GLOBALCLASS), 0u); + class_style_ = class_style; + } + UINT initial_class_style() const { return class_style_; } + + // Returns true if the specified |hwnd| is a WindowImpl. + static bool IsWindowImpl(HWND hwnd); + + protected: + // Handles the WndProc callback for this object. + virtual LRESULT OnWndProc(UINT message, WPARAM w_param, LPARAM l_param); + + private: + friend class ClassRegistrar; + + // The window procedure used by all Windows. + static LRESULT CALLBACK WndProc(HWND window, + UINT message, + WPARAM w_param, + LPARAM l_param); + + // Gets the window class name to use when creating the corresponding HWND. + // If necessary, this registers the window class. + std::wstring GetWindowClassName(); + + // All classes registered by WidgetWin start with this name. + static const wchar_t* const kBaseClassName; + + // Window Styles used when creating the window. + DWORD window_style_; + + // Window Extended Styles used when creating the window. + DWORD window_ex_style_; + + // Style of the class to use. + UINT class_style_; + + // Our hwnd. + HWND hwnd_; + + DISALLOW_COPY_AND_ASSIGN(WindowImpl); +}; + +} // namespace gfx + +#endif // GFX_WINDOW_IMPL_H_ |