src/ui/dialog/filedialogimpl-win32.cpp

   1 /**
   2  * Implementation of the file dialog interfaces defined in filedialog.h for Win32
   3  *
   4  * Authors:
   5  *   Joel Holdsworth
   6  *   The Inkscape Organization
   7  *
   8  * Copyright (C) 2004-2008 The Inkscape Organization
   9  *
  10  * Released under GNU GPL, read the file 'COPYING' for more information
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include <config.h>
  15 #endif
  16
  17 #ifdef WIN32
  18
  19 //General includes
  20 #include <list>
  21 #include <unistd.h>
  22 #include <sys/stat.h>
  23 #include <errno.h>
  24 #include <set>
  25 #include <gdk/gdkwin32.h>
  26 #include <glib/gstdio.h>
  27 #include <glibmm/i18n.h>
  28 #include <gtkmm/window.h>
  29
  30 //Inkscape includes
  31 #include "inkscape.h"
  32 #include "prefs-utils.h"
  33 #include <dialogs/dialog-events.h>
  34 #include <extension/input.h>
  35 #include <extension/output.h>
  36 #include <extension/db.h>
  37
  38 #include <libnr/nr-pixops.h>
  39 #include <libnr/nr-translate-scale-ops.h>
  40 #include <display/nr-arena-item.h>
  41 #include <display/nr-arena.h>
  42 #include "sp-item.h"
  43 #include "canvas-arena.h"
  44
  45 #include "filedialog.h"
  46 #include "filedialogimpl-win32.h"
  47
  48 #include <zlib.h>
  49 #include <cairomm/win32_surface.h>
  50 #include <cairomm/context.h>
  51
  52 using namespace std;
  53 using namespace Glib;
  54 using namespace Cairo;
  55 using namespace Gdk::Cairo;
  56
  57 namespace Inkscape
  58 {
  59 namespace UI
  60 {
  61 namespace Dialog
  62 {
  63
  64 const int PreviewWidening = 150;
  65 const char PreviewWindowClassName[] = "PreviewWnd";
  66 const unsigned long MaxPreviewFileSize = 1344; // kB
  67
  68 #define IDC_SHOW_PREVIEW    1000
  69
  70 // Windows 2000 version of OPENFILENAMEW
  71 struct OPENFILENAMEEXW : public OPENFILENAMEW {
  72   void *        pvReserved;
  73   DWORD         dwReserved;
  74   DWORD         FlagsEx;
  75 };
  76
  77 struct Filter
  78 {
  79     gunichar2* name;
  80     glong name_length;
  81     gunichar2* filter;
  82     glong filter_length;
  83     Inkscape::Extension::Extension* mod;
  84 };
  85
  86 ustring utf16_to_ustring(const wchar_t *utf16string, int utf16length = -1)
  87 {
  88     gchar *utf8string = g_utf16_to_utf8((const gunichar2*)utf16string,
  89         utf16length, NULL, NULL, NULL);
  90     ustring result(utf8string);
  91     g_free(utf8string);
  92
  93     return result;
  94 }
  95
  96 /*#########################################################################
  97 ### F I L E     D I A L O G    B A S E    C L A S S
  98 #########################################################################*/
  99
 100 FileDialogBaseWin32::FileDialogBaseWin32(Gtk::Window &parent,
 101         const Glib::ustring &dir, const gchar *title,
 102         FileDialogType type, gchar const* /*preferenceBase*/) :
 103         dialogType(type),
 104         parent(parent),
 105         _current_directory(dir)
 106 {
 107     _main_loop = NULL;
 108
 109         _filter_index = 1;
 110         _filter_count = 0;
 111
 112     _title = (wchar_t*)g_utf8_to_utf16(title, -1, NULL, NULL, NULL);
 113         g_assert(_title != NULL);
 114
 115     Glib::RefPtr<const Gdk::Window> parentWindow = parent.get_window();
 116     g_assert(parentWindow->gobj() != NULL);
 117     _ownerHwnd = (HWND)gdk_win32_drawable_get_handle((GdkDrawable*)parentWindow->gobj());
 118 }
 119
 120 FileDialogBaseWin32::~FileDialogBaseWin32()
 121 {
 122     g_free(_title);
 123 }
 124
 125 Inkscape::Extension::Extension *FileDialogBaseWin32::getSelectionType()
 126 {
 127     return _extension;
 128 }
 129
 130 Glib::ustring FileDialogBaseWin32::getCurrentDirectory()
 131 {
 132     return _current_directory;
 133 }
 134
 135 /*#########################################################################
 136 ### F I L E    O P E N
 137 #########################################################################*/
 138
 139 bool FileOpenDialogImplWin32::_show_preview = true;
 140
 141 /**
 142  * Constructor.  Not called directly.  Use the factory.
 143  */
 144 FileOpenDialogImplWin32::FileOpenDialogImplWin32(Gtk::Window &parent,
 145                                        const Glib::ustring &dir,
 146                                        FileDialogType fileTypes,
 147                                        const gchar *title) :
 148     FileDialogBaseWin32(parent, dir, title, fileTypes, "dialogs.open")
 149 {
 150     // Initalize to Autodetect
 151     _extension = NULL;
 152
 153     // Set our dialog type (open, import, etc...)
 154     dialogType = fileTypes;
 155
 156     _show_preview_button_bitmap = NULL;
 157     _preview_wnd = NULL;
 158     _file_dialog_wnd = NULL;
 159     _base_window_proc = NULL;
 160
 161     _preview_file_size = 0;
 162     _preview_bitmap = NULL;
 163     _preview_file_icon = NULL;
 164     _preview_document_width = 0;
 165     _preview_document_height = 0;
 166     _preview_image_width = 0;
 167     _preview_image_height = 0;
 168
 169         _mutex = NULL;
 170
 171     createFilterMenu();
 172 }
 173
 174
 175 /**
 176  * Destructor
 177  */
 178 FileOpenDialogImplWin32::~FileOpenDialogImplWin32()
 179 {
 180     if(_filter != NULL)
 181         delete[] _filter;
 182     if(_extension_map != NULL)
 183         delete[] _extension_map;
 184 }
 185
 186 void FileOpenDialogImplWin32::createFilterMenu()
 187 {
 188     list<Filter> filter_list;
 189
 190     // Compose the filter string
 191     Inkscape::Extension::DB::InputList extension_list;
 192     Inkscape::Extension::db.get_input_list(extension_list);
 193
 194     ustring all_inkscape_files_filter, all_image_files_filter;
 195     Filter all_files, all_inkscape_files, all_image_files;
 196
 197     const gchar *all_files_filter_name = N_("All Files");
 198     const gchar *all_inkscape_files_filter_name = N_("All Inkscape Files");
 199     const gchar *all_image_files_filter_name = N_("All Image Files");
 200
 201     // Calculate the amount of memory required
 202     int filter_count = 3;       // 3 - one for All Files, All Images and All Inkscape Files
 203     int filter_length = 1;
 204
 205     for (Inkscape::Extension::DB::InputList::iterator current_item = extension_list.begin();
 206          current_item != extension_list.end(); current_item++)
 207     {
 208         Filter filter;
 209
 210         Inkscape::Extension::Input *imod = *current_item;
 211         if (imod->deactivated()) continue;
 212
 213         // Type
 214         filter.name = g_utf8_to_utf16(_(imod->get_filetypename()),
 215             -1, NULL, &filter.name_length, NULL);
 216
 217         // Extension
 218         const gchar *file_extension_name = imod->get_extension();
 219         filter.filter = g_utf8_to_utf16(file_extension_name,
 220             -1, NULL, &filter.filter_length, NULL);
 221
 222         filter.mod = imod;
 223         filter_list.push_back(filter);
 224
 225         filter_length += filter.name_length +
 226             filter.filter_length + 3;   // Add 3 for two \0s and a *
 227
 228         // Add to the "All Inkscape Files" Entry
 229         if(all_inkscape_files_filter.length() > 0)
 230             all_inkscape_files_filter += ";*";
 231         all_inkscape_files_filter += file_extension_name;
 232         if( strncmp("image", imod->get_mimetype(), 5) == 0)
 233         {
 234             // Add to the "All Image Files" Entry
 235             if(all_image_files_filter.length() > 0)
 236                 all_image_files_filter += ";*";
 237             all_image_files_filter += file_extension_name;
 238         }
 239
 240         filter_count++;
 241     }
 242
 243     int extension_index = 0;
 244     _extension_map = new Inkscape::Extension::Extension*[filter_count + 3];
 245
 246     // Filter Image Files
 247     all_image_files.name = g_utf8_to_utf16(all_image_files_filter_name,
 248         -1, NULL, &all_image_files.name_length, NULL);
 249     all_image_files.filter = g_utf8_to_utf16(all_image_files_filter.data(),
 250             -1, NULL, &all_image_files.filter_length, NULL);
 251     filter_list.push_front(all_image_files);
 252     _extension_map[extension_index++] = NULL;
 253
 254     // Filter Inkscape Files
 255     all_inkscape_files.name = g_utf8_to_utf16(all_inkscape_files_filter_name,
 256         -1, NULL, &all_inkscape_files.name_length, NULL);
 257     all_inkscape_files.filter = g_utf8_to_utf16(all_inkscape_files_filter.data(),
 258             -1, NULL, &all_inkscape_files.filter_length, NULL);
 259     filter_list.push_front(all_inkscape_files);
 260     _extension_map[extension_index++] = NULL;
 261
 262     // Filter All Files
 263     all_files.name = g_utf8_to_utf16(all_files_filter_name,
 264         -1, NULL, &all_files.name_length, NULL);
 265     all_files.filter = NULL;
 266     all_files.filter_length = 0;
 267     filter_list.push_front(all_files);
 268     _extension_map[extension_index++] = NULL;
 269
 270     filter_length += all_files.name_length + 3 +
 271                     all_inkscape_files.filter_length +
 272                     all_inkscape_files.name_length + 3 +
 273                     all_image_files.filter_length +
 274                     all_image_files.name_length + 3 + 1;
 275      // Add 3 for 2*2 \0s and a *, and 1 for a trailing \0
 276
 277         _filter = new wchar_t[filter_length];
 278     wchar_t *filterptr = _filter;
 279
 280     for(list<Filter>::iterator filter_iterator = filter_list.begin();
 281         filter_iterator != filter_list.end(); filter_iterator++)
 282     {
 283         const Filter &filter = *filter_iterator;
 284
 285         wcsncpy(filterptr, (wchar_t*)filter.name, filter.name_length);
 286         filterptr += filter.name_length;
 287         g_free(filter.name);
 288
 289         *(filterptr++) = L'\0';
 290         *(filterptr++) = L'*';
 291
 292         if(filter.filter != NULL)
 293         {
 294             wcsncpy(filterptr, (wchar_t*)filter.filter, filter.filter_length);
 295             filterptr += filter.filter_length;
 296             g_free(filter.filter);
 297         }
 298
 299         *(filterptr++) = L'\0';
 300
 301         // Associate this input extension with the file type name
 302         _extension_map[extension_index++] = filter.mod;
 303     }
 304     *(filterptr++) = L'\0';
 305
 306         _filter_count = extension_index;
 307     _filter_index = 2;  // Select the 2nd filter in the list - 2 is NOT the 3rd
 308 }
 309
 310 void FileOpenDialogImplWin32::GetOpenFileName_thread()
 311 {
 312     OPENFILENAMEEXW ofn;
 313
 314     g_assert(this != NULL);
 315         g_assert(_mutex != NULL);
 316
 317     WCHAR* current_directory_string = (WCHAR*)g_utf8_to_utf16(
 318         _current_directory.data(), _current_directory.length(),
 319                 NULL, NULL, NULL);
 320
 321     memset(&ofn, 0, sizeof(ofn));
 322
 323     // Copy the selected file name, converting from UTF-8 to UTF-16
 324     memset(_path_string, 0, sizeof(_path_string));
 325     gunichar2* utf16_path_string = g_utf8_to_utf16(
 326         myFilename.data(), -1, NULL, NULL, NULL);
 327     wcsncpy(_path_string, (wchar_t*)utf16_path_string, _MAX_PATH);
 328     g_free(utf16_path_string);
 329
 330     ofn.lStructSize = sizeof(ofn);
 331     ofn.hwndOwner = _ownerHwnd;
 332     ofn.lpstrFile = _path_string;
 333     ofn.nMaxFile = _MAX_PATH;
 334     ofn.lpstrFileTitle = NULL;
 335     ofn.nMaxFileTitle = 0;
 336     ofn.lpstrInitialDir = current_directory_string;
 337     ofn.lpstrTitle = _title;
 338     ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_EXPLORER | OFN_ENABLEHOOK | OFN_HIDEREADONLY | OFN_ENABLESIZING;
 339     ofn.lpstrFilter = _filter;
 340     ofn.nFilterIndex = _filter_index;
 341     ofn.lpfnHook = GetOpenFileName_hookproc;
 342     ofn.lCustData = (LPARAM)this;
 343
 344     _result = GetOpenFileNameW(&ofn) != 0;
 345
 346         g_assert(ofn.nFilterIndex >= 1 && ofn.nFilterIndex <= _filter_count);
 347     _filter_index = ofn.nFilterIndex;
 348     _extension = _extension_map[ofn.nFilterIndex - 1];
 349
 350     // Copy the selected file name, converting from UTF-16 to UTF-8
 351     myFilename = utf16_to_ustring(_path_string, _MAX_PATH);
 352
 353     // Tidy up
 354     g_free(current_directory_string);
 355
 356     _mutex->lock();
 357     _finished = true;
 358     _mutex->unlock();
 359 }
 360
 361 void FileOpenDialogImplWin32::register_preview_wnd_class()
 362 {
 363     HINSTANCE hInstance = GetModuleHandle(NULL);
 364     const WNDCLASSA PreviewWndClass =
 365     {
 366         CS_HREDRAW | CS_VREDRAW,
 367         preview_wnd_proc,
 368         0,
 369         0,
 370         hInstance,
 371         NULL,
 372         LoadCursor(hInstance, IDC_ARROW),
 373         (HBRUSH)(COLOR_BTNFACE + 1),
 374         NULL,
 375         PreviewWindowClassName
 376     };
 377
 378     RegisterClassA(&PreviewWndClass);
 379 }
 380
 381 UINT_PTR CALLBACK FileOpenDialogImplWin32::GetOpenFileName_hookproc(
 382     HWND hdlg, UINT uiMsg, WPARAM, LPARAM lParam)
 383 {
 384     FileOpenDialogImplWin32 *pImpl = (FileOpenDialogImplWin32*)
 385         GetWindowLongPtr(hdlg, GWLP_USERDATA);
 386
 387     switch(uiMsg)
 388     {
 389     case WM_INITDIALOG:
 390         {
 391             HWND hParentWnd = GetParent(hdlg);
 392             HINSTANCE hInstance = GetModuleHandle(NULL);
 393
 394             // Make the window a bit wider
 395             RECT rcRect;
 396             GetWindowRect(hParentWnd, &rcRect);
 397             MoveWindow(hParentWnd, rcRect.left, rcRect.top,
 398                 rcRect.right - rcRect.left + PreviewWidening,
 399                 rcRect.bottom - rcRect.top,
 400                 FALSE);
 401
 402             // Set the pointer to the object
 403             OPENFILENAMEW *ofn = (OPENFILENAMEW*)lParam;
 404             SetWindowLongPtr(hdlg, GWLP_USERDATA, ofn->lCustData);
 405             SetWindowLongPtr(hParentWnd, GWLP_USERDATA, ofn->lCustData);
 406             pImpl = (FileOpenDialogImplWin32*)ofn->lCustData;
 407
 408             // Subclass the parent
 409             pImpl->_base_window_proc = (WNDPROC)GetWindowLongPtr(hParentWnd, GWL_WNDPROC);
 410             SetWindowLongPtr(hParentWnd, GWL_WNDPROC, (LONG_PTR)file_dialog_subclass_proc);
 411
 412             // Add a button to the toolbar
 413             pImpl->_toolbar_wnd = FindWindowEx(hParentWnd, NULL, "ToolbarWindow32", NULL);
 414
 415             pImpl->_show_preview_button_bitmap = LoadBitmap(
 416                 hInstance, MAKEINTRESOURCE(IDC_SHOW_PREVIEW));
 417             TBADDBITMAP tbAddBitmap = {NULL, (UINT)pImpl->_show_preview_button_bitmap};
 418             const int iBitmapIndex = SendMessage(pImpl->_toolbar_wnd,
 419                 TB_ADDBITMAP, 1, (LPARAM)&tbAddBitmap);
 420
 421             TBBUTTON tbButton;
 422             memset(&tbButton, 0, sizeof(TBBUTTON));
 423             tbButton.iBitmap = iBitmapIndex;
 424             tbButton.idCommand = IDC_SHOW_PREVIEW;
 425             tbButton.fsState = (pImpl->_show_preview ? TBSTATE_CHECKED : 0)
 426                 | TBSTATE_ENABLED;
 427             tbButton.fsStyle = TBSTYLE_CHECK;
 428             tbButton.iString = (INT_PTR)_("Show Preview");
 429             SendMessage(pImpl->_toolbar_wnd, TB_ADDBUTTONS, 1, (LPARAM)&tbButton);
 430
 431             // Create preview pane
 432             register_preview_wnd_class();
 433
 434             pImpl->_mutex->lock();
 435
 436                 pImpl->_file_dialog_wnd = hParentWnd;
 437
 438                 pImpl->_preview_wnd =
 439                     CreateWindowA(PreviewWindowClassName, "",
 440                         WS_CHILD | WS_VISIBLE,
 441                         0, 0, 100, 100, hParentWnd, NULL, hInstance, NULL);
 442                 SetWindowLongPtr(pImpl->_preview_wnd, GWLP_USERDATA, ofn->lCustData);
 443
 444             pImpl->_mutex->unlock();
 445
 446             pImpl->layout_dialog();
 447         }
 448         break;
 449
 450     case WM_NOTIFY:
 451         {
 452
 453         OFNOTIFY *pOFNotify = reinterpret_cast<OFNOTIFY*>(lParam);
 454         switch(pOFNotify->hdr.code)
 455         {
 456         case CDN_SELCHANGE:
 457             {
 458                 if(pImpl != NULL)
 459                 {
 460                     // Get the file name
 461                     pImpl->_mutex->lock();
 462
 463                     SendMessage(pOFNotify->hdr.hwndFrom, CDM_GETFILEPATH,
 464                         sizeof(pImpl->_path_string) / sizeof(wchar_t),
 465                         (LPARAM)pImpl->_path_string);
 466
 467                     pImpl->_file_selected = true;
 468
 469                     pImpl->_mutex->unlock();
 470                 }
 471             }
 472             break;
 473         }
 474         }
 475         break;
 476
 477     case WM_CLOSE:
 478         pImpl->_mutex->lock();
 479         pImpl->_preview_file_size = 0;
 480
 481         pImpl->_file_dialog_wnd = NULL;
 482         DestroyWindow(pImpl->_preview_wnd);
 483         pImpl->_preview_wnd = NULL;
 484         DeleteObject(pImpl->_show_preview_button_bitmap);
 485         pImpl->_show_preview_button_bitmap = NULL;
 486         pImpl->_mutex->unlock();
 487
 488         break;
 489     }
 490
 491     // Use default dialog behaviour
 492     return 0;
 493 }
 494
 495 LRESULT CALLBACK FileOpenDialogImplWin32::file_dialog_subclass_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 496 {
 497     FileOpenDialogImplWin32 *pImpl = (FileOpenDialogImplWin32*)
 498         GetWindowLongPtr(hwnd, GWLP_USERDATA);
 499
 500     LRESULT lResult = CallWindowProc(pImpl->_base_window_proc, hwnd, uMsg, wParam, lParam);
 501
 502     switch(uMsg)
 503     {
 504     case WM_SHOWWINDOW:
 505         if(wParam != 0)
 506             pImpl->layout_dialog();
 507         break;
 508
 509     case WM_SIZE:
 510         pImpl->layout_dialog();
 511         break;
 512
 513     case WM_COMMAND:
 514         if(wParam == IDC_SHOW_PREVIEW)
 515         {
 516             const bool enable = SendMessage(pImpl->_toolbar_wnd,
 517                 TB_ISBUTTONCHECKED, IDC_SHOW_PREVIEW, 0) != 0;
 518             pImpl->enable_preview(enable);
 519         }
 520         break;
 521     }
 522
 523     return lResult;
 524 }
 525
 526 LRESULT CALLBACK FileOpenDialogImplWin32::preview_wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 527 {
 528     const int CaptionPadding = 4;
 529     const int IconSize = 32;
 530
 531     FileOpenDialogImplWin32 *pImpl = (FileOpenDialogImplWin32*)
 532         GetWindowLongPtr(hwnd, GWLP_USERDATA);
 533
 534     LRESULT lResult = 0;
 535
 536     switch(uMsg)
 537     {
 538     case WM_ERASEBKGND:
 539         // Do nothing to erase the background
 540         //  - otherwise there'll be flicker
 541         lResult = 1;
 542         break;
 543
 544     case WM_PAINT:
 545         {
 546             // Get the client rect
 547             RECT rcClient;
 548             GetClientRect(hwnd, &rcClient);
 549
 550             // Prepare to paint
 551             PAINTSTRUCT paint_struct;
 552             HDC dc = BeginPaint(hwnd, &paint_struct);
 553
 554             HFONT hCaptionFont = (HFONT)SendMessage(GetParent(hwnd),
 555                     WM_GETFONT, 0, 0);
 556             HFONT hOldFont = (HFONT)SelectObject(dc, hCaptionFont);
 557             SetBkMode(dc, TRANSPARENT);
 558
 559             pImpl->_mutex->lock();
 560
 561             if(pImpl->_path_string[0] == 0)
 562             {
 563                 FillRect(dc, &rcClient, (HBRUSH)(COLOR_3DFACE + 1));
 564                 DrawText(dc, _("No file selected"), -1, &rcClient,
 565                     DT_CENTER | DT_VCENTER | DT_NOPREFIX);
 566             }
 567             else if(pImpl->_preview_bitmap != NULL)
 568             {
 569                 BITMAP bitmap;
 570                 GetObject(pImpl->_preview_bitmap, sizeof(bitmap), &bitmap);
 571                 const int destX = (rcClient.right - bitmap.bmWidth) / 2;
 572
 573                 // Render the image
 574                 HDC hSrcDC = CreateCompatibleDC(dc);
 575                 HBITMAP hOldBitmap = (HBITMAP)SelectObject(hSrcDC, pImpl->_preview_bitmap);
 576
 577                 BitBlt(dc, destX, 0, bitmap.bmWidth, bitmap.bmHeight,
 578                     hSrcDC, 0, 0, SRCCOPY);
 579
 580                 SelectObject(hSrcDC, hOldBitmap);
 581                 DeleteDC(hSrcDC);
 582
 583                 // Fill in the background area
 584                 HRGN hEraseRgn = CreateRectRgn(rcClient.left, rcClient.top,
 585                     rcClient.right, rcClient.bottom);
 586                 HRGN hImageRgn = CreateRectRgn(destX, 0,
 587                     destX + bitmap.bmWidth, bitmap.bmHeight);
 588                 CombineRgn(hEraseRgn, hEraseRgn, hImageRgn, RGN_DIFF);
 589
 590                 FillRgn(dc, hEraseRgn, GetSysColorBrush(COLOR_3DFACE));
 591
 592                 DeleteObject(hImageRgn);
 593                 DeleteObject(hEraseRgn);
 594
 595                 // Draw the caption on
 596                 RECT rcCaptionRect = {rcClient.left,
 597                     rcClient.top + bitmap.bmHeight + CaptionPadding,
 598                     rcClient.right, rcClient.bottom};
 599
 600                 WCHAR szCaption[_MAX_FNAME + 32];
 601                 const int iLength = pImpl->format_caption(
 602                     szCaption, sizeof(szCaption) / sizeof(WCHAR));
 603
 604                 DrawTextW(dc, szCaption, iLength, &rcCaptionRect,
 605                     DT_CENTER | DT_TOP | DT_NOPREFIX | DT_PATH_ELLIPSIS);
 606             }
 607             else if(pImpl->_preview_file_icon != NULL)
 608             {
 609                 FillRect(dc, &rcClient, (HBRUSH)(COLOR_3DFACE + 1));
 610
 611                 // Draw the files icon
 612                 const int destX = (rcClient.right - IconSize) / 2;
 613                 DrawIconEx(dc, destX, 0, pImpl->_preview_file_icon,
 614                     IconSize, IconSize, 0, NULL,
 615                     DI_NORMAL | DI_COMPAT);
 616
 617                 // Draw the caption on
 618                 RECT rcCaptionRect = {rcClient.left,
 619                     rcClient.top + IconSize + CaptionPadding,
 620                     rcClient.right, rcClient.bottom};
 621
 622                 WCHAR szFileName[_MAX_FNAME], szCaption[_MAX_FNAME + 32];
 623                 _wsplitpath(pImpl->_path_string, NULL, NULL, szFileName, NULL);
 624
 625                 const int iLength = snwprintf(szCaption,
 626                     sizeof(szCaption), L"%s\n%d kB",
 627                     szFileName, pImpl->_preview_file_size);
 628
 629                 DrawTextW(dc, szCaption, iLength, &rcCaptionRect,
 630                     DT_CENTER | DT_TOP | DT_NOPREFIX | DT_PATH_ELLIPSIS);
 631             }
 632             else
 633             {
 634                 // Can't show anything!
 635                 FillRect(dc, &rcClient, (HBRUSH)(COLOR_3DFACE + 1));
 636             }
 637
 638             pImpl->_mutex->unlock();
 639
 640             // Finish painting
 641             SelectObject(dc, hOldFont);
 642             EndPaint(hwnd, &paint_struct);
 643         }
 644
 645         break;
 646
 647     case WM_DESTROY:
 648         pImpl->free_preview();
 649         break;
 650
 651     default:
 652         lResult = DefWindowProc(hwnd, uMsg, wParam, lParam);
 653         break;
 654     }
 655
 656     return lResult;
 657 }
 658
 659 void FileOpenDialogImplWin32::enable_preview(bool enable)
 660 {
 661     _show_preview = enable;
 662
 663     // Relayout the dialog
 664     ShowWindow(_preview_wnd, enable ? SW_SHOW : SW_HIDE);
 665     layout_dialog();
 666
 667     // Load or unload the preview
 668     if(enable)
 669     {
 670         _mutex->lock();
 671         _file_selected = true;
 672         _mutex->unlock();
 673     }
 674     else free_preview();
 675 }
 676
 677 void FileOpenDialogImplWin32::layout_dialog()
 678 {
 679     union RECTPOINTS
 680     {
 681         RECT r;
 682         POINT p[2];
 683     };
 684
 685     const float MaxExtentScale = 2.0f / 3.0f;
 686
 687     RECT rcClient;
 688     GetClientRect(_file_dialog_wnd, &rcClient);
 689
 690     // Re-layout the dialog
 691     HWND hFileListWnd = GetDlgItem(_file_dialog_wnd, lst2);
 692     HWND hFolderComboWnd = GetDlgItem(_file_dialog_wnd, cmb2);
 693
 694
 695     RECT rcFolderComboRect;
 696     RECTPOINTS rcFileList;
 697     GetWindowRect(hFileListWnd, &rcFileList.r);
 698     GetWindowRect(hFolderComboWnd, &rcFolderComboRect);
 699     const int iPadding = rcFileList.r.top - rcFolderComboRect.bottom;
 700     MapWindowPoints(NULL, _file_dialog_wnd, rcFileList.p, 2);
 701
 702     RECT rcPreview;
 703     RECT rcBody = {rcFileList.r.left, rcFileList.r.top,
 704         rcClient.right - iPadding, rcFileList.r.bottom};
 705     rcFileList.r.right = rcBody.right;
 706
 707     if(_show_preview)
 708     {
 709         rcPreview.top = rcBody.top;
 710         rcPreview.left = rcClient.right - (rcBody.bottom - rcBody.top);
 711         const int iMaxExtent = (int)(MaxExtentScale * (float)(rcBody.left + rcBody.right)) + iPadding / 2;
 712         if(rcPreview.left < iMaxExtent) rcPreview.left = iMaxExtent;
 713         rcPreview.bottom = rcBody.bottom;
 714         rcPreview.right = rcBody.right;
 715
 716         // Re-layout the preview box
 717         _mutex->lock();
 718
 719             _preview_width = rcPreview.right - rcPreview.left;
 720             _preview_height = rcPreview.bottom - rcPreview.top;
 721
 722         _mutex->unlock();
 723
 724         render_preview();
 725
 726         MoveWindow(_preview_wnd, rcPreview.left, rcPreview.top,
 727             _preview_width, _preview_height, TRUE);
 728
 729         rcFileList.r.right = rcPreview.left - iPadding;
 730     }
 731
 732     // Re-layout the file list box
 733     MoveWindow(hFileListWnd, rcFileList.r.left, rcFileList.r.top,
 734         rcFileList.r.right - rcFileList.r.left,
 735         rcFileList.r.bottom - rcFileList.r.top, TRUE);
 736
 737     // Re-layout the toolbar
 738     RECTPOINTS rcToolBar;
 739     GetWindowRect(_toolbar_wnd, &rcToolBar.r);
 740     MapWindowPoints(NULL, _file_dialog_wnd, rcToolBar.p, 2);
 741     MoveWindow(_toolbar_wnd, rcToolBar.r.left, rcToolBar.r.top,
 742         rcToolBar.r.right - rcToolBar.r.left, rcToolBar.r.bottom - rcToolBar.r.top, TRUE);
 743 }
 744
 745 void FileOpenDialogImplWin32::file_selected()
 746 {
 747     // Destroy any previous previews
 748     free_preview();
 749
 750
 751     // Determine if the file exists
 752     DWORD attributes = GetFileAttributesW(_path_string);
 753     if(attributes == 0xFFFFFFFF ||
 754         attributes == FILE_ATTRIBUTE_DIRECTORY)
 755     {
 756         InvalidateRect(_preview_wnd, NULL, FALSE);
 757         return;
 758     }
 759
 760     // Check the file exists and get the file size
 761     HANDLE file_handle = CreateFileW(_path_string, GENERIC_READ,
 762         FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 763     if(file_handle == INVALID_HANDLE_VALUE) return;
 764     const DWORD file_size = GetFileSize(file_handle, NULL);
 765     if (file_size == INVALID_FILE_SIZE) return;
 766     _preview_file_size = file_size / 1024;
 767     CloseHandle(file_handle);
 768
 769     if(_show_preview) load_preview();
 770 }
 771
 772 void FileOpenDialogImplWin32::load_preview()
 773 {
 774     // Destroy any previous previews
 775     free_preview();
 776
 777     // Try to get the file icon
 778     SHFILEINFOW fileInfo;
 779     if(SUCCEEDED(SHGetFileInfoW(_path_string, 0, &fileInfo,
 780         sizeof(fileInfo), SHGFI_ICON | SHGFI_LARGEICON)))
 781         _preview_file_icon = fileInfo.hIcon;
 782
 783     // Will this file be too big?
 784     if(_preview_file_size > MaxPreviewFileSize)
 785     {
 786         InvalidateRect(_preview_wnd, NULL, FALSE);
 787         return;
 788     }
 789
 790     // Prepare to render a preview
 791     const Glib::ustring svg = ".svg";
 792     const Glib::ustring svgz = ".svgz";
 793     const Glib::ustring path = utf16_to_ustring(_path_string);
 794
 795     bool success = false;
 796
 797     _preview_document_width = _preview_document_height = 0;
 798
 799     if ((dialogType == SVG_TYPES || dialogType == IMPORT_TYPES) &&
 800             (hasSuffix(path, svg) || hasSuffix(path, svgz)))
 801         success = set_svg_preview();
 802     else if (isValidImageFile(path))
 803         success = set_image_preview();
 804     else {
 805         // Show no preview
 806     }
 807
 808     if(success) render_preview();
 809
 810     InvalidateRect(_preview_wnd, NULL, FALSE);
 811 }
 812
 813 void FileOpenDialogImplWin32::free_preview()
 814 {
 815     _mutex->lock();
 816     if(_preview_bitmap != NULL)
 817         DeleteObject(_preview_bitmap);
 818     _preview_bitmap = NULL;
 819
 820     if(_preview_file_icon != NULL)
 821         DestroyIcon(_preview_file_icon);
 822     _preview_file_icon = NULL;
 823
 824     _preview_bitmap_image.clear();
 825     _mutex->unlock();
 826 }
 827
 828 bool FileOpenDialogImplWin32::set_svg_preview()
 829 {
 830     const int PreviewSize = 512;
 831
 832     gchar *utf8string = g_utf16_to_utf8((const gunichar2*)_path_string,
 833         _MAX_PATH, NULL, NULL, NULL);
 834     SPDocument *svgDoc = sp_document_new (utf8string, true);
 835     g_free(utf8string);
 836
 837     // Check the document loaded properly
 838     if(svgDoc == NULL) return false;
 839     if(svgDoc->root == NULL)
 840     {
 841         sp_document_unref(svgDoc);
 842         return false;
 843     }
 844
 845     // Get the size of the document
 846     const double svgWidth = sp_document_width(svgDoc);
 847     const double svgHeight = sp_document_height(svgDoc);
 848
 849     // Find the minimum scale to fit the image inside the preview area
 850     const double scaleFactorX =    PreviewSize / svgWidth;
 851     const double scaleFactorY =    PreviewSize / svgHeight;
 852     const double scaleFactor = (scaleFactorX > scaleFactorY) ? scaleFactorY : scaleFactorX;
 853
 854     // Now get the resized values
 855     const double scaledSvgWidth  = scaleFactor * svgWidth;
 856     const double scaledSvgHeight = scaleFactor * svgHeight;
 857
 858     NR::Rect area(NR::Point(0, 0), NR::Point(scaledSvgWidth, scaledSvgHeight));
 859     NRRectL areaL = {0, 0, scaledSvgWidth, scaledSvgHeight};
 860     NRRectL bbox = {0, 0, scaledSvgWidth, scaledSvgHeight};
 861
 862     // write object bbox to area
 863     NR::Maybe<NR::Rect> maybeArea(area);
 864     sp_document_ensure_up_to_date (svgDoc);
 865     sp_item_invoke_bbox((SPItem *) svgDoc->root, &maybeArea,
 866         sp_item_i2r_affine((SPItem *)(svgDoc->root)), TRUE);
 867
 868     NRArena *const arena = NRArena::create();
 869
 870     unsigned const key = sp_item_display_key_new(1);
 871
 872     NRArenaItem *root = sp_item_invoke_show((SPItem*)(svgDoc->root),
 873         arena, key, SP_ITEM_SHOW_DISPLAY);
 874
 875     NRGC gc(NULL);
 876     nr_matrix_set_scale(&gc.transform, scaleFactor, scaleFactor);
 877
 878     nr_arena_item_invoke_update (root, NULL, &gc,
 879         NR_ARENA_ITEM_STATE_ALL, NR_ARENA_ITEM_STATE_NONE);
 880
 881     // Prepare a GDI compatible NRPixBlock
 882     NRPixBlock pixBlock;
 883     pixBlock.size = NR_PIXBLOCK_SIZE_BIG;
 884     pixBlock.mode = NR_PIXBLOCK_MODE_R8G8B8;
 885     pixBlock.empty = 1;
 886     pixBlock.visible_area.x0 = pixBlock.area.x0 = 0;
 887     pixBlock.visible_area.y0 = pixBlock.area.y0 = 0;
 888     pixBlock.visible_area.x1 = pixBlock.area.x1 = scaledSvgWidth;
 889     pixBlock.visible_area.y1 = pixBlock.area.y1 = scaledSvgHeight;
 890     pixBlock.rs = 4 * ((3 * (int)scaledSvgWidth + 3) / 4);
 891     pixBlock.data.px = g_try_new (unsigned char, pixBlock.rs * scaledSvgHeight);
 892
 893     // Fail if the pixblock failed to allocate
 894     if(pixBlock.data.px == NULL)
 895     {
 896         sp_document_unref(svgDoc);
 897         return false;
 898     }
 899
 900     memset(pixBlock.data.px, 0xFF, pixBlock.rs * scaledSvgHeight);
 901
 902     memcpy(&root->bbox, &areaL, sizeof(areaL));
 903
 904     // Render the image
 905     nr_arena_item_invoke_render(NULL, root, &bbox, &pixBlock, /*0*/NR_ARENA_ITEM_RENDER_NO_CACHE);
 906
 907     // Tidy up
 908     sp_document_unref(svgDoc);
 909     sp_item_invoke_hide((SPItem*)(svgDoc->root), key);
 910     nr_arena_item_unref(root);
 911     nr_object_unref((NRObject *) arena);
 912
 913     // Create the GDK pixbuf
 914     _mutex->lock();
 915
 916     _preview_bitmap_image = Gdk::Pixbuf::create_from_data(
 917         pixBlock.data.px, Gdk::COLORSPACE_RGB, false, 8,
 918         (int)scaledSvgWidth, (int)scaledSvgHeight, pixBlock.rs,
 919         sigc::ptr_fun(destroy_svg_rendering));
 920
 921     _preview_document_width = scaledSvgWidth;
 922     _preview_document_height = scaledSvgHeight;
 923     _preview_image_width = svgWidth;
 924     _preview_image_height = svgHeight;
 925
 926     _mutex->unlock();
 927
 928     return true;
 929 }
 930
 931 void FileOpenDialogImplWin32::destroy_svg_rendering(const guint8 *buffer)
 932 {
 933     g_assert(buffer != NULL);
 934     g_free((void*)buffer);
 935 }
 936
 937 bool FileOpenDialogImplWin32::set_image_preview()
 938 {
 939     const Glib::ustring path = utf16_to_ustring(_path_string, _MAX_PATH);
 940
 941     _mutex->lock();
 942     _preview_bitmap_image = Gdk::Pixbuf::create_from_file(path);
 943     if(!_preview_bitmap_image) return false;
 944
 945     _preview_image_width = _preview_bitmap_image->get_width();
 946     _preview_document_width = _preview_image_width;
 947     _preview_image_height = _preview_bitmap_image->get_height();
 948     _preview_document_height = _preview_image_height;
 949
 950     _mutex->unlock();
 951
 952     return true;
 953 }
 954
 955 void FileOpenDialogImplWin32::render_preview()
 956 {
 957     double x, y;
 958     const double blurRadius = 8;
 959     const double halfBlurRadius = blurRadius / 2;
 960     const int shaddowOffsetX = 0;
 961     const int shaddowOffsetY = 2;
 962     const int pagePadding = 5;
 963     const double shaddowAlpha = 0.75;
 964
 965     // Is the preview showing?
 966     if(!_show_preview)
 967         return;
 968
 969     // Do we have anything to render?
 970     _mutex->lock();
 971
 972     if(!_preview_bitmap_image)
 973     {
 974         _mutex->unlock();
 975         return;
 976     }
 977
 978     // Tidy up any previous bitmap renderings
 979     if(_preview_bitmap != NULL)
 980         DeleteObject(_preview_bitmap);
 981     _preview_bitmap = NULL;
 982
 983     // Calculate the size of the caption
 984     int captionHeight = 0;
 985
 986     if(_preview_wnd != NULL)
 987     {
 988         RECT rcCaptionRect;
 989         WCHAR szCaption[_MAX_FNAME + 32];
 990         const int iLength = format_caption(szCaption,
 991             sizeof(szCaption) / sizeof(WCHAR));
 992
 993         HDC dc = GetDC(_preview_wnd);
 994         DrawTextW(dc, szCaption, iLength, &rcCaptionRect,
 995             DT_CENTER | DT_TOP | DT_NOPREFIX | DT_PATH_ELLIPSIS | DT_CALCRECT);
 996         ReleaseDC(_preview_wnd, dc);
 997
 998         captionHeight = rcCaptionRect.bottom - rcCaptionRect.top;
 999     }
1000
1001     // Find the minimum scale to fit the image inside the preview area
1002     const double scaleFactorX =
1003         ((double)_preview_width - pagePadding * 2 - blurRadius)  / _preview_document_width;
1004     const double scaleFactorY =
1005         ((double)_preview_height - pagePadding * 2
1006         - shaddowOffsetY - halfBlurRadius - captionHeight) / _preview_document_height;
1007     double scaleFactor = (scaleFactorX > scaleFactorY) ? scaleFactorY : scaleFactorX;
1008     scaleFactor = (scaleFactor > 1.0) ? 1.0 : scaleFactor;
1009
1010     // Now get the resized values
1011     const double scaledSvgWidth  = scaleFactor * _preview_document_width;
1012     const double scaledSvgHeight = scaleFactor * _preview_document_height;
1013
1014     const int svgX = pagePadding + halfBlurRadius;
1015     const int svgY = pagePadding;
1016
1017     const int frameX = svgX - pagePadding;
1018     const int frameY = svgY - pagePadding;
1019     const int frameWidth = scaledSvgWidth + pagePadding * 2;
1020     const int frameHeight = scaledSvgHeight + pagePadding * 2;
1021
1022     const int totalWidth = (int)ceil(frameWidth + blurRadius);
1023     const int totalHeight = (int)ceil(frameHeight + blurRadius);
1024
1025     // Prepare the drawing surface
1026     HDC hDC = GetDC(_preview_wnd);
1027     HDC hMemDC = CreateCompatibleDC(hDC);
1028     _preview_bitmap = CreateCompatibleBitmap(hDC, totalWidth, totalHeight);
1029     HBITMAP hOldBitmap = (HBITMAP)SelectObject(hMemDC, _preview_bitmap);
1030     Cairo::RefPtr<Win32Surface> surface = Win32Surface::create(hMemDC);
1031     Cairo::RefPtr<Context> context = Context::create(surface);
1032
1033     // Paint the background to match the dialog colour
1034     const COLORREF background = GetSysColor(COLOR_3DFACE);
1035     context->set_source_rgb(
1036         GetRValue(background) / 255.0,
1037         GetGValue(background) / 255.0,
1038         GetBValue(background) / 255.0);
1039     context->paint();
1040
1041     //----- Draw the drop shaddow -----//
1042
1043     // Left Edge
1044     x = frameX + shaddowOffsetX - halfBlurRadius;
1045     Cairo::RefPtr<LinearGradient> leftEdgeFade = LinearGradient::create(
1046         x, 0.0, x + blurRadius, 0.0);
1047     leftEdgeFade->add_color_stop_rgba (0, 0, 0, 0, 0);
1048     leftEdgeFade->add_color_stop_rgba (1, 0, 0, 0, shaddowAlpha);
1049     context->set_source(leftEdgeFade);
1050     context->rectangle (x, frameY + shaddowOffsetY + halfBlurRadius,
1051         blurRadius, frameHeight - blurRadius);
1052     context->fill();
1053
1054     // Right Edge
1055     x = frameX + frameWidth + shaddowOffsetX - halfBlurRadius;
1056     Cairo::RefPtr<LinearGradient> rightEdgeFade = LinearGradient::create(
1057         x, 0.0,    x + blurRadius, 0.0);
1058     rightEdgeFade->add_color_stop_rgba (0, 0, 0, 0, shaddowAlpha);
1059     rightEdgeFade->add_color_stop_rgba (1, 0, 0, 0, 0);
1060     context->set_source(rightEdgeFade);
1061     context->rectangle (frameX + frameWidth + shaddowOffsetX - halfBlurRadius,
1062         frameY + shaddowOffsetY + halfBlurRadius,
1063         blurRadius, frameHeight - blurRadius);
1064     context->fill();
1065
1066     // Top Edge
1067     y = frameY + shaddowOffsetY - halfBlurRadius;
1068     Cairo::RefPtr<LinearGradient> topEdgeFade = LinearGradient::create(
1069         0.0, y, 0.0, y + blurRadius);
1070     topEdgeFade->add_color_stop_rgba (0, 0, 0, 0, 0);
1071     topEdgeFade->add_color_stop_rgba (1, 0, 0, 0, shaddowAlpha);
1072     context->set_source(topEdgeFade);
1073     context->rectangle (frameX + shaddowOffsetX + halfBlurRadius, y,
1074         frameWidth - blurRadius, blurRadius);
1075     context->fill();
1076
1077     // Bottom Edge
1078     y = frameY + frameHeight + shaddowOffsetY - halfBlurRadius;
1079     Cairo::RefPtr<LinearGradient> bottomEdgeFade = LinearGradient::create(
1080         0.0, y,    0.0, y + blurRadius);
1081     bottomEdgeFade->add_color_stop_rgba (0, 0, 0, 0, shaddowAlpha);
1082     bottomEdgeFade->add_color_stop_rgba (1, 0, 0, 0, 0);
1083     context->set_source(bottomEdgeFade);
1084     context->rectangle (frameX + shaddowOffsetX + halfBlurRadius, y,
1085         frameWidth - blurRadius, blurRadius);
1086     context->fill();
1087
1088     // Top Left Corner
1089     x = frameX + shaddowOffsetX - halfBlurRadius;
1090     y = frameY + shaddowOffsetY - halfBlurRadius;
1091     Cairo::RefPtr<RadialGradient> topLeftCornerFade = RadialGradient::create(
1092         x + blurRadius, y + blurRadius, 0, x + blurRadius, y + blurRadius, blurRadius);
1093     topLeftCornerFade->add_color_stop_rgba (0, 0, 0, 0, shaddowAlpha);
1094     topLeftCornerFade->add_color_stop_rgba (1, 0, 0, 0, 0);
1095     context->set_source(topLeftCornerFade);
1096     context->rectangle (x, y, blurRadius, blurRadius);
1097     context->fill();
1098
1099     // Top Right Corner
1100     x = frameX + frameWidth + shaddowOffsetX - halfBlurRadius;
1101     y = frameY + shaddowOffsetY - halfBlurRadius;
1102     Cairo::RefPtr<RadialGradient> topRightCornerFade = RadialGradient::create(
1103         x, y + blurRadius, 0, x, y + blurRadius, blurRadius);
1104     topRightCornerFade->add_color_stop_rgba (0, 0, 0, 0, shaddowAlpha);
1105     topRightCornerFade->add_color_stop_rgba (1, 0, 0, 0, 0);
1106     context->set_source(topRightCornerFade);
1107     context->rectangle (x, y, blurRadius, blurRadius);
1108     context->fill();
1109
1110     // Bottom Left Corner
1111     x = frameX + shaddowOffsetX - halfBlurRadius;
1112     y = frameY + frameHeight + shaddowOffsetY - halfBlurRadius;
1113     Cairo::RefPtr<RadialGradient> bottomLeftCornerFade = RadialGradient::create(
1114         x + blurRadius, y, 0, x + blurRadius, y, blurRadius);
1115     bottomLeftCornerFade->add_color_stop_rgba (0, 0, 0, 0, shaddowAlpha);
1116     bottomLeftCornerFade->add_color_stop_rgba (1, 0, 0, 0, 0);
1117     context->set_source(bottomLeftCornerFade);
1118     context->rectangle (x, y, blurRadius, blurRadius);
1119     context->fill();
1120
1121     // Bottom Right Corner
1122     x = frameX + frameWidth + shaddowOffsetX - halfBlurRadius;
1123     y = frameY + frameHeight + shaddowOffsetY - halfBlurRadius;
1124     Cairo::RefPtr<RadialGradient> bottomRightCornerFade = RadialGradient::create(
1125         x, y, 0, x, y, blurRadius);
1126     bottomRightCornerFade->add_color_stop_rgba (0, 0, 0, 0, shaddowAlpha);
1127     bottomRightCornerFade->add_color_stop_rgba (1, 0, 0, 0, 0);
1128     context->set_source(bottomRightCornerFade);
1129     context->rectangle (frameX + frameWidth + shaddowOffsetX - halfBlurRadius,
1130         frameY + frameHeight + shaddowOffsetY - halfBlurRadius,
1131         blurRadius, blurRadius);
1132     context->fill();
1133
1134     // Draw the frame
1135     context->set_line_width(1);
1136     context->rectangle (frameX, frameY,    frameWidth, frameHeight);
1137
1138     context->set_source_rgb(1.0, 1.0, 1.0);
1139     context->fill_preserve();
1140     context->set_source_rgb(0.25, 0.25, 0.25);
1141     context->stroke_preserve();
1142
1143     // Draw the image
1144     if(_preview_bitmap_image)    // Is the image a pixbuf?
1145     {
1146         // Set the transformation
1147         const Matrix matrix = {
1148             scaleFactor, 0,
1149             0, scaleFactor,
1150             svgX, svgY };
1151         context->set_matrix (matrix);
1152
1153         // Render the image
1154         set_source_pixbuf (context, _preview_bitmap_image, 0, 0);
1155         context->paint();
1156
1157         // Reset the transformation
1158         context->set_identity_matrix();
1159     }
1160
1161     // Draw the inner frame
1162     context->set_source_rgb(0.75, 0.75, 0.75);
1163     context->rectangle (svgX, svgY,    scaledSvgWidth, scaledSvgHeight);
1164     context->stroke();
1165
1166     _mutex->unlock();
1167
1168     // Finish drawing
1169     surface->finish();
1170     SelectObject(hMemDC, hOldBitmap) ;
1171     DeleteDC(hMemDC);
1172
1173     // Refresh the preview pane
1174     InvalidateRect(_preview_wnd, NULL, FALSE);
1175 }
1176
1177 int FileOpenDialogImplWin32::format_caption(wchar_t *caption, int caption_size)
1178 {
1179     wchar_t szFileName[_MAX_FNAME];
1180     _wsplitpath(_path_string, NULL, NULL, szFileName, NULL);
1181
1182     return snwprintf(caption, caption_size,
1183         L"%s\n%d kB\n%d \xD7 %d", szFileName, _preview_file_size,
1184         (int)_preview_document_width, (int)_preview_document_height);
1185 }
1186
1187 /**
1188  * Show this dialog modally.  Return true if user hits [OK]
1189  */
1190 bool
1191 FileOpenDialogImplWin32::show()
1192 {
1193     // We can only run one worker thread at a time
1194     if(_mutex != NULL) return false;
1195
1196     if(!Glib::thread_supported())
1197         Glib::thread_init();
1198
1199     _result = false;
1200     _finished = false;
1201     _file_selected = false;
1202     _mutex = new Glib::Mutex();
1203     _main_loop = g_main_loop_new(g_main_context_default(), FALSE);
1204
1205     if(Glib::Thread::create(sigc::mem_fun(*this, &FileOpenDialogImplWin32::GetOpenFileName_thread), true))
1206     {
1207         while(1)
1208         {
1209             g_main_context_iteration(g_main_context_default(), FALSE);
1210
1211             if(_mutex->trylock())
1212             {
1213                 // Read mutexed data
1214                 const bool finished = _finished;
1215                 const bool is_file_selected = _file_selected;
1216                 _file_selected = false;
1217                 _mutex->unlock();
1218
1219                 if(finished) break;
1220                 if(is_file_selected) file_selected();
1221             }
1222
1223             Sleep(10);
1224         }
1225     }
1226
1227     // Tidy up
1228     delete _mutex;
1229     _mutex = NULL;
1230
1231     return _result;
1232 }
1233
1234 /**
1235  * To Get Multiple filenames selected at-once.
1236  */
1237 std::vector<Glib::ustring>FileOpenDialogImplWin32::getFilenames()
1238 {
1239     std::vector<Glib::ustring> result;
1240     result.push_back(getFilename());
1241     return result;
1242 }
1243
1244
1245 /*#########################################################################
1246 ### F I L E    S A V E
1247 #########################################################################*/
1248
1249 /**
1250  * Constructor
1251  */
1252 FileSaveDialogImplWin32::FileSaveDialogImplWin32(Gtk::Window &parent,
1253             const Glib::ustring &dir,
1254             FileDialogType fileTypes,
1255             const char *title,
1256             const Glib::ustring &/*default_key*/) :
1257     FileDialogBaseWin32(parent, dir, title, fileTypes, "dialogs.save_as")
1258 {
1259     createFilterMenu();
1260 }
1261
1262 FileSaveDialogImplWin32::~FileSaveDialogImplWin32()
1263 {
1264 }
1265
1266 void FileSaveDialogImplWin32::createFilterMenu()
1267 {
1268     list<Filter> filter_list;
1269
1270     knownExtensions.clear();
1271
1272     // Compose the filter string
1273     Glib::ustring all_inkscape_files_filter, all_image_files_filter;
1274     Inkscape::Extension::DB::OutputList extension_list;
1275     Inkscape::Extension::db.get_output_list(extension_list);
1276
1277     int filter_count = 0;
1278     int filter_length = 0;
1279
1280     for (Inkscape::Extension::DB::OutputList::iterator current_item = extension_list.begin();
1281          current_item != extension_list.end(); current_item++)
1282     {
1283         Inkscape::Extension::Output *omod = *current_item;
1284         if (omod->deactivated()) continue;
1285
1286         filter_count++;
1287
1288         Filter filter;
1289
1290         // Extension
1291         const gchar *filter_extension = omod->get_extension();
1292         filter.filter = g_utf8_to_utf16(
1293             filter_extension, -1, NULL, &filter.filter_length, NULL);
1294         knownExtensions.insert( Glib::ustring(filter_extension).casefold() );
1295
1296         // Type
1297         filter.name = g_utf8_to_utf16(
1298             _(omod->get_filetypename()), -1, NULL, &filter.name_length, NULL);
1299
1300         filter.mod = omod;
1301
1302         filter_length += filter.name_length +
1303             filter.filter_length + 3;   // Add 3 for two \0s and a *
1304
1305         filter_list.push_back(filter);
1306     }
1307
1308     int extension_index = 0;
1309     _extension_map = new Inkscape::Extension::Extension*[filter_count];
1310
1311     _filter = new wchar_t[filter_length];
1312     wchar_t *filterptr = _filter;
1313
1314     for(list<Filter>::iterator filter_iterator = filter_list.begin();
1315         filter_iterator != filter_list.end(); filter_iterator++)
1316     {
1317         const Filter &filter = *filter_iterator;
1318
1319         wcsncpy(filterptr, (wchar_t*)filter.name, filter.name_length);
1320         filterptr += filter.name_length;
1321         g_free(filter.name);
1322
1323         *(filterptr++) = L'\0';
1324         *(filterptr++) = L'*';
1325
1326         wcsncpy(filterptr, (wchar_t*)filter.filter, filter.filter_length);
1327         filterptr += filter.filter_length;
1328         g_free(filter.filter);
1329
1330         *(filterptr++) = L'\0';
1331
1332         // Associate this input extension with the file type name
1333         _extension_map[extension_index++] = filter.mod;
1334     }
1335     *(filterptr++) = 0;
1336
1337         _filter_count = extension_index;
1338     _filter_index = 1;  // A value of 1 selects the 1st filter - NOT the 2nd
1339 }
1340
1341 void FileSaveDialogImplWin32::GetSaveFileName_thread()
1342 {
1343     OPENFILENAMEEXW ofn;
1344
1345     g_assert(this != NULL);
1346     g_assert(_main_loop != NULL);
1347
1348     WCHAR* current_directory_string = (WCHAR*)g_utf8_to_utf16(
1349         _current_directory.data(), _current_directory.length(),
1350                 NULL, NULL, NULL);
1351
1352     // Copy the selected file name, converting from UTF-8 to UTF-16
1353     memset(_path_string, 0, sizeof(_path_string));
1354     gunichar2* utf16_path_string = g_utf8_to_utf16(
1355         myFilename.data(), -1, NULL, NULL, NULL);
1356     wcsncpy(_path_string, (wchar_t*)utf16_path_string, _MAX_PATH);
1357     g_free(utf16_path_string);
1358
1359     ZeroMemory(&ofn, sizeof(ofn));
1360     ofn.lStructSize = sizeof(ofn);
1361     ofn.hwndOwner = _ownerHwnd;
1362     ofn.lpstrFile = _path_string;
1363     ofn.nMaxFile = _MAX_PATH;
1364     ofn.nFilterIndex = _filter_index;
1365     ofn.lpstrFileTitle = NULL;
1366     ofn.nMaxFileTitle = 0;
1367     ofn.lpstrInitialDir = current_directory_string;
1368     ofn.lpstrTitle = _title;
1369     ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
1370     ofn.lpstrFilter = _filter;
1371     ofn.nFilterIndex = _filter_index;
1372
1373     _result = GetSaveFileNameW(&ofn) != 0;
1374
1375         g_assert(ofn.nFilterIndex >= 1 && ofn.nFilterIndex <= _filter_count);
1376     _filter_index = ofn.nFilterIndex;
1377     _extension = _extension_map[ofn.nFilterIndex - 1];
1378
1379     // Copy the selected file name, converting from UTF-16 to UTF-8
1380     myFilename = utf16_to_ustring(_path_string, _MAX_PATH);
1381
1382     // Tidy up
1383     g_free(current_directory_string);
1384
1385     g_main_loop_quit(_main_loop);
1386 }
1387
1388 /**
1389  * Show this dialog modally.  Return true if user hits [OK]
1390  */
1391 bool
1392 FileSaveDialogImplWin32::show()
1393 {
1394     if(!Glib::thread_supported())
1395         Glib::thread_init();
1396
1397     _result = false;
1398     _main_loop = g_main_loop_new(g_main_context_default(), FALSE);
1399
1400         if(_main_loop != NULL)
1401         {
1402             if(Glib::Thread::create(sigc::mem_fun(*this, &FileSaveDialogImplWin32::GetSaveFileName_thread), true))
1403                 g_main_loop_run(_main_loop);
1404
1405             if(_result)
1406                 appendExtension(myFilename, (Inkscape::Extension::Output*)_extension);
1407         }
1408
1409     return _result;
1410 }
1411
1412 void FileSaveDialogImplWin32::setSelectionType( Inkscape::Extension::Extension * /*key*/ )
1413 {
1414     // If no pointer to extension is passed in, look up based on filename extension.
1415
1416 }
1417
1418 }
1419 }
1420 }
1421
1422 #endif
1423
1424 /*
1425   Local Variables:
1426   mode:c++
1427   c-file-style:"stroustrup"
1428   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1429   indent-tabs-mode:nil
1430   fill-column:99
1431   End:
1432 */
1433 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :