Quelle TaskbarWindowPreview.cpp Sprache: C

/* vim: se cin sw=2 ts=2 et : */
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/ArrayUtils.h"

#include <nsITaskbarPreviewController.h>
#include "TaskbarWindowPreview.h"
#include "WindowHook.h"
#include "nsUXThemeData.h"
#include "TaskbarPreviewButton.h"
#include "nsWindow.h"
#include "nsWindowGfx.h"
#include "imgLoader.h"
#include "nsISVGPaintContext.h"

namespace mozilla {
namespace widget {

namespace {
bool WindowHookProc(void* aContext, HWND hWnd, UINT nMsg, WPARAM wParam,
                    LPARAM lParam, LRESULT* aResult) {
  TaskbarWindowPreview* preview =
      reinterpret_cast<TaskbarWindowPreview*>(aContext);
  *aResult = preview->WndProc(nMsg, wParam, lParam);
  return true;
}
}  // namespace

NS_IMPL_ISUPPORTS(TaskbarWindowPreview, nsITaskbarWindowPreview,
                  nsITaskbarProgress, nsITaskbarOverlayIconController,
                  nsISupportsWeakReference)

/**
* These correspond directly to the states defined in nsITaskbarProgress.idl, so
* they should be kept in sync.
*/
static TBPFLAG sNativeStates[] = {TBPF_NOPROGRESS, TBPF_INDETERMINATE,
                                  TBPF_NORMAL, TBPF_ERROR, TBPF_PAUSED};

TaskbarWindowPreview::TaskbarWindowPreview(
    ITaskbarList4* aTaskbar, nsITaskbarPreviewController* aController,
    HWND aHWND, nsIDocShell* aShell)
    : TaskbarPreview(aTaskbar, aController, aHWND, aShell),
      mCustomDrawing(false),
      mHaveButtons(false),
      mState(TBPF_NOPROGRESS),
      mCurrentValue(0),
      mMaxValue(0),
      mOverlayIcon(nullptr) {
  // Window previews are visible by default
  (void)SetVisible(true);

  memset(mThumbButtons, 0, sizeof mThumbButtons);
  for (int32_t i = 0; i < nsITaskbarWindowPreview::NUM_TOOLBAR_BUTTONS; i++) {
    mThumbButtons[i].dwMask = THB_FLAGS | THB_ICON | THB_TOOLTIP;
    mThumbButtons[i].iId = i;
    mThumbButtons[i].dwFlags = THBF_HIDDEN;
  }
}

TaskbarWindowPreview::~TaskbarWindowPreview() {
  if (mOverlayIcon) {
    ::DestroyIcon(mOverlayIcon);
    mOverlayIcon = nullptr;
  }

  // We need to clean up a hook associated with the "this" pointer.
  SetVisible(false);

  if (IsWindowAvailable()) {
    DetachFromNSWindow();
  } else {
    mWnd = nullptr;
  }
}

nsresult TaskbarWindowPreview::Init() {
  nsresult rv = TaskbarPreview::Init();
  if (NS_FAILED(rv)) {
    return rv;
  }

  if (CanMakeTaskbarCalls()) {
    return NS_OK;
  }

  WindowHook* hook = GetWindowHook();
  if (!hook) {
    return NS_ERROR_NOT_AVAILABLE;
  }

  return hook->AddMonitor(nsAppShell::GetTaskbarButtonCreatedMessage(),
                          TaskbarWindowHook, this);
}

nsresult TaskbarWindowPreview::ShowActive(bool active) {
  return FAILED(mTaskbar->ActivateTab(active ? mWnd : nullptr))
             ? NS_ERROR_FAILURE
             : NS_OK;
}

HWND& TaskbarWindowPreview::PreviewWindow() { return mWnd; }

nsresult TaskbarWindowPreview::GetButton(uint32_t index,
                                         nsITaskbarPreviewButton** _retVal) {
  if (index >= nsITaskbarWindowPreview::NUM_TOOLBAR_BUTTONS)
    return NS_ERROR_INVALID_ARG;

  nsCOMPtr<nsITaskbarPreviewButton> button(
      do_QueryReferent(mWeakButtons[index]));

  if (!button) {
    // Lost reference
    button = new TaskbarPreviewButton(this, index);
    if (!button) {
      return NS_ERROR_OUT_OF_MEMORY;
    }
    mWeakButtons[index] = do_GetWeakReference(button);
  }

  if (!mHaveButtons) {
    mHaveButtons = true;

    WindowHook* hook = GetWindowHook();
    if (!hook) {
      return NS_ERROR_NOT_AVAILABLE;
    }
    (void)hook->AddHook(WM_COMMAND, WindowHookProc, this);

    if (mVisible && FAILED(mTaskbar->ThumbBarAddButtons(
                        mWnd, nsITaskbarWindowPreview::NUM_TOOLBAR_BUTTONS,
                        mThumbButtons))) {
      return NS_ERROR_FAILURE;
    }
  }
  button.forget(_retVal);
  return NS_OK;
}

NS_IMETHODIMP
TaskbarWindowPreview::SetEnableCustomDrawing(bool aEnable) {
  if (aEnable == mCustomDrawing) return NS_OK;

  WindowHook* hook = GetWindowHook();
  if (!hook) {
    return NS_ERROR_NOT_AVAILABLE;
  }

  mCustomDrawing = aEnable;
  TaskbarPreview::EnableCustomDrawing(mWnd, aEnable);

  if (aEnable) {
    (void)hook->AddHook(WM_DWMSENDICONICTHUMBNAIL, WindowHookProc, this);
    (void)hook->AddHook(WM_DWMSENDICONICLIVEPREVIEWBITMAP, WindowHookProc,
                        this);
  } else {
    (void)hook->RemoveHook(WM_DWMSENDICONICLIVEPREVIEWBITMAP, WindowHookProc,
                           this);
    (void)hook->RemoveHook(WM_DWMSENDICONICTHUMBNAIL, WindowHookProc, this);
  }
  return NS_OK;
}

NS_IMETHODIMP
TaskbarWindowPreview::GetEnableCustomDrawing(bool* aEnable) {
  *aEnable = mCustomDrawing;
  return NS_OK;
}

NS_IMETHODIMP
TaskbarWindowPreview::SetProgressState(nsTaskbarProgressState aState,
                                       uint64_t aCurrentValue,
                                       uint64_t aMaxValue) {
  NS_ENSURE_ARG_RANGE(aState, nsTaskbarProgressState(0),
                      nsTaskbarProgressState(std::size(sNativeStates) - 1));

  TBPFLAG nativeState = sNativeStates[aState];
  if (nativeState == TBPF_NOPROGRESS || nativeState == TBPF_INDETERMINATE) {
    NS_ENSURE_TRUE(aCurrentValue == 0, NS_ERROR_INVALID_ARG);
    NS_ENSURE_TRUE(aMaxValue == 0, NS_ERROR_INVALID_ARG);
  }

  if (aCurrentValue > aMaxValue) return NS_ERROR_ILLEGAL_VALUE;

  mState = nativeState;
  mCurrentValue = aCurrentValue;
  mMaxValue = aMaxValue;

  // Only update if we can
  return CanMakeTaskbarCalls() ? UpdateTaskbarProgress() : NS_OK;
}

NS_IMETHODIMP
TaskbarWindowPreview::SetOverlayIcon(imgIContainer* aStatusIcon,
                                     const nsAString& aStatusDescription,
                                     nsISVGPaintContext* aPaintContext) {
  nsresult rv;
  if (aStatusIcon) {
    // The image shouldn't be animated
    bool isAnimated;
    rv = aStatusIcon->GetAnimated(&isAnimated);
    NS_ENSURE_SUCCESS(rv, rv);
    NS_ENSURE_FALSE(isAnimated, NS_ERROR_INVALID_ARG);
  }

  HICON hIcon = nullptr;
  if (aStatusIcon) {
    rv = nsWindowGfx::CreateIcon(
        aStatusIcon, aPaintContext, false, LayoutDeviceIntPoint(),
        nsWindowGfx::GetIconMetrics(nsWindowGfx::kSmallIcon), &hIcon);
    NS_ENSURE_SUCCESS(rv, rv);
  }

  if (mOverlayIcon) ::DestroyIcon(mOverlayIcon);
  mOverlayIcon = hIcon;
  mIconDescription = aStatusDescription;

  // Only update if we can
  return CanMakeTaskbarCalls() ? UpdateOverlayIcon() : NS_OK;
}

nsresult TaskbarWindowPreview::UpdateTaskbarProperties() {
  if (mHaveButtons) {
    if (FAILED(mTaskbar->ThumbBarAddButtons(
            mWnd, nsITaskbarWindowPreview::NUM_TOOLBAR_BUTTONS, mThumbButtons)))
      return NS_ERROR_FAILURE;
  }
  nsresult rv = UpdateTaskbarProgress();
  NS_ENSURE_SUCCESS(rv, rv);
  rv = UpdateOverlayIcon();
  NS_ENSURE_SUCCESS(rv, rv);
  return TaskbarPreview::UpdateTaskbarProperties();
}

nsresult TaskbarWindowPreview::UpdateTaskbarProgress() {
  HRESULT hr = mTaskbar->SetProgressState(mWnd, mState);
  if (SUCCEEDED(hr) && mState != TBPF_NOPROGRESS &&
      mState != TBPF_INDETERMINATE)
    hr = mTaskbar->SetProgressValue(mWnd, mCurrentValue, mMaxValue);

  return SUCCEEDED(hr) ? NS_OK : NS_ERROR_FAILURE;
}

nsresult TaskbarWindowPreview::UpdateOverlayIcon() {
  HRESULT hr =
      mTaskbar->SetOverlayIcon(mWnd, mOverlayIcon, mIconDescription.get());
  return SUCCEEDED(hr) ? NS_OK : NS_ERROR_FAILURE;
}

LRESULT
TaskbarWindowPreview::WndProc(UINT nMsg, WPARAM wParam, LPARAM lParam) {
  RefPtr<TaskbarWindowPreview> kungFuDeathGrip(this);
  switch (nMsg) {
    case WM_COMMAND: {
      uint32_t id = LOWORD(wParam);
      uint32_t index = id;
      nsCOMPtr<nsITaskbarPreviewButton> button;
      nsresult rv = GetButton(index, getter_AddRefs(button));
      if (NS_SUCCEEDED(rv)) mController->OnClick(button);
    }
      return 0;
  }
  return TaskbarPreview::WndProc(nMsg, wParam, lParam);
}

/* static */
bool TaskbarWindowPreview::TaskbarWindowHook(void* aContext, HWND hWnd,
                                             UINT nMsg, WPARAM wParam,
                                             LPARAM lParam, LRESULT* aResult) {
  NS_ASSERTION(nMsg == nsAppShell::GetTaskbarButtonCreatedMessage(),
               "Window hook proc called with wrong message");
  TaskbarWindowPreview* preview =
      reinterpret_cast<TaskbarWindowPreview*>(aContext);
  // Now we can make all the calls to mTaskbar
  preview->UpdateTaskbarProperties();
  return false;
}

nsresult TaskbarWindowPreview::Enable() {
  nsresult rv = TaskbarPreview::Enable();
  NS_ENSURE_SUCCESS(rv, rv);

  return FAILED(mTaskbar->AddTab(mWnd)) ? NS_ERROR_FAILURE : NS_OK;
}

nsresult TaskbarWindowPreview::Disable() {
  nsresult rv = TaskbarPreview::Disable();
  NS_ENSURE_SUCCESS(rv, rv);

  return FAILED(mTaskbar->DeleteTab(mWnd)) ? NS_ERROR_FAILURE : NS_OK;
}

void TaskbarWindowPreview::DetachFromNSWindow() {
  // Remove the hooks we have for drawing
  SetEnableCustomDrawing(false);

  if (WindowHook* hook = GetWindowHook()) {
    (void)hook->RemoveHook(WM_COMMAND, WindowHookProc, this);
    (void)hook->RemoveMonitor(nsAppShell::GetTaskbarButtonCreatedMessage(),
                              TaskbarWindowHook, this);
  }
  TaskbarPreview::DetachFromNSWindow();
}

nsresult TaskbarWindowPreview::UpdateButtons() {
  NS_ASSERTION(mVisible, "UpdateButtons called on invisible preview");

  if (FAILED(mTaskbar->ThumbBarUpdateButtons(
          mWnd, nsITaskbarWindowPreview::NUM_TOOLBAR_BUTTONS, mThumbButtons)))
    return NS_ERROR_FAILURE;
  return NS_OK;
}

nsresult TaskbarWindowPreview::UpdateButton(uint32_t index) {
  if (index >= nsITaskbarWindowPreview::NUM_TOOLBAR_BUTTONS)
    return NS_ERROR_INVALID_ARG;
  if (mVisible) {
    if (FAILED(mTaskbar->ThumbBarUpdateButtons(mWnd, 1, &mThumbButtons[index])))
      return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

}  // namespace widget
}  // namespace mozilla

quality99%

¤ Dauer der Verarbeitung: 0.16 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.