anchor_window.cpp

Go to the documentation of this file.

#ifndef ANCHOR_WINDOW_IMPLEMENTATION_FILE
#define ANCHOR_WINDOW_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : anchor_window                                                     *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2000-$now By Author.  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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "anchor_window.h"

#include <basis/array.cpp>
#include <basis/convert_utf.h>
#include <basis/istring.h>
#include <basis/log_base.h>
#include <basis/portable.h>
#include <data_struct/static_memory_gremlin.h>
#include <opsystem/filename.h>

#undef LOG
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger(), s)

#ifdef __WIN32__
const int STARTUP_MESSAGE = WM_USER + 123;
  // the special message we send out on startup of the event loop.

const int TIMER_EVENT_ID = 23;
  // the ID we use to create a timer, if the user wants one.

// a window_association tracks the object related to a window handle.

struct window_association {
  window_handle _handle;
  anchor_window *_window_object;

  window_association(window_handle wh = NIL, anchor_window *wo = NIL)
      : _handle(wh), _window_object(wo) {}
};

class window_association_list
: public array<window_association>, public virtual object_base
{
public:
  IMPLEMENT_CLASS_NAME("window_association_list");
};

// the associations list keeps track of windows that have been created so
// that the window procedure can get to the real object.

SAFE_STATIC(window_association_list, associations, )
#endif //win32


anchor_window::anchor_window()
#ifdef __LINUX__
: shutdown_alerter()
#endif
#ifdef __WIN32__
: _instance(NIL),
  _window_title(new istring),
  _window_class(new istring),
  _class_reg(NIL),
  _wind_handle(NIL),
  _cycle(0),
  _defunct(false)
#endif
{
}

anchor_window::~anchor_window()
{
  set_defunct();
#ifdef __WIN32__
  WHACK(_window_title);
  WHACK(_window_class);
  _class_reg = NIL;
  // remove the association for our window.
  for (int i = 0; i < associations().length(); i++) {
    if (associations()[i]._handle == _wind_handle) {
      associations().zap(i, i);
      break;
    }
  }
#endif
}

void anchor_window::handle_startup() { /* nothing for base class. */ }

void anchor_window::handle_timer() { /* nothing for base class. */ }

void anchor_window::handle_shutdown() { /* nothing for base class. */ }

bool anchor_window::close_this_program()
{
#ifdef __LINUX__
  shutdown_alerter::close_this_program();
  return true;
#endif
#ifdef __WIN32__
  bool to_return = false;
  for (int i = 0; i < associations().length(); i++) {
    window_handle win = associations()[i]._handle;
    int ret = PostMessage(win, WM_CLOSE, NIL, NIL);
    // if we got a healthy return from any post, then we'll say this worked.
    if (ret) to_return = true;
  }
  return to_return;
#endif
}

bool anchor_window::defunct() const
{
#ifdef __LINUX__
  return shutdown_alerter::is_defunct();
#endif
#ifdef __WIN32__
  return _defunct;
#endif
}

void anchor_window::set_defunct()
{
#ifdef __LINUX__
  return shutdown_alerter::set_defunct();
#endif
#ifdef __WIN32__
  _defunct = true;
#endif
}

bool anchor_window::close_app_window(const istring &app_name)
{
  FUNCDEF("close_app_window");
#ifdef __LINUX__
  return shutdown_alerter::close_application(app_name);
#endif
#ifdef __WIN32__
  istring title = anchor_window::make_well_known_title(app_name);
#ifdef DEBUG_PROCESS_MANAGER
  LOG(istring("title is: ") + title);
#endif

//hmmm: add support for linux...
#ifdef __WIN32__
  window_handle win_found = FindWindow(NIL, to_unicode_temp(title));
#ifdef DEBUG_PROCESS_MANAGER
  LOG(istring(istring::SPRINTF, "found window %lx", win_found));
#endif
  if (!win_found) {
    LOG(istring("Failed to find special window for [") + app_name
      + istring("]"));
    return false;
  }

//hmmm:
//why would we find only one window if there were multiple apps under that
//name?  how does windows deal with that?  is there a find window iterator?

  int ret = PostMessage(win_found, WM_CLOSE, NIL, NIL);
  if (!ret) {
    LOG(istring("Failed to send close message to [") + app_name
        + istring("]"));
    return false;
  }

  LOG(istring("Sent close message to [") + app_name + istring("]"));
#else
  #ifdef DEBUG_PROCESS_MANAGER
    LOG("graceful shutdown not implemented for this OS.");
  #endif
  return false;
#endif
  return true;
#endif //win32
}

bool anchor_window::setup(application_instance instance,
    const istring &app_name, int cycle)
{
#ifdef __LINUX__
  if (instance) {}
  return shutdown_alerter::setup(app_name, cycle);
#endif
#ifdef __WIN32__
  if (_wind_handle) return true;  // already initialized.
  // simple initializations first...
  _instance = instance;
  _cycle = cycle;
  *_window_title = make_well_known_title(app_name);
  *_window_class = make_well_known_class(app_name);
  _class_reg = register_class();  // register a new window class for this.
  _wind_handle = CreateWindow(to_unicode_temp(*_window_class),
      to_unicode_temp(*_window_title), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
      0, CW_USEDEFAULT, 0, NIL, NIL, _instance, NIL);
  if (!_wind_handle) return false;

  register_window(_wind_handle);  // hook in our window to the list.
  ShowWindow(_wind_handle, SW_HIDE);
  UpdateWindow(_wind_handle);
  PostMessage(_wind_handle, STARTUP_MESSAGE, 0, 0);
#endif  //win32
  return true;
}

void anchor_window::register_window(window_handle wind)
{
#ifdef __WIN32__
  // add the new window to our list of associations.
  associations() += window_association(wind, this);
#else
  if (wind) {}
#endif
}

#ifdef __WIN32__
ATOM anchor_window::register_class()
{
  WNDCLASSEX wcex;

  wcex.cbSize = sizeof(WNDCLASSEX);

  wcex.style = CS_HREDRAW | CS_VREDRAW;
  wcex.lpfnWndProc = (WNDPROC)WndProc;
  wcex.cbClsExtra = 0;
  wcex.cbWndExtra = 0;
  wcex.hInstance = _instance;
  wcex.hIcon = NIL;
  wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
  wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  wcex.lpszMenuName = NIL;
  to_unicode_persist(hold_class, _window_class->s());
  wcex.lpszClassName = hold_class;
  wcex.hIconSm = NIL;

  return RegisterClassEx(&wcex);
}
#endif

#ifdef __WIN32__
LRESULT CALLBACK anchor_window::WndProc(HWND hWnd, UINT message,
    WPARAM wParam, LPARAM lParam)
{
  switch (message) {
    case STARTUP_MESSAGE: {
      for (int i = 0; i < associations().length(); i++) {
        if (associations()[i]._handle == hWnd) {
          anchor_window &anch = *associations()[i]._window_object;
          // invoke the initial callback so the window can initialize.
          anch.handle_startup();

          // set a timer going if they wanted one.
          if (anch._cycle)
            SetTimer(anch._wind_handle, TIMER_EVENT_ID, anch._cycle, 0);
          break;
        }
      }
      break;
    }
    case WM_CLOSE: {
      for (int i = 0; i < associations().length(); i++) {
        if (associations()[i]._handle == hWnd) {
          // invoke the closing callback because we're leaving.
          associations()[i]._window_object->handle_shutdown();
          associations()[i]._window_object->set_defunct();
          break;
        }
      }
      return DefWindowProc(hWnd, message, wParam, lParam);
      break;
    }
    case WM_DESTROY: {
      PostQuitMessage(0);
      break;
    }
    case WM_TIMER: {
      bool found_window = false;  // records if we dispatched the event.
      for (int i = 0; i < associations().length(); i++)
        if (associations()[i]._handle == hWnd) {
          // always stop the timer since we're suspending time while we're busy.
          // more of a desire than a strategy.
          KillTimer(hWnd, TIMER_EVENT_ID);
          // invoke the timer callback to give the user some action.
          associations()[i]._window_object->handle_timer();
          found_window = true;
          // always set the timer going again after handling it.
          SetTimer(hWnd, TIMER_EVENT_ID,
              associations()[i]._window_object->_cycle, 0);
          break;
        }
      bool to_return = 0;
      // if the timer wasn't for one of our windows, we pass it to the default
      // window procedure in hopes it will know what the hell to do with it.
      if (!found_window)
        to_return = DefWindowProc(hWnd, message, wParam, lParam);
      return to_return;
    }
    case WM_PAINT: {
      PAINTSTRUCT ps;
      HDC hdc = BeginPaint(hWnd, &ps);
      // add drawing code here if needed.
      EndPaint(hWnd, &ps);
      break;
    }
    default: return DefWindowProc(hWnd, message, wParam, lParam);
  }
  return 0;
}
#endif

#ifdef __WIN32__
istring anchor_window::make_well_known_title(const istring &application_name)
{
  filename app_short = application_name;
  return istring("Anchor_for_") + app_short.basename();
}
#endif

#ifdef __WIN32__
istring anchor_window::make_well_known_class(const istring &application_name)
{
  filename app_short = application_name;
  return istring("Dozeclass_for_") + app_short.basename();
}
#endif

bool anchor_window::launch(anchor_window &win, application_instance handle,
    const istring &application_name, int cycle)
{
  // prepare the window for its role...
  if (!win.setup(handle, application_name, cycle)) return false;
#ifdef __LINUX__
  return shutdown_alerter::launch_console(win, application_name, cycle);
#endif
#ifdef __WIN32__
  MSG msg;
  msg.hwnd = 0; msg.message = 0; msg.wParam = 0; msg.lParam = 0;
  while (GetMessage(&msg, NIL, 0, 0)) {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
#endif
  return true;
}


#endif //ANCHOR_WINDOW_IMPLEMENTATION_FILE

---