// Written by Christopher E. Miller
// See the included license.txt for copyright and license details.



module dfl.application;

private import dfl.internal.dlib, dfl.internal.clib;

private import dfl.base, dfl.form, dfl.internal.winapi, dfl.event;
private import dfl.control, dfl.drawing, dfl.label;
private import dfl.button, dfl.textbox, dfl.internal.wincom, dfl.environment;
private import dfl.internal.utf;

version(DFL_NO_RESOURCES) {
} else {
   private import dfl.resources;
}

version(DFL_NO_MENUS) {
} else {
   private import dfl.menu;
}


version = DFL_NO_ZOMBIE_FORM;

//debug = APP_PRINT;
//debug = SHOW_MESSAGE_INFO; // Slow.

debug(APP_PRINT) {
   pragma(msg, "DFL: debug app print");

   version(DFL_LIB)
   static assert(0);
}


private extern(C) void abort();



class ApplicationContext { // docmain

   this() {
   }



   // If onMainFormClose isn't overridden, the message
   // loop terminates when the main form is destroyed.
   this(Form mainForm) {
      mform = mainForm;
      mainForm.closed ~= &onMainFormClosed;
   }



   final @property void mainForm(Form mainForm) { // setter
      if(mform) {
         mform.closed.removeHandler(&onMainFormClosed);
      }

      mform = mainForm;

      if(mainForm) {
         mainForm.closed ~= &onMainFormClosed;
      }
   }

   final @property Form mainForm() nothrow { // getter
      return mform;
   }



   Event!(Object, EventArgs) threadExit;



   final void exitThread() {
      exitThreadCore();
   }


 protected:


   void exitThreadCore() {
      threadExit(this, EventArgs.empty);
      //ExitThread(0);
   }



   void onMainFormClosed(Object sender, EventArgs args) {
      exitThreadCore();
   }


 private:
   Form mform; // The context form.
}


private extern(Windows) nothrow {
   alias UINT function(LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique,
   LPWSTR lpTempFileName) GetTempFileNameWProc;
   alias DWORD function(DWORD nBufferLength, LPWSTR lpBuffer) GetTempPathWProc;
   alias HANDLE function(PACTCTXW pActCtx) CreateActCtxWProc;
   alias BOOL function(HANDLE hActCtx, ULONG_PTR* lpCookie) ActivateActCtxProc;
}


version(NO_WINDOWS_HUNG_WORKAROUND) {
}
else {
   version = WINDOWS_HUNG_WORKAROUND;
}


// Compatibility with previous DFL versions.
// Set version=DFL_NO_COMPAT to disable.
enum DflCompat {
   NONE = 0,

   // Adding to menus is the old way.
   MENU_092 = 0x1,

   // Controls don't recreate automatically when necessary.
   CONTROL_RECREATE_095 = 0x2,

   // Nothing.
   CONTROL_KEYEVENT_096 = 0x4,

   // When a Form is in showDialog, changing the dialogResult from NONE doesn't close the form.
   FORM_DIALOGRESULT_096 = 0x8,

   // Call onLoad/load and focus a control at old time.
   FORM_LOAD_096 = 0x10,

   // Parent controls now need to be container-controls; this removes that limit.
   CONTROL_PARENT_096 = 0x20,
}


final class Application { // docmain
   private this() {}

 static:


   // Should be called before creating any controls.
   // This is typically the first function called in main().
   // Does nothing if not supported.
   void enableVisualStyles() {
      enum MANIFEST = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>` "\r\n"
                                     `<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">` "\r\n"
                                           `<description>DFL manifest</description>` "\r\n"
                                           `<dependency>` "\r\n"
                                           `<dependentAssembly>` "\r\n"
                                           `<assemblyIdentity `
                                           `type="win32" `
                                                 `name="Microsoft.Windows.Common-Controls" `
                                                       `version="6.0.0.0" `
                                                             `processorArchitecture="X86" `
                                                                   `publicKeyToken="6595b64144ccf1df" `
                                                                         `language="*" `
                                                                               `/>` "\r\n"
                                                                               `</dependentAssembly>` "\r\n"
                                                                               `</dependency>` "\r\n"
                                                                               `</assembly>` "\r\n";

      HMODULE kernel32;
      kernel32 = GetModuleHandleA("kernel32.dll");
      //if(kernel32)
      assert(kernel32);
      {
         CreateActCtxWProc createActCtxW;
         createActCtxW = cast(CreateActCtxWProc)GetProcAddress(kernel32, "CreateActCtxW");
         if(createActCtxW) {
            GetTempPathWProc getTempPathW;
            GetTempFileNameWProc getTempFileNameW;
            ActivateActCtxProc activateActCtx;

            getTempPathW = cast(GetTempPathWProc)GetProcAddress(kernel32, "GetTempPathW");
            assert(getTempPathW !is null);
            getTempFileNameW = cast(GetTempFileNameWProc)GetProcAddress(kernel32, "GetTempFileNameW");
            assert(getTempFileNameW !is null);
            activateActCtx = cast(ActivateActCtxProc)GetProcAddress(kernel32, "ActivateActCtx");
            assert(activateActCtx !is null);

            DWORD pathlen;
            wchar[MAX_PATH] pathbuf = void;
            //if(pathbuf)
            {
               pathlen = getTempPathW(pathbuf.length, pathbuf.ptr);
               if(pathlen) {
                  DWORD manifestlen;
                  wchar[MAX_PATH] manifestbuf = void;
                  //if(manifestbuf)
                  {
                     manifestlen = getTempFileNameW(pathbuf.ptr, "dmf", 0, manifestbuf.ptr);
                     if(manifestlen) {
                        HANDLE hf;
                        hf = CreateFileW(manifestbuf.ptr, GENERIC_WRITE, 0, null, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, HANDLE.init);
                        if(hf != INVALID_HANDLE_VALUE) {
                           DWORD written;
                           if(WriteFile(hf, MANIFEST.ptr, MANIFEST.length, &written, null)) {
                              CloseHandle(hf);

                              ACTCTXW ac;
                              HANDLE hac;

                              ac.cbSize = ACTCTXW.sizeof;
                              //ac.dwFlags = 4; // ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID
                              ac.dwFlags = 0;
                              ac.lpSource = manifestbuf.ptr;
                              //ac.lpAssemblyDirectory = pathbuf; // ?

                              hac = createActCtxW(&ac);
                              if(hac != INVALID_HANDLE_VALUE) {
                                 ULONG_PTR ul;
                                 activateActCtx(hac, &ul);

                                 _initCommonControls(ICC_STANDARD_CLASSES); // Yes.
                                 //InitCommonControls(); // No. Doesn't work with common controls version 6!

                                 // Ensure the actctx is actually associated with the message queue...
                                 PostMessageA(null, wmDfl, 0, 0);
                                 {
                                    MSG msg;
                                    PeekMessageA(&msg, null, wmDfl, wmDfl, PM_REMOVE);
                                 }
                              } else {
                                 debug(APP_PRINT)
                                 cprintf("CreateActCtxW failed.\n");
                              }
                           } else {
                              CloseHandle(hf);
                           }
                        }

                        DeleteFileW(manifestbuf.ptr);
                     }
                  }
               }
            }
         }
      }
   }


   /+
   // ///
   @property bool visualStyles() nothrow { // getter
      // IsAppThemed:
      // "Do not call this function during DllMain or global objects contructors.
      // This may cause invalid return values in Microsoft Windows Vista and may cause Windows XP to become unstable."
   }
   +/


   /// Path of the executable including its file name.
   @property Dstring executablePath() { // getter
      return dfl.internal.utf.getModuleFileName(HMODULE.init);
   }


   /// Directory containing the executable.
   @property Dstring startupPath() { // getter
      return pathGetDirName(dfl.internal.utf.getModuleFileName(HMODULE.init));
   }


   // Used internally.
   Dstring getSpecialPath(Dstring name) { // package
      HKEY hk;
      if(ERROR_SUCCESS != RegOpenKeyA(HKEY_CURRENT_USER,
                                      r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders".ptr, &hk)) {
      bad_path:
         throw new DflException("Unable to obtain " ~ name ~ " directory information");
      }
      scope(exit)
      RegCloseKey(hk);
      Dstring result;
      result = regQueryValueString(hk, name);
      if(!result.length) {
         goto bad_path;
      }
      return result;
   }


   /// Application data base directory path, usually `C:\Documents and Settings\<user>\Application Data`; this directory might not exist yet.
   @property Dstring userAppDataBasePath() { // getter
      return getSpecialPath("AppData");
   }



   @property bool messageLoop() nothrow { // getter
      return (threadFlags & TF.RUNNING) != 0;
   }



   void addMessageFilter(IMessageFilter mf) {
      //filters ~= mf;

      IMessageFilter[] fs = filters;
      fs ~= mf;
      filters = fs;
   }


   void removeMessageFilter(IMessageFilter mf) {
      uint i;
      for(i = 0; i != filters.length; i++) {
         if(mf is filters[i]) {
            if(!i) {
               filters = filters[1 .. filters.length];
            } else if(i == filters.length - 1) {
               filters = filters[0 .. i];
            } else {
               filters = filters[0 .. i] ~ filters[i + 1 .. filters.length];
            }
            break;
         }
      }
   }


   package bool _doEvents(bool* keep) {
      if(threadFlags & (TF.STOP_RUNNING | TF.QUIT)) {
         return false;
      }

      try {
         Message msg;

         //while(PeekMessageA(&msg._winMsg, HWND.init, 0, 0, PM_REMOVE))
         while(dfl.internal.utf.peekMessage(&msg._winMsg, HWND.init, 0, 0, PM_REMOVE)) {
            gotMessage(msg);

            if(msg.msg == WM_QUIT) {
               threadFlags = threadFlags | TF.QUIT;
               return false;
            }
            if(threadFlags & TF.STOP_RUNNING) {
               return false;
            }
            if(!*keep) {
               break;
            }
         }

         // Execution continues after this so it's not idle.
      } catch(DThrowable e) {
         onThreadException(e);
      }

      return (threadFlags & TF.QUIT) == 0;
   }


   /// Process all messages in the message queue. Returns false if the application should exit.
   bool doEvents() {
      bool keep = true;
      return _doEvents(&keep);
   }


   bool doEvents(uint msDelay) {
      if(msDelay <= 3) {
         return doEvents();
      }
      struct TMR {
         public import dfl.timer;
      }
      scope tmr = new TMR.Timer();
      bool keep = true;
      tmr.interval = msDelay;
      tmr.tick ~= (TMR.Timer sender, EventArgs ea) {
         sender.stop();
         keep = false;
      };
      tmr.start();
      while(keep) {
         Application.waitForEvent();
         if(!_doEvents(&keep)) {
            return false;
         }
      }
      return true;
   }


   /// Run the application.
   void run() {
      run(new ApplicationContext);
   }


   void run(void delegate() whileIdle) {
      run(new ApplicationContext, whileIdle);
   }


   void run(ApplicationContext appcon) {
      void whileIdle() {
         waitForEvent();
      }


      run(appcon, &whileIdle);
   }


   // -whileIdle- is called repeatedly while there are no messages in the queue.
   // Application.idle events are suppressed; however, the -whileIdle- handler
   // may manually fire the Application.idle event.
   void run(ApplicationContext appcon, void delegate() whileIdle) {
      if(threadFlags & TF.RUNNING) {
         //throw new DflException("Cannot have more than one message loop per thread");
         assert(0, "Cannot have more than one message loop per thread");
      }

      if(threadFlags & TF.QUIT) {
         assert(0, "The application is shutting down");
      }

      version(CUSTOM_MSG_HOOK) {
         HHOOK _msghook = SetWindowsHookExA(WH_CALLWNDPROCRET, &globalMsgHook, null, GetCurrentThreadId());
         if(!_msghook) {
            throw new DflException("Unable to get window messages");
         }
         msghook = _msghook;
      }


      void threadJustExited(Object sender, EventArgs ea) {
         exitThread();
      }


      ctx = appcon;
      ctx.threadExit ~= &threadJustExited;
      try {
         threadFlags = threadFlags | TF.RUNNING;

         if(ctx.mainForm) {
            //ctx.mainForm.createControl();
            ctx.mainForm.show();
         }

         for(;;) {
            try {
            still_running:
               while(!(threadFlags & (TF.QUIT | TF.STOP_RUNNING))) {
                  Message msg;

                  //while(PeekMessageA(&msg._winMsg, HWND.init, 0, 0, PM_REMOVE))
                  while(dfl.internal.utf.peekMessage(&msg._winMsg, HWND.init, 0, 0, PM_REMOVE)) {
                     gotMessage(msg);

                     if(msg.msg == WM_QUIT) {
                        threadFlags = threadFlags | TF.QUIT;
                        break still_running;
                     }

                     if(threadFlags & (TF.QUIT | TF.STOP_RUNNING)) {
                        break still_running;
                     }
                  }

                  whileIdle();
               }

               // Stopped running.
               threadExit(typeid(Application), EventArgs.empty);
               threadFlags = threadFlags & ~(TF.RUNNING | TF.STOP_RUNNING);
               return;
            } catch(DThrowable e) {
               onThreadException(e);
            }
         }
      }
      finally {
         threadFlags = threadFlags & ~(TF.RUNNING | TF.STOP_RUNNING);

         ApplicationContext tctx;
         tctx = ctx;
         ctx = null;

         version(CUSTOM_MSG_HOOK)
         UnhookWindowsHookEx(msghook);

         tctx.threadExit.removeHandler(&threadJustExited);
      }
   }


   // Makes the form -mainForm- visible.
   void run(Form mainForm, void delegate() whileIdle) {
      ApplicationContext appcon = new ApplicationContext(mainForm);
      //mainForm.show(); // Interferes with -running-.
      run(appcon, whileIdle);
   }


   void run(Form mainForm) {
      ApplicationContext appcon = new ApplicationContext(mainForm);
      //mainForm.show(); // Interferes with -running-.
      run(appcon);
   }



   void exit() {
      PostQuitMessage(0);
   }


   /// Exit the thread's message loop and return from run.
   // Actually only stops the current run() loop.
   void exitThread() {
      threadFlags = threadFlags | TF.STOP_RUNNING;
   }


   // Will be null if not in a successful Application.run.
   package @property ApplicationContext context() nothrow { // getter
      return ctx;
   }



   HINSTANCE getInstance() {
      if(!hinst) {
         _initInstance();
      }
      return hinst;
   }


   void setInstance(HINSTANCE inst) {
      if(hinst) {
         if(inst != hinst) {
            throw new DflException("Instance is already set");
         }
         return;
      }

      if(inst) {
         _initInstance(inst);
      } else {
         _initInstance(); // ?
      }
   }


   // ApartmentState oleRequired() ...


   private static class ErrForm: Form {
      protected override void onLoad(EventArgs ea) {
         okBtn.focus();
      }


      protected override void onClosing(CancelEventArgs cea) {
         cea.cancel = !errdone;
      }


      enum PADDING = 10;


      void onOkClick(Object sender, EventArgs ea) {
         errdone = true;
         ctnu = true;
         //close();
         dispose();
      }


      void onCancelClick(Object sender, EventArgs ea) {
         errdone = true;
         ctnu = false;
         //close();
         dispose();
      }


      this(Dstring errmsg) {
         text = "Error";
         clientSize = Size(340, 150);
         startPosition = FormStartPosition.CENTER_SCREEN;
         formBorderStyle = FormBorderStyle.FIXED_DIALOG;
         minimizeBox = false;
         maximizeBox = false;
         controlBox = false;

         Label label;
         with(label = new Label) {
            bounds = Rect(PADDING, PADDING, this.clientSize.width - PADDING * 2, 40);
            label.text = "An application exception has occured. Click Continue to allow "
                         "the application to ignore this error and attempt to continue.";
            parent = this;
         }

         with(errBox = new TextBox) {
            text = errmsg;
            bounds = Rect(PADDING, 40 + PADDING, this.clientSize.width - PADDING * 2, 50);
            errBox.backColor = this.backColor;
            readOnly = true;
            multiline = true;
            parent = this;
         }

         with(okBtn = new Button) {
            width = 100;
            location = Point(this.clientSize.width - width - PADDING - width - PADDING,
                             this.clientSize.height - height - PADDING);
            text = "&Continue";
            parent = this;
            click ~= &onOkClick;
         }
         acceptButton = okBtn;

         with(new Button) {
            width = 100;
            location = Point(this.clientSize.width - width - PADDING,
                             this.clientSize.height - height - PADDING);
            text = "&Quit";
            parent = this;
            click ~= &onCancelClick;
         }

         autoScale = true;
      }


      /+
      private int inThread2() {
         try {
            // Create in this thread so that it owns the handle.
            assert(!isHandleCreated);
            show();
            SetForegroundWindow(handle);

            MSG msg;
            assert(isHandleCreated);
            // Using the unicode stuf here messes up the redrawing for some reason.
            while(GetMessageA(&msg, HWND.init, 0, 0)) // TODO: unicode ?
               //while(dfl.internal.utf.getMessage(&msg, HWND.init, 0, 0))
            {
               if(!IsDialogMessageA(handle, &msg))
                  //if(!dfl.internal.utf.isDialogMessage(handle, &msg))
               {
                  TranslateMessage(&msg);
                  DispatchMessageA(&msg);
                  //dfl.internal.utf.dispatchMessage(&msg);
               }

               if(!isHandleCreated) {
                  break;
               }
            }
         }
         finally {
            dispose();
            assert(!isHandleCreated);

            thread1 = null;
         }

         return 0;
      }

      private void tinThread2() {
         inThread2();
      }


      private Thread thread1;

      bool doContinue() {
         assert(!isHandleCreated);

         // Need to use a separate thread so that all the main thread's messages
         // will be there still when the exception is recovered from.
         // This is very important for some messages, such as socket events.
         thread1 = Thread.getThis(); // Problems with DMD 2.x
         Thread thd;
         thd = new Thread(&inThread2);
         thd.start();
         do {
            Sleep(200);
         } while(thread1);

         return ctnu;
      }
      +/

      bool doContinue() {
         assert(!isHandleCreated);

         show();

         Message msg;
         for(;;) {
            WaitMessage();
            if(PeekMessageA(&msg._winMsg, handle, 0, 0, PM_REMOVE | PM_NOYIELD)) {
               /+
               //if(!IsDialogMessageA(handle, &msg._winMsg)) // Back to the old problems.
               {
                  TranslateMessage(&msg._winMsg);
                  DispatchMessageA(&msg._winMsg);
               }
               +/
               gotMessage(msg);
            }

            if(!isHandleCreated) {
               break;
            }
         }

         return ctnu;
      }


      override Dstring toString() {
         return errBox.text;
      }


    private:
      bool errdone = false;
      bool ctnu = false;
      Button okBtn;
      TextBox errBox;
   }



   bool showDefaultExceptionDialog(Object e) {
      /+
      if(IDYES == MessageBoxA(null,
                              "An application exception has occured. Click Yes to allow\r\n"
                              "the application to ignore this error and attempt to continue.\r\n"
                              "Click No to quit the application.\r\n\r\n"~
                              e.toString(),
                              null, MB_ICONWARNING | MB_TASKMODAL | MB_YESNO)) {
         except = false;
         return;
      }
      +/

      //try
      {
         if((new ErrForm(getObjectString(e))).doContinue()) {
            return true;
         }
      }
      /+
      catch {
         MessageBoxA(null, "Error displaying error message", "DFL", MB_ICONERROR | MB_TASKMODAL);
      }
      +/

      return false;
   }



   void onThreadException(DThrowable e) nothrow {
      try
      {
         static bool except = false;

         version(WINDOWS_HUNG_WORKAROUND) {
            version(WINDOWS_HUNG_WORKAROUND_NO_IGNORE) {
            }
            else {
               if(cast(WindowsHungDflException)e) {
                  return;
               }
            }
         }

         if(except) {
            cprintf("Error: %.*s\n", cast(int)getObjectString(e).length, getObjectString(e).ptr);

            abort();
            return;
         }

         except = true;
         //if(threadException.handlers.length)
         if(threadException.hasHandlers) {
            threadException(typeid(Application), new ThreadExceptionEventArgs(e));
            except = false;
            return;
         } else
         {
            // No thread exception handlers, display a dialog.
            if(showDefaultExceptionDialog(e)) {
               except = false;
               return;
            }
         }
         //except = false;

         //throw e;
         cprintf("Error: %.*s\n", cast(int)getObjectString(e).length, getObjectString(e).ptr);
         //exitThread();
         Environment.exit(EXIT_FAILURE);
      } catch (DThrowable e) {
      }
   }



   Event!(Object, EventArgs) idle; // Finished processing and is now idle.

   Event!(Object, ThreadExceptionEventArgs) threadException;

   Event!(Object, EventArgs) threadExit;



   void addHotkey(Keys k,void delegate(Object sender, KeyEventArgs ea) dg) {
      if (auto pkid = k in hotkeyId) {
         immutable kid = *pkid;
         hotkeyHandler[kid] ~= dg;
      } else {
         int kid = 0;
         foreach (aak, aav; hotkeyHandler) {
            if (!aav.hasHandlers) {
               kid = aak;
               break;
            }
            ++kid;
         }
         immutable mod = (k&Keys.MODIFIERS)>>16,
                   keycode = k&Keys.KEY_CODE;
         if (RegisterHotKey(null, kid, mod, keycode)) {
            hotkeyId[k] = kid;
            if (auto h = kid in hotkeyHandler) {
               *h ~= dg;
            } else {
               typeof(hotkeyHandler[kid]) e;
               e ~= dg;
               hotkeyHandler[kid] = e;
            }
         } else {
            throw new DflException("Hotkey cannot resistered.");
         }
      }
   }



   void removeHotkey(Keys k, void delegate(Object sender, KeyEventArgs ea) dg) {
      if (auto pkid = k in hotkeyId) {
         immutable kid = *pkid;
         hotkeyHandler[kid].removeHandler(dg);
         if (!hotkeyHandler[kid].hasHandlers) {
            if (UnregisterHotKey(null, kid) == 0) {
               throw new DflException("Hotkey cannot unresistered.");
            }
            hotkeyHandler.remove(kid);
            hotkeyId.remove(k);
         }
      }
   }



   void removeHotkey(Keys k) {
      if (auto pkid = k in hotkeyId) {
         immutable kid = *pkid;
         foreach (hnd; hotkeyHandler[kid]) {
            hotkeyHandler[kid].removeHandler(hnd);
         }
         assert(!hotkeyHandler[kid].hasHandlers);
         if (UnregisterHotKey(null, kid) == 0) {
            throw new DflException("Hotkey cannot unresistered.");
         }
         hotkeyHandler.remove(kid);
         hotkeyId.remove(k);
      }
   }



   struct HotkeyRegister {
   static:

      alias void delegate(Object c, KeyEventArgs e) Handler;



      void addHandler(Keys k, Handler dg) {
         addHotkey(k, dg);
      }



      struct IndexedCatAssigner {
         Keys k;



         void opCatAssign(Handler dg) {
            addHandler(k, dg);
         }
      }



      IndexedCatAssigner opIndex(Keys k) {
         return IndexedCatAssigner(k);
      }



      void removeHandler(Keys k, Handler dg) {
         removeHotkey(k, dg);
      }



      void removeHandler(Keys k) {
         removeHotkey(k);
      }
   }


   /// helper
   HotkeyRegister hotkeys;


   static ~this() {
      foreach (key; hotkeyId.keys) {
         removeHotkey(key);
      }
      hotkeyId = null;
   }

   // Returns null if not found.
   package Control lookupHwnd(HWND hwnd) nothrow {
      //if(hwnd in controls)
      // return controls[hwnd];
      auto pc = hwnd in controls;
      if(pc) {
         return *pc;
      }
      return null;
   }


   // Also makes a great zombie.
   package void removeHwnd(HWND hwnd) {
      //delete controls[hwnd];
      controls.remove(hwnd);
   }


   version(DFL_NO_ZOMBIE_FORM) {
   }
   else {
      package enum ZOMBIE_PROP = "DFL_Zombie";

      // Doesn't do any good since the child controls still reference this control.
      package void zombieHwnd(Control c)
      in {
         assert(c !is null);
         assert(c.isHandleCreated);
         assert(lookupHwnd(c.handle));
      }
      body {
         SetPropA(c.handle, ZOMBIE_PROP.ptr, cast(HANDLE)cast(void*)c);
         removeHwnd(c.handle);
      }


      package void unzombieHwnd(Control c)
      in {
         assert(c !is null);
         assert(c.isHandleCreated);
         assert(!lookupHwnd(c.handle));
      }
      body {
         RemovePropA(c.handle, ZOMBIE_PROP.ptr);
         controls[c.handle] = c;
      }


      // Doesn't need to be a zombie.
      package void zombieKill(Control c)
      in {
         assert(c !is null);
      }
      body {
         if(c.isHandleCreated) {
            RemovePropA(c.handle, ZOMBIE_PROP.ptr);
         }
      }
   }


   version(DFL_NO_MENUS) {
   }
   else {
      // Returns its new unique menu ID.
      package int addMenuItem(MenuItem menu) {
         if(nmenus == END_MENU_ID - FIRST_MENU_ID) {
            throw new DflException("Out of menus");
         }

         typeof(menus) tempmenus;

         // TODO: sort menu IDs in 'menus' so that looking for free ID is much faster.

         prevMenuID++;
         if(prevMenuID >= END_MENU_ID || prevMenuID <= FIRST_MENU_ID) {
            prevMenuID = FIRST_MENU_ID;
         previdloop:
            for(;;) {
               for(size_t iw; iw != nmenus; iw++) {
                  MenuItem mi;
                  mi = cast(MenuItem)menus[iw];
                  if(mi) {
                     if(prevMenuID == mi._menuID) {
                        prevMenuID++;
                        continue previdloop;
                     }
                  }
               }
               break;
            }
         }
         tempmenus = cast(Menu*)dfl.internal.clib.realloc(menus, Menu.sizeof * (nmenus + 1));
         if(!tempmenus) {
            //throw new OutOfMemory;
            throw new DflException("Out of memory");
         }
         menus = tempmenus;

         menus[nmenus++] = menu;

         return prevMenuID;
      }


      package void addContextMenu(ContextMenu menu) {
         if(nmenus == END_MENU_ID - FIRST_MENU_ID) {
            throw new DflException("Out of menus");
         }

         typeof(menus) tempmenus;
         int idx;

         idx = nmenus;
         nmenus++;
         tempmenus = cast(Menu*)dfl.internal.clib.realloc(menus, Menu.sizeof * nmenus);
         if(!tempmenus) {
            nmenus--;
            //throw new OutOfMemory;
            throw new DflException("Out of memory");
         }
         menus = tempmenus;

         menus[idx] = menu;
      }


      package void removeMenu(Menu menu) {
         uint idx;

         for(idx = 0; idx != nmenus; idx++) {
            if(menus[idx] is menu) {
               goto found;
            }
         }
         return;

      found:
         if(nmenus == 1) {
            dfl.internal.clib.free(menus);
            menus = null;
            nmenus--;
         } else {
            if(idx != nmenus - 1) {
               menus[idx] = menus[nmenus - 1];   // Move last one in its place
            }

            nmenus--;
            menus = cast(Menu*)dfl.internal.clib.realloc(menus, Menu.sizeof * nmenus);
            assert(menus != null); // Memory shrink shouldn't be a problem.
         }
      }


      package MenuItem lookupMenuID(int menuID) {
         uint idx;
         MenuItem mi;

         for(idx = 0; idx != nmenus; idx++) {
            mi = cast(MenuItem)menus[idx];
            if(mi && mi._menuID == menuID) {
               return mi;
            }
         }
         return null;
      }


      package Menu lookupMenu(HMENU hmenu) {
         uint idx;

         for(idx = 0; idx != nmenus; idx++) {
            if(menus[idx].handle == hmenu) {
               return menus[idx];
            }
         }
         return null;
      }
   }


   package void creatingControl(Control ctrl) nothrow {
      TlsSetValue(tlsControl, cast(Control*)ctrl);
   }


   version(DFL_NO_RESOURCES) {
   }
   else {

      @property Resources resources() { // getter
         static Resources rc = null;

         if(!rc) {
            synchronized {
               if(!rc) {
                  rc = new Resources(getInstance());
               }
            }
         }
         return rc;
      }
   }


   private UINT gctimer = 0;
   private DWORD gcinfo = 1;



   @property void autoCollect(bool byes) { // setter
      if(byes) {
         if(!autoCollect) {
            gcinfo = 1;
         }
      } else {
         if(autoCollect) {
            gcinfo = 0;
            KillTimer(HWND.init, gctimer);
            gctimer = 0;
         }
      }
   }


   @property bool autoCollect() nothrow { // getter
      return gcinfo > 0;
   }


   package void _waitMsg() {
      if(threadFlags & (TF.STOP_RUNNING | TF.QUIT)) {
         return;
      }

      idle(typeid(Application), EventArgs.empty);
      WaitMessage();
   }

   package deprecated alias _waitMsg waitMsg;

   // Because waiting for an event enters an idle state,
   // this function fires the -idle- event.
   void waitForEvent() {
      if(!autoCollect) {
         _waitMsg();
         return;
      }

      if(1 == gcinfo) {
         gcinfo = gcinfo.max;
         assert(!gctimer);
         gctimer = SetTimer(HWND.init, 0, 200, &_gcTimeout);
      }

      _waitMsg();

      if(GetTickCount() > gcinfo) {
         gcinfo = 1;
      }
   }


   version(DFL_NO_COMPAT)
   package enum _compat = DflCompat.NONE;
   else {
      package DflCompat _compat = DflCompat.NONE;
   }


   deprecated void setCompat(DflCompat dflcompat) {
      version(DFL_NO_COMPAT) {
         assert(0, "Compatibility disabled"); // version=DFL_NO_COMPAT
      }
      else {
         if(messageLoop) {
            assert(0, "setCompat"); // Called too late, must enable compatibility sooner.
         }

         _compat |= dflcompat;
      }
   }


   private static size_t _doref(void* p, int by) {
      assert(1 == by || -1 == by);

      size_t result;

      synchronized {
         auto pref = p in _refs;
         if(pref) {
            size_t count;
            count = *pref;

            assert(count || -1 != by);

            if(-1 == by) {
               count--;
            } else {
               count++;
            }

            if(!count) {
               result = 0;
               _refs.remove(p);
            } else {
               result = count;
               _refs[p] = count;
            }
         } else if(1 == by) {
            _refs[p] = 1;
            result = 1;
         }
      }

      return result;
   }


   package size_t refCountInc(void* p) {
      return _doref(p, 1);
   }


   // Returns the new ref count.
   package size_t refCountDec(void* p) {
      return _doref(p, -1);
   }


   package void ppin(void* p) {
      dfl.internal.dlib.gcPin(p);
   }


   package void punpin(void* p) {
      dfl.internal.dlib.gcUnpin(p);
   }


 private:
 static:
   size_t[void*] _refs;
   IMessageFilter[] filters;
   DWORD tlsThreadFlags;
   DWORD tlsControl;
   DWORD tlsFilter; // IMessageFilter[]*.
   version(CUSTOM_MSG_HOOK)
   DWORD tlsHook; // HHOOK.
   Control[HWND] controls;
   HINSTANCE hinst;
   ApplicationContext ctx = null;
   int[Keys] hotkeyId;
   Event!(Object, KeyEventArgs)[int] hotkeyHandler;

   version(DFL_NO_MENUS) {
   }
   else {
      // Menus.
      enum short FIRST_MENU_ID = 200;
      enum short END_MENU_ID = 10000;

      // Controls.
      enum ushort FIRST_CTRL_ID = END_MENU_ID + 1;
      enum ushort LAST_CTRL_ID = 65500;


      ushort prevMenuID = FIRST_MENU_ID;
      // malloc() is needed so the menus can be garbage collected.
      uint nmenus = 0; // Number of -menus-.
      Menu* menus = null; // WARNING: malloc()'d memory!


      // Destroy all menu handles at program exit because Windows will not
      // unless it is assigned to a window.
      // Note that this is probably just a 16bit issue, but it still appeared in the 32bit docs.
      private void sdtorFreeAllMenus() {
         foreach(Menu m; menus[0 .. nmenus]) {
            DestroyMenu(m.handle);
         }
         nmenus = 0;
         dfl.internal.clib.free(menus);
         menus = null;
      }
   }


   private struct TlsFilterValue {
      IMessageFilter[] filters;
   }


   /+
   @property void filters(IMessageFilter[] filters) { // setter
      // The TlsFilterValue is being garbage collected!

      TlsFilterValue* val = cast(TlsFilterValue*)TlsGetValue(tlsFilter);
      if(!val) {
         val = new TlsFilterValue;
      }
      val.filters = filters;
      TlsSetValue(tlsFilter, cast(LPVOID)val);
   }


   @property IMessageFilter[] filters() nothrow { // getter
      TlsFilterValue* val = cast(TlsFilterValue*)TlsGetValue(tlsFilter);
      if(!val) {
         return null;
      }
      return val.filters;
   }
   +/


   version(CUSTOM_MSG_HOOK) {
      @property void msghook(HHOOK hhook) { // setter
         TlsSetValue(tlsHook, cast(LPVOID)hhook);
      }


      @property HHOOK msghook() nothrow { // getter
         return cast(HHOOK)TlsGetValue(tlsHook);
      }
   }


   Control getCreatingControl() nothrow {
      return cast(Control)cast(Control*)TlsGetValue(tlsControl);
   }


   // Thread flags.
   enum TF: DWORD {
      RUNNING = 1, // Application.run is in affect.
      STOP_RUNNING = 2,
      QUIT = 4, // Received WM_QUIT.
   }


   @property TF threadFlags() nothrow { // getter
      return cast(TF)cast(DWORD)TlsGetValue(tlsThreadFlags);
   }


   @property void threadFlags(TF flags) { // setter
      if(!TlsSetValue(tlsThreadFlags, cast(LPVOID)cast(DWORD)flags)) {
         assert(0);
      }
   }


   void gotMessage(ref Message msg) {
      //debug(SHOW_MESSAGE_INFO)
      // showMessageInfo(msg);
      void handleHotkey() {
         immutable kid = cast(int)msg.wParam,
                   mod = cast(uint) (msg.lParam&0x0000ffff),
                   keycode = cast(uint)((msg.lParam&0xffff0000)>>16);
         assert(kid < hotkeyHandler.length);
         hotkeyHandler[kid](
            typeid(Application),
            new KeyEventArgs(cast(Keys)((mod << 16) | keycode)));
      }
      // Don't bother with this extra stuff if there aren't any filters.
      if(filters.length) {
         try {
            // Keep a local reference so that handlers
            // may be added and removed during filtering.
            IMessageFilter[] local = filters;

            foreach(IMessageFilter mf; local) {
               // Returning true prevents dispatching.
               if(mf.preFilterMessage(msg)) {
                  Control ctrl;
                  ctrl = lookupHwnd(msg.hWnd);
                  if(ctrl) {
                     ctrl.mustWndProc(msg);
                  } else if (msg.msg == WM_HOTKEY) {
                     handleHotkey();
                  }
                  return;
               }
            }
         } catch(DThrowable o) {
            Control ctrl;
            ctrl = lookupHwnd(msg.hWnd);
            if(ctrl) {
               ctrl.mustWndProc(msg);
            }
            throw o;
         }
      }
      if (msg.msg == WM_HOTKEY) {
         handleHotkey();
      }
      TranslateMessage(&msg._winMsg);
      //DispatchMessageA(&msg._winMsg);
      dfl.internal.utf.dispatchMessage(&msg._winMsg);
   }
}


package:


extern(Windows) void _gcTimeout(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime) nothrow {
   KillTimer(hwnd, Application.gctimer);
   Application.gctimer = 0;

   //cprintf("Auto-collecting\n");
   dfl.internal.dlib.gcFullCollect();

   Application.gcinfo = GetTickCount() + 4000;
}


// Note: phobos-only.
debug(SHOW_MESSAGE_INFO) {
   private import std.stdio, std.string;


   void showMessageInfo(ref Message m) {
      void writeWm(Dstring wmName) {
         writef("Message %s=%d(0x%X)\n", wmName, m.msg, m.msg);
      }


      switch(m.msg) {
         case WM_NULL: writeWm("WM_NULL"); break;
         case WM_CREATE: writeWm("WM_CREATE"); break;
         case WM_DESTROY: writeWm("WM_DESTROY"); break;
         case WM_MOVE: writeWm("WM_MOVE"); break;
         case WM_SIZE: writeWm("WM_SIZE"); break;
         case WM_ACTIVATE: writeWm("WM_ACTIVATE"); break;
         case WM_SETFOCUS: writeWm("WM_SETFOCUS"); break;
         case WM_KILLFOCUS: writeWm("WM_KILLFOCUS"); break;
         case WM_ENABLE: writeWm("WM_ENABLE"); break;
         case WM_SETREDRAW: writeWm("WM_SETREDRAW"); break;
         case WM_SETTEXT: writeWm("WM_SETTEXT"); break;
         case WM_GETTEXT: writeWm("WM_GETTEXT"); break;
         case WM_GETTEXTLENGTH: writeWm("WM_GETTEXTLENGTH"); break;
         case WM_PAINT: writeWm("WM_PAINT"); break;
         case WM_CLOSE: writeWm("WM_CLOSE"); break;
         case WM_QUERYENDSESSION: writeWm("WM_QUERYENDSESSION"); break;
         case WM_QUIT: writeWm("WM_QUIT"); break;
         case WM_QUERYOPEN: writeWm("WM_QUERYOPEN"); break;
         case WM_ERASEBKGND: writeWm("WM_ERASEBKGND"); break;
         case WM_SYSCOLORCHANGE: writeWm("WM_SYSCOLORCHANGE"); break;
         case WM_ENDSESSION: writeWm("WM_ENDSESSION"); break;
         case WM_SHOWWINDOW: writeWm("WM_SHOWWINDOW"); break;
         //case WM_WININICHANGE: writeWm("WM_WININICHANGE"); break;
         case WM_SETTINGCHANGE: writeWm("WM_SETTINGCHANGE"); break;
         case WM_DEVMODECHANGE: writeWm("WM_DEVMODECHANGE"); break;
         case WM_ACTIVATEAPP: writeWm("WM_ACTIVATEAPP"); break;
         case WM_FONTCHANGE: writeWm("WM_FONTCHANGE"); break;
         case WM_TIMECHANGE: writeWm("WM_TIMECHANGE"); break;
         case WM_CANCELMODE: writeWm("WM_CANCELMODE"); break;
         case WM_SETCURSOR: writeWm("WM_SETCURSOR"); break;
         case WM_MOUSEACTIVATE: writeWm("WM_MOUSEACTIVATE"); break;
         case WM_CHILDACTIVATE: writeWm("WM_CHILDACTIVATE"); break;
         case WM_QUEUESYNC: writeWm("WM_QUEUESYNC"); break;
         case WM_GETMINMAXINFO: writeWm("WM_GETMINMAXINFO"); break;
         case WM_NOTIFY: writeWm("WM_NOTIFY"); break;
         case WM_INPUTLANGCHANGEREQUEST: writeWm("WM_INPUTLANGCHANGEREQUEST"); break;
         case WM_INPUTLANGCHANGE: writeWm("WM_INPUTLANGCHANGE"); break;
         case WM_TCARD: writeWm("WM_TCARD"); break;
         case WM_HELP: writeWm("WM_HELP"); break;
         case WM_USERCHANGED: writeWm("WM_USERCHANGED"); break;
         case WM_NOTIFYFORMAT: writeWm("WM_NOTIFYFORMAT"); break;
         case WM_CONTEXTMENU: writeWm("WM_CONTEXTMENU"); break;
         case WM_STYLECHANGING: writeWm("WM_STYLECHANGING"); break;
         case WM_STYLECHANGED: writeWm("WM_STYLECHANGED"); break;
         case WM_DISPLAYCHANGE: writeWm("WM_DISPLAYCHANGE"); break;
         case WM_GETICON: writeWm("WM_GETICON"); break;
         case WM_SETICON: writeWm("WM_SETICON"); break;
         case WM_NCCREATE: writeWm("WM_NCCREATE"); break;
         case WM_NCDESTROY: writeWm("WM_NCDESTROY"); break;
         case WM_NCCALCSIZE: writeWm("WM_NCCALCSIZE"); break;
         case WM_NCHITTEST: writeWm("WM_NCHITTEST"); break;
         case WM_NCPAINT: writeWm("WM_NCPAINT"); break;
         case WM_NCACTIVATE: writeWm("WM_NCACTIVATE"); break;
         case WM_GETDLGCODE: writeWm("WM_GETDLGCODE"); break;
         case WM_NCMOUSEMOVE: writeWm("WM_NCMOUSEMOVE"); break;
         case WM_NCLBUTTONDOWN: writeWm("WM_NCLBUTTONDOWN"); break;
         case WM_NCLBUTTONUP: writeWm("WM_NCLBUTTONUP"); break;
         case WM_NCLBUTTONDBLCLK: writeWm("WM_NCLBUTTONDBLCLK"); break;
         case WM_NCRBUTTONDOWN: writeWm("WM_NCRBUTTONDOWN"); break;
         case WM_NCRBUTTONUP: writeWm("WM_NCRBUTTONUP"); break;
         case WM_NCRBUTTONDBLCLK: writeWm("WM_NCRBUTTONDBLCLK"); break;
         case WM_NCMBUTTONDOWN: writeWm("WM_NCMBUTTONDOWN"); break;
         case WM_NCMBUTTONUP: writeWm("WM_NCMBUTTONUP"); break;
         case WM_NCMBUTTONDBLCLK: writeWm("WM_NCMBUTTONDBLCLK"); break;
         case WM_KEYDOWN: writeWm("WM_KEYDOWN"); break;
         case WM_KEYUP: writeWm("WM_KEYUP"); break;
         case WM_CHAR: writeWm("WM_CHAR"); break;
         case WM_DEADCHAR: writeWm("WM_DEADCHAR"); break;
         case WM_SYSKEYDOWN: writeWm("WM_SYSKEYDOWN"); break;
         case WM_SYSKEYUP: writeWm("WM_SYSKEYUP"); break;
         case WM_SYSCHAR: writeWm("WM_SYSCHAR"); break;
         case WM_SYSDEADCHAR: writeWm("WM_SYSDEADCHAR"); break;
         case WM_IME_STARTCOMPOSITION: writeWm("WM_IME_STARTCOMPOSITION"); break;
         case WM_IME_ENDCOMPOSITION: writeWm("WM_IME_ENDCOMPOSITION"); break;
         case WM_IME_COMPOSITION: writeWm("WM_IME_COMPOSITION"); break;
         case WM_INITDIALOG: writeWm("WM_INITDIALOG"); break;
         case WM_COMMAND: writeWm("WM_COMMAND"); break;
         case WM_SYSCOMMAND: writeWm("WM_SYSCOMMAND"); break;
         case WM_TIMER: writeWm("WM_TIMER"); break;
         case WM_HSCROLL: writeWm("WM_HSCROLL"); break;
         case WM_VSCROLL: writeWm("WM_VSCROLL"); break;
         case WM_INITMENU: writeWm("WM_INITMENU"); break;
         case WM_INITMENUPOPUP: writeWm("WM_INITMENUPOPUP"); break;
         case WM_MENUSELECT: writeWm("WM_MENUSELECT"); break;
         case WM_MENUCHAR: writeWm("WM_MENUCHAR"); break;
         case WM_ENTERIDLE: writeWm("WM_ENTERIDLE"); break;
         case WM_CTLCOLORMSGBOX: writeWm("WM_CTLCOLORMSGBOX"); break;
         case WM_CTLCOLOREDIT: writeWm("WM_CTLCOLOREDIT"); break;
         case WM_CTLCOLORLISTBOX: writeWm("WM_CTLCOLORLISTBOX"); break;
         case WM_CTLCOLORBTN: writeWm("WM_CTLCOLORBTN"); break;
         case WM_CTLCOLORDLG: writeWm("WM_CTLCOLORDLG"); break;
         case WM_CTLCOLORSCROLLBAR: writeWm("WM_CTLCOLORSCROLLBAR"); break;
         case WM_CTLCOLORSTATIC: writeWm("WM_CTLCOLORSTATIC"); break;
         case WM_MOUSEMOVE: writeWm("WM_MOUSEMOVE"); break;
         case WM_LBUTTONDOWN: writeWm("WM_LBUTTONDOWN"); break;
         case WM_LBUTTONUP: writeWm("WM_LBUTTONUP"); break;
         case WM_LBUTTONDBLCLK: writeWm("WM_LBUTTONDBLCLK"); break;
         case WM_RBUTTONDOWN: writeWm("WM_RBUTTONDOWN"); break;
         case WM_RBUTTONUP: writeWm("WM_RBUTTONUP"); break;
         case WM_RBUTTONDBLCLK: writeWm("WM_RBUTTONDBLCLK"); break;
         case WM_MBUTTONDOWN: writeWm("WM_MBUTTONDOWN"); break;
         case WM_MBUTTONUP: writeWm("WM_MBUTTONUP"); break;
         case WM_MBUTTONDBLCLK: writeWm("WM_MBUTTONDBLCLK"); break;
         case WM_PARENTNOTIFY: writeWm("WM_PARENTNOTIFY"); break;
         case WM_ENTERMENULOOP: writeWm("WM_ENTERMENULOOP"); break;
         case WM_EXITMENULOOP: writeWm("WM_EXITMENULOOP"); break;
         case WM_NEXTMENU: writeWm("WM_NEXTMENU"); break;
         case WM_SETFONT: writeWm("WM_SETFONT"); break;
         case WM_GETFONT: writeWm("WM_GETFONT"); break;
         case WM_USER: writeWm("WM_USER"); break;
         case WM_NEXTDLGCTL: writeWm("WM_NEXTDLGCTL"); break;
         case WM_CAPTURECHANGED: writeWm("WM_CAPTURECHANGED"); break;
         case WM_WINDOWPOSCHANGING: writeWm("WM_WINDOWPOSCHANGING"); break;
         case WM_WINDOWPOSCHANGED: writeWm("WM_WINDOWPOSCHANGED"); break;
         case WM_DRAWITEM: writeWm("WM_DRAWITEM"); break;
         case WM_CLEAR: writeWm("WM_CLEAR"); break;
         case WM_CUT: writeWm("WM_CUT"); break;
         case WM_COPY: writeWm("WM_COPY"); break;
         case WM_PASTE: writeWm("WM_PASTE"); break;
         case WM_MDITILE: writeWm("WM_MDITILE"); break;
         case WM_MDICASCADE: writeWm("WM_MDICASCADE"); break;
         case WM_MDIICONARRANGE: writeWm("WM_MDIICONARRANGE"); break;
         case WM_MDIGETACTIVE: writeWm("WM_MDIGETACTIVE"); break;
         case WM_MOUSEWHEEL: writeWm("WM_MOUSEWHEEL"); break;
         case WM_MOUSEHOVER: writeWm("WM_MOUSEHOVER"); break;
         case WM_MOUSELEAVE: writeWm("WM_MOUSELEAVE"); break;
         case WM_PRINT: writeWm("WM_PRINT"); break;
         case WM_PRINTCLIENT: writeWm("WM_PRINTCLIENT"); break;
         case WM_MEASUREITEM: writeWm("WM_MEASUREITEM"); break;

         default:
            if(m.msg >= WM_USER && m.msg <= 0x7FFF) {
               writeWm("WM_USER+" ~ std..string.toString(m.msg - WM_USER));
            } else if(m.msg >=0xC000 && m.msg <= 0xFFFF) {
               writeWm("RegisterWindowMessage");
            } else {
               writeWm("?");
            }
      }

      Control ctrl;
      ctrl = Application.lookupHwnd(m.hWnd);
      writef("HWND=%d(0x%X) %s WPARAM=%d(0x%X) LPARAM=%d(0x%X)\n\n",
             cast(size_t)m.hWnd, cast(size_t)m.hWnd,
             ctrl ? ("DFLname='" ~ ctrl.name ~ "'") : "<nonDFL>",
             m.wParam, m.wParam,
             m.lParam, m.lParam);

      debug(MESSAGE_PAUSE) {
         Sleep(50);
      }
   }
}


extern(Windows) LRESULT dflWndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) nothrow {
   //cprintf("HWND %p; WM %d(0x%X); WPARAM %d(0x%X); LPARAM %d(0x%X);\n", hwnd, msg, msg, wparam, wparam, lparam, lparam);

   if(msg == wmDfl) {
      switch(wparam) {
         case WPARAM_DFL_INVOKE: {
               InvokeData* pinv;
               pinv = cast(InvokeData*)lparam;
               try {
                  pinv.result = pinv.dg(pinv.args);
               } catch(DThrowable e) {
                  //Application.onThreadException(e);
                  try {
                     pinv.exception = e;
                  } catch(DThrowable e2) {
                     Application.onThreadException(e2);
                  }
               }
            }
            return LRESULT_DFL_INVOKE;

         case WPARAM_DFL_INVOKE_SIMPLE: {
               InvokeSimpleData* pinv;
               pinv = cast(InvokeSimpleData*)lparam;
               try {
                  pinv.dg();
               } catch(DThrowable e) {
                  //Application.onThreadException(e);
                  try {
                     pinv.exception = e;
                  } catch(DThrowable e2) {
                     Application.onThreadException(e2);
                  }
               }
            }
            return LRESULT_DFL_INVOKE;

         case WPARAM_DFL_DELAY_INVOKE:
            try {
               (cast(void function())lparam)();
            } catch(DThrowable e) {
               Application.onThreadException(e);
            }
            break;

         case WPARAM_DFL_DELAY_INVOKE_PARAMS: {
               DflInvokeParam* p;
               p = cast(DflInvokeParam*)lparam;
               try {
                  p.fp(Application.lookupHwnd(hwnd), p.params.ptr[0 .. p.nparams]);
               } catch(DThrowable e) {
                  Application.onThreadException(e);
               }
               dfl.internal.clib.free(p);
            }
            break;

         default:
      }
   }

   Message dm = Message(hwnd, msg, wparam, lparam);
   Control ctrl;

   debug(SHOW_MESSAGE_INFO)
   showMessageInfo(dm);

   if(msg == WM_NCCREATE) {
      ctrl = Application.getCreatingControl();
      if(!ctrl) {
         debug(APP_PRINT)
         cprintf("Unable to add window 0x%X.\n", hwnd);
         return dm.result;
      }
      Application.creatingControl(null); // Reset.

      Application.controls[hwnd] = ctrl;
      ctrl.hwnd = hwnd;
      debug(APP_PRINT)
      cprintf("Added window 0x%X.\n", hwnd);

      //ctrl.finishCreating(hwnd);
      goto do_msg;
   }

   ctrl = Application.lookupHwnd(hwnd);

   if(!ctrl) {
      // Zombie...
      //return 1; // Returns correctly for most messages. e.g. WM_QUERYENDSESSION, WM_NCACTIVATE.
      dm.result = 1;
      version(DFL_NO_ZOMBIE_FORM) {
      }
      else {
         ctrl = cast(Control)cast(void*)GetPropA(hwnd, Application.ZOMBIE_PROP.ptr);
         if(ctrl) {
            ctrl.mustWndProc(dm);
         }
      }
      return dm.result;
   }

   if(ctrl) {
   do_msg:
      try {
         ctrl.mustWndProc(dm);
         if(!ctrl.preProcessMessage(dm)) {
            ctrl._wndProc(dm);
         }
      } catch (DThrowable e) {
         Application.onThreadException(e);
      }
   }
   return dm.result;
}


version(CUSTOM_MSG_HOOK) {
   alias CWPRETSTRUCT CustomMsg;


   // Needs to be re-entrant.
   extern(Windows) LRESULT globalMsgHook(int code, WPARAM wparam, LPARAM lparam) {
      if(code == HC_ACTION) {
         CustomMsg* msg = cast(CustomMsg*)lparam;
         Control ctrl;

         switch(msg.message) {
               // ...
         }
      }

      return CallNextHookEx(Application.msghook, code, wparam, lparam);
   }
}
else {
   /+
   struct CustomMsg {
      HWND hwnd;
      UINT message;
      WPARAM wParam;
      LPARAM lParam;
   }
   +/
}


enum LRESULT LRESULT_DFL_INVOKE = 0x95FADF; // Magic number.


struct InvokeData {
   Object delegate(Object[]) dg;
   Object[] args;
   Object result;
   DThrowable exception = null;
}


struct InvokeSimpleData {
   void delegate() dg;
   DThrowable exception = null;
}


UINT wmDfl;

enum: WPARAM {
   WPARAM_DFL_INVOKE = 78,
   WPARAM_DFL_DELAY_INVOKE = 79,
   WPARAM_DFL_DELAY_INVOKE_PARAMS = 80,
   WPARAM_DFL_INVOKE_SIMPLE = 81,
}

struct DflInvokeParam {
   void function(Control, size_t[]) fp;
   size_t nparams;
   size_t[1] params;
}


version(DFL_NO_WM_GETCONTROLNAME) {
}
else {
   UINT wmGetControlName;
}


extern(Windows) {
   alias BOOL function(LPTRACKMOUSEEVENT lpEventTrack) TrackMouseEventProc;
   alias BOOL function(HWND, COLORREF, BYTE, DWORD) SetLayeredWindowAttributesProc;

   alias HTHEME function(HWND) GetWindowThemeProc;
   alias BOOL function(HTHEME hTheme, int iPartId, int iStateId) IsThemeBackgroundPartiallyTransparentProc;
   alias HRESULT function(HWND hwnd, HDC hdc, RECT* prc) DrawThemeParentBackgroundProc;
   alias void function(DWORD dwFlags) SetThemeAppPropertiesProc;
}


// Set version = SUPPORTS_MOUSE_TRACKING if it is guaranteed to be supported.
TrackMouseEventProc trackMouseEvent;

// Set version = SUPPORTS_OPACITY if it is guaranteed to be supported.
SetLayeredWindowAttributesProc setLayeredWindowAttributes;

/+
GetWindowThemeProc getWindowTheme;
IsThemeBackgroundPartiallyTransparentProc isThemeBackgroundPartiallyTransparent;
DrawThemeParentBackgroundProc drawThemeParentBackground;
SetThemeAppPropertiesProc setThemeAppProperties;
+/


enum CONTROL_CLASSNAME = "DFL_Control";
enum FORM_CLASSNAME = "DFL_Form";
enum TEXTBOX_CLASSNAME = "DFL_TextBox";
enum LISTBOX_CLASSNAME = "DFL_ListBox";
//enum LABEL_CLASSNAME = "DFL_Label";
enum BUTTON_CLASSNAME = "DFL_Button";
enum MDICLIENT_CLASSNAME = "DFL_MdiClient";
enum RICHTEXTBOX_CLASSNAME = "DFL_RichTextBox";
enum COMBOBOX_CLASSNAME = "DFL_ComboBox";
enum TREEVIEW_CLASSNAME = "DFL_TreeView";
enum TABCONTROL_CLASSNAME = "DFL_TabControl";
enum LISTVIEW_CLASSNAME = "DFL_ListView";
enum STATUSBAR_CLASSNAME = "DFL_StatusBar";
enum PROGRESSBAR_CLASSNAME = "DFL_ProgressBar";

WNDPROC textBoxPrevWndProc;
WNDPROC listboxPrevWndProc;
//WNDPROC labelPrevWndProc;
WNDPROC buttonPrevWndProc;
WNDPROC mdiclientPrevWndProc;
WNDPROC richtextboxPrevWndProc;
WNDPROC comboboxPrevWndProc;
WNDPROC treeviewPrevWndProc;
WNDPROC tabcontrolPrevWndProc;
WNDPROC listviewPrevWndProc;
WNDPROC statusbarPrevWndProc;
WNDPROC progressbarPrevWndProc;

LONG textBoxClassStyle;
LONG listboxClassStyle;
//LONG labelClassStyle;
LONG buttonClassStyle;
LONG mdiclientClassStyle;
LONG richtextboxClassStyle;
LONG comboboxClassStyle;
LONG treeviewClassStyle;
LONG tabcontrolClassStyle;
LONG listviewClassStyle;
LONG statusbarClassStyle;
LONG progressbarClassStyle;

HMODULE hmodRichtextbox;

// DMD 0.93: CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS is not an expression
//enum UINT WNDCLASS_STYLE = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
//enum UINT WNDCLASS_STYLE = 11;

//enum UINT WNDCLASS_STYLE = CS_DBLCLKS;
// DMD 0.106: CS_DBLCLKS is not an expression
enum UINT WNDCLASS_STYLE = 0x0008;


extern(Windows) {
   alias BOOL function(LPINITCOMMONCONTROLSEX lpInitCtrls) InitCommonControlsExProc;
}


// For this to work properly on Windows 95, Internet Explorer 4.0 must be installed.
void _initCommonControls(DWORD dwControls) {
   version(SUPPORTS_COMMON_CONTROLS_EX) {
      pragma(msg, "DFL: extended common controls supported at compile time");

      alias InitCommonControlsEx initProc;
   }
   else {
      // Make sure InitCommonControlsEx() is in comctl32.dll,
      // otherwise use the old InitCommonControls().

      HMODULE hmodCommonControls;
      InitCommonControlsExProc initProc;

      hmodCommonControls = LoadLibraryA("comctl32.dll");
      if(!hmodCommonControls)
         // throw new DflException("Unable to load 'comctl32.dll'");
      {
         goto no_comctl32;
      }

      initProc = cast(InitCommonControlsExProc)GetProcAddress(hmodCommonControls, "InitCommonControlsEx");
      if(!initProc) {
         //FreeLibrary(hmodCommonControls);
      no_comctl32:
         InitCommonControls();
         return;
      }
   }

   INITCOMMONCONTROLSEX icce;
   icce.dwSize = INITCOMMONCONTROLSEX.sizeof;
   icce.dwICC = dwControls;
   initProc(&icce);
}


extern(C) {
   size_t C_refCountInc(void* p) {
      return Application._doref(p, 1);
   }


   // Returns the new ref count.
   size_t C_refCountDec(void* p) {
      return Application._doref(p, -1);
   }
}


static this() {
   dfl.internal.utf._utfinit();

   Application.tlsThreadFlags = TlsAlloc();
   Application.tlsControl = TlsAlloc();
   Application.tlsFilter = TlsAlloc();
   version(CUSTOM_MSG_HOOK)
   Application.tlsHook = TlsAlloc();

   wmDfl = RegisterWindowMessageA("WM_DFL");
   if(!wmDfl) {
      wmDfl = WM_USER + 0x7CD;
   }

   version(DFL_NO_WM_GETCONTROLNAME) {
   }
   else {
      wmGetControlName = RegisterWindowMessageA("WM_GETCONTROLNAME");
   }

   //InitCommonControls(); // Done later. Needs to be linked with comctl32.lib.
   OleInitialize(null); // Needs to be linked with ole32.lib.

   HMODULE user32 = GetModuleHandleA("user32.dll");

   version(SUPPORTS_MOUSE_TRACKING) {
      pragma(msg, "DFL: mouse tracking supported at compile time");

      trackMouseEvent = &TrackMouseEvent;
   }
   else {
      trackMouseEvent = cast(TrackMouseEventProc)GetProcAddress(user32, "TrackMouseEvent");
      if(!trackMouseEvent) { // Must be Windows 95; check if common controls has it (IE 5.5).
         trackMouseEvent = cast(TrackMouseEventProc)GetProcAddress(GetModuleHandleA("comctl32.dll"), "_TrackMouseEvent");
      }
   }

   version(SUPPORTS_OPACITY) {
      pragma(msg, "DFL: opacity supported at compile time");

      setLayeredWindowAttributes = &SetLayeredWindowAttributes;
   }
   else {
      setLayeredWindowAttributes = cast(SetLayeredWindowAttributesProc)GetProcAddress(user32, "SetLayeredWindowAttributes");
   }
}


static ~this() {
   version(DFL_NO_MENUS) {
   }
   else {
      Application.sdtorFreeAllMenus();
   }

   if(hmodRichtextbox) {
      FreeLibrary(hmodRichtextbox);
   }
}


void _unableToInit(Dstring what) {
   /+if(what.length > 4
         && what[0] == 'D' && what[1] == 'F'
         && what[2] == 'L' && what[3] == '_')+/
      what = what[4 .. what.length];
   throw new DflException("Unable to initialize " ~ what);
}


void _initInstance() {
   return _initInstance(GetModuleHandleA(null));
}


void _initInstance(HINSTANCE inst)
in {
   assert(!Application.hinst);
   assert(inst);
}
body {
   Application.hinst = inst;

   dfl.internal.utf.WndClass wc;
   wc.wc.style = WNDCLASS_STYLE;
   wc.wc.hInstance = inst;
   wc.wc.lpfnWndProc = &dflWndProc;

   // Control wndclass.
   wc.className = CONTROL_CLASSNAME;
   if(!dfl.internal.utf.registerClass(wc)) {
      _unableToInit(CONTROL_CLASSNAME);
   }

   // Form wndclass.
   wc.wc.cbWndExtra = DLGWINDOWEXTRA;
   wc.className = FORM_CLASSNAME;
   if(!dfl.internal.utf.registerClass(wc)) {
      _unableToInit(FORM_CLASSNAME);
   }
}


extern(Windows) {
   void _initTextBox() {
      if(!textBoxPrevWndProc) {
         dfl.internal.utf.WndClass info;
         textBoxPrevWndProc = superClass(HINSTANCE.init, "EDIT", TEXTBOX_CLASSNAME, info);
         if(!textBoxPrevWndProc) {
            _unableToInit(TEXTBOX_CLASSNAME);
         }
         textBoxClassStyle = info.wc.style;
      }
   }


   void _initListbox() {
      if(!listboxPrevWndProc) {
         dfl.internal.utf.WndClass info;
         listboxPrevWndProc = superClass(HINSTANCE.init, "LISTBOX", LISTBOX_CLASSNAME, info);
         if(!listboxPrevWndProc) {
            _unableToInit(LISTBOX_CLASSNAME);
         }
         listboxClassStyle = info.wc.style;
      }
   }


   /+
   void _initLabel() {
      if(!labelPrevWndProc) {
         dfl.internal.utf.WndClass info;
         labelPrevWndProc = superClass(HINSTANCE.init, "STATIC", LABEL_CLASSNAME, info);
         if(!labelPrevWndProc) {
            _unableToInit(LABEL_CLASSNAME);
         }
         labelClassStyle = info.wc.style;
      }
   }
   +/


   void _initButton() {
      if(!buttonPrevWndProc) {
         dfl.internal.utf.WndClass info;
         buttonPrevWndProc = superClass(HINSTANCE.init, "BUTTON", BUTTON_CLASSNAME, info);
         if(!buttonPrevWndProc) {
            _unableToInit(BUTTON_CLASSNAME);
         }
         buttonClassStyle = info.wc.style;
      }
   }


   void _initMdiclient() {
      if(!mdiclientPrevWndProc) {
         dfl.internal.utf.WndClass info;
         mdiclientPrevWndProc = superClass(HINSTANCE.init, "MDICLIENT", MDICLIENT_CLASSNAME, info);
         if(!mdiclientPrevWndProc) {
            _unableToInit(MDICLIENT_CLASSNAME);
         }
         mdiclientClassStyle = info.wc.style;
      }
   }


   void _initRichtextbox() {
      if(!richtextboxPrevWndProc) {
         if(!hmodRichtextbox) {
            hmodRichtextbox = LoadLibraryA("riched20.dll");
            if(!hmodRichtextbox) {
               throw new DflException("Unable to load 'riched20.dll'");
            }
         }

         Dstring classname;
         if(dfl.internal.utf.useUnicode) {
            classname = "RichEdit20W";
         } else {
            classname = "RichEdit20A";
         }

         dfl.internal.utf.WndClass info;
         richtextboxPrevWndProc = superClass(HINSTANCE.init, classname, RICHTEXTBOX_CLASSNAME, info);
         if(!richtextboxPrevWndProc) {
            _unableToInit(RICHTEXTBOX_CLASSNAME);
         }
         richtextboxClassStyle = info.wc.style;
      }
   }


   void _initCombobox() {
      if(!comboboxPrevWndProc) {
         dfl.internal.utf.WndClass info;
         comboboxPrevWndProc = superClass(HINSTANCE.init, "COMBOBOX", COMBOBOX_CLASSNAME, info);
         if(!comboboxPrevWndProc) {
            _unableToInit(COMBOBOX_CLASSNAME);
         }
         comboboxClassStyle = info.wc.style;
      }
   }


   void _initTreeview() {
      if(!treeviewPrevWndProc) {
         _initCommonControls(ICC_TREEVIEW_CLASSES);

         dfl.internal.utf.WndClass info;
         treeviewPrevWndProc = superClass(HINSTANCE.init, "SysTreeView32", TREEVIEW_CLASSNAME, info);
         if(!treeviewPrevWndProc) {
            _unableToInit(TREEVIEW_CLASSNAME);
         }
         treeviewClassStyle = info.wc.style;
      }
   }


   void _initTabcontrol() {
      if(!tabcontrolPrevWndProc) {
         _initCommonControls(ICC_TAB_CLASSES);

         dfl.internal.utf.WndClass info;
         tabcontrolPrevWndProc = superClass(HINSTANCE.init, "SysTabControl32", TABCONTROL_CLASSNAME, info);
         if(!tabcontrolPrevWndProc) {
            _unableToInit(TABCONTROL_CLASSNAME);
         }
         tabcontrolClassStyle = info.wc.style;
      }
   }


   void _initListview() {
      if(!listviewPrevWndProc) {
         _initCommonControls(ICC_LISTVIEW_CLASSES);

         dfl.internal.utf.WndClass info;
         listviewPrevWndProc = superClass(HINSTANCE.init, "SysListView32", LISTVIEW_CLASSNAME, info);
         if(!listviewPrevWndProc) {
            _unableToInit(LISTVIEW_CLASSNAME);
         }
         listviewClassStyle = info.wc.style;
      }
   }


   void _initStatusbar() {
      if(!statusbarPrevWndProc) {
         _initCommonControls(ICC_WIN95_CLASSES);

         dfl.internal.utf.WndClass info;
         statusbarPrevWndProc = superClass(HINSTANCE.init, "msctls_statusbar32", STATUSBAR_CLASSNAME, info);
         if(!statusbarPrevWndProc) {
            _unableToInit(STATUSBAR_CLASSNAME);
         }
         statusbarClassStyle = info.wc.style;
      }
   }


   void _initProgressbar() {
      if(!progressbarPrevWndProc) {
         _initCommonControls(ICC_PROGRESS_CLASS);

         dfl.internal.utf.WndClass info;
         progressbarPrevWndProc = superClass(HINSTANCE.init, "msctls_progress32", PROGRESSBAR_CLASSNAME, info);
         if(!progressbarPrevWndProc) {
            _unableToInit(PROGRESSBAR_CLASSNAME);
         }
         progressbarClassStyle = info.wc.style;
      }
   }
}


WNDPROC _superClass(HINSTANCE hinst, Dstring className, Dstring newClassName, out WNDCLASSA getInfo) { // deprecated
   WNDPROC wndProc;

   if(!GetClassInfoA(hinst, unsafeStringz(className), &getInfo)) { // TODO: unicode.
      throw new DflException("Unable to obtain information for window class '" ~ className ~ "'");
   }

   wndProc = getInfo.lpfnWndProc;
   getInfo.lpfnWndProc = &dflWndProc;

   getInfo.style &= ~CS_GLOBALCLASS;
   getInfo.hCursor = HCURSOR.init;
   getInfo.lpszClassName = unsafeStringz(newClassName);
   getInfo.hInstance = Application.getInstance();

   if(!RegisterClassA(&getInfo)) // TODO: unicode.
      //throw new DflException("Unable to register window class '" ~ newClassName ~ "'");
   {
      return null;
   }
   return wndProc;
}


public:

// Returns the old wndProc.
// This is the old, unsafe, unicode-unfriendly function for superclassing.
deprecated WNDPROC superClass(HINSTANCE hinst, Dstring className, Dstring newClassName, out WNDCLASSA getInfo) { // package
   return _superClass(hinst, className, newClassName, getInfo);
}


deprecated WNDPROC superClass(HINSTANCE hinst, Dstring className, Dstring newClassName) { // package
   WNDCLASSA info;
   return _superClass(hinst, className, newClassName, info);
}


// Returns the old wndProc.
WNDPROC superClass(HINSTANCE hinst, Dstring className, Dstring newClassName, out dfl.internal.utf.WndClass getInfo) { // package
   WNDPROC wndProc;

   if(!dfl.internal.utf.getClassInfo(hinst, className, getInfo)) {
      throw new DflException("Unable to obtain information for window class '" ~ className ~ "'");
   }

   wndProc = getInfo.wc.lpfnWndProc;
   getInfo.wc.lpfnWndProc = &dflWndProc;

   getInfo.wc.style &= ~CS_GLOBALCLASS;
   getInfo.wc.hCursor = HCURSOR.init;
   getInfo.className = newClassName;
   getInfo.wc.hInstance = Application.getInstance();

   if(!dfl.internal.utf.registerClass(getInfo))
      //throw new DflException("Unable to register window class '" ~ newClassName ~ "'");
   {
      return null;
   }
   return wndProc;
}