Merge remote-tracking branch 'origin/master' into tm_sla_supports_backend

CMakeLists.txt

@@ -129,7 +129,7 @@ set(LIBDIR ${CMAKE_CURRENT_SOURCE_DIR}/src/)
 # For the bundled boost libraries (boost::nowide)
 include_directories(${LIBDIR})
 # For libslic3r.h
-include_directories(${LIBDIR}/libslic3r ${LIBDIR}/clipper ${LIBDIR}/polypartition)
+include_directories(${LIBDIR}/clipper ${LIBDIR}/polypartition)
 #set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 if(WIN32)

src/CMakeLists.txt

@@ -11,6 +11,7 @@ add_subdirectory(poly2tri)
 add_subdirectory(qhull)
 add_subdirectory(Shiny)
 add_subdirectory(semver)
+add_subdirectory(imgui)
 
 # Adding libnest2d project for bin packing...
 set(LIBNEST2D_UNITTESTS ON CACHE BOOL "Force generating unittests for libnest2d")

src/imgui/CMakeLists.txt

@@ -0,0 +1,15 @@
+project(imgui)
+cmake_minimum_required(VERSION 2.6)
+
+add_library(imgui STATIC
+    imconfig.h
+    imgui.h
+    imgui_internal.h
+    imstb_rectpack.h
+    imstb_textedit.h
+    imstb_truetype.h
+    imgui.cpp
+    imgui_demo.cpp
+    imgui_draw.cpp
+    imgui_widgets.cpp
+)

src/imgui/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2018 Omar Cornut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

src/imgui/imconfig.h

@@ -0,0 +1,72 @@
+//-----------------------------------------------------------------------------
+// COMPILE-TIME OPTIONS FOR DEAR IMGUI
+// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
+// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
+//-----------------------------------------------------------------------------
+// A) You may edit imconfig.h (and not overwrite it when updating imgui, or maintain a patch/branch with your modifications to imconfig.h)
+// B) or add configuration directives in your own file and compile with #define IMGUI_USER_CONFIG "myfilename.h"
+// If you do so you need to make sure that configuration settings are defined consistently _everywhere_ dear imgui is used, which include
+// the imgui*.cpp files but also _any_ of your code that uses imgui. This is because some compile-time options have an affect on data structures.
+// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
+// Call IMGUI_CHECKVERSION() from your .cpp files to verify that the data structures your files are using are matching the ones imgui.cpp is using.
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+//---- Define assertion handler. Defaults to calling assert().
+//#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
+//#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
+
+//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows.
+//#define IMGUI_API __declspec( dllexport )
+//#define IMGUI_API __declspec( dllimport )
+
+//---- Don't define obsolete functions/enums names. Consider enabling from time to time after updating to avoid using soon-to-be obsolete function/names.
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
+//---- Don't implement demo windows functionality (ShowDemoWindow()/ShowStyleEditor()/ShowUserGuide() methods will be empty)
+//---- It is very strongly recommended to NOT disable the demo windows during development. Please read the comments in imgui_demo.cpp.
+//#define IMGUI_DISABLE_DEMO_WINDOWS
+
+//---- Don't implement some functions to reduce linkage requirements.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] Don't implement default IME handler. Won't use and link with ImmGetContext/ImmSetCompositionWindow.
+//#define IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS             // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself if you don't want to link with vsnprintf.
+//#define IMGUI_DISABLE_MATH_FUNCTIONS                      // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 wrapper so you can implement them yourself. Declare your prototypes in imconfig.h.
+//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
+
+//---- Include imgui_user.h at the end of imgui.h as a convenience
+//#define IMGUI_INCLUDE_IMGUI_USER_H
+
+//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
+//#define IMGUI_USE_BGRA_PACKED_COLOR
+
+//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
+// By default the embedded implementations are declared static and not available outside of imgui cpp files.
+//#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
+//#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
+//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
+//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
+
+//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
+// This will be inlined as part of ImVec2 and ImVec4 class declarations.
+/*
+#define IM_VEC2_CLASS_EXTRA                                                 \
+        ImVec2(const MyVec2& f) { x = f.x; y = f.y; }                       \
+        operator MyVec2() const { return MyVec2(x,y); }
+
+#define IM_VEC4_CLASS_EXTRA                                                 \
+        ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; }     \
+        operator MyVec4() const { return MyVec4(x,y,z,w); }
+*/
+
+//---- Use 32-bit vertex indices (default is 16-bit) to allow meshes with more than 64K vertices. Render function needs to support it.
+//#define ImDrawIdx unsigned int
+
+//---- Tip: You can add extra functions within the ImGui:: namespace, here or in your own headers files.
+/*
+namespace ImGui
+{
+    void MyFunction(const char* name, const MyMatrix44& v);
+}
+*/

src/imgui/imstb_rectpack.h

@@ -0,0 +1,623 @@
+// stb_rect_pack.h - v0.11 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//    
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//
+// Version history:
+//
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node    stbrp_node;
+typedef struct stbrp_rect    stbrp_rect;
+
+#ifdef STBRP_LARGE_RECTS
+typedef int            stbrp_coord;
+#else
+typedef unsigned short stbrp_coord;
+#endif
+
+STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+//
+// The function returns 1 if all of the rectangles were successfully
+// packed and 0 otherwise.
+
+struct stbrp_rect
+{
+   // reserved for your use:
+   int            id;
+
+   // input:
+   stbrp_coord    w, h;
+
+   // output:
+   stbrp_coord    x, y;
+   int            was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum
+{
+   STBRP_HEURISTIC_Skyline_default=0,
+   STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+   STBRP_HEURISTIC_Skyline_BF_sortHeight
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node
+{
+   stbrp_coord  x,y;
+   stbrp_node  *next;
+};
+
+struct stbrp_context
+{
+   int width;
+   int height;
+   int align;
+   int init_mode;
+   int heuristic;
+   int num_nodes;
+   stbrp_node *active_head;
+   stbrp_node *free_head;
+   stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+#include <stdlib.h>
+#define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+#define STBRP_ASSERT assert
+#endif
+
+#ifdef _MSC_VER
+#define STBRP__NOTUSED(v)  (void)(v)
+#define STBRP__CDECL __cdecl
+#else
+#define STBRP__NOTUSED(v)  (void)sizeof(v)
+#define STBRP__CDECL
+#endif
+
+enum
+{
+   STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
+{
+   switch (context->init_mode) {
+      case STBRP__INIT_skyline:
+         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+         context->heuristic = heuristic;
+         break;
+      default:
+         STBRP_ASSERT(0);
+   }
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
+{
+   if (allow_out_of_mem)
+      // if it's ok to run out of memory, then don't bother aligning them;
+      // this gives better packing, but may fail due to OOM (even though
+      // the rectangles easily fit). @TODO a smarter approach would be to only
+      // quantize once we've hit OOM, then we could get rid of this parameter.
+      context->align = 1;
+   else {
+      // if it's not ok to run out of memory, then quantize the widths
+      // so that num_nodes is always enough nodes.
+      //
+      // I.e. num_nodes * align >= width
+      //                  align >= width / num_nodes
+      //                  align = ceil(width/num_nodes)
+
+      context->align = (context->width + context->num_nodes-1) / context->num_nodes;
+   }
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
+{
+   int i;
+#ifndef STBRP_LARGE_RECTS
+   STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
+#endif
+
+   for (i=0; i < num_nodes-1; ++i)
+      nodes[i].next = &nodes[i+1];
+   nodes[i].next = NULL;
+   context->init_mode = STBRP__INIT_skyline;
+   context->heuristic = STBRP_HEURISTIC_Skyline_default;
+   context->free_head = &nodes[0];
+   context->active_head = &context->extra[0];
+   context->width = width;
+   context->height = height;
+   context->num_nodes = num_nodes;
+   stbrp_setup_allow_out_of_mem(context, 0);
+
+   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+   context->extra[0].x = 0;
+   context->extra[0].y = 0;
+   context->extra[0].next = &context->extra[1];
+   context->extra[1].x = (stbrp_coord) width;
+#ifdef STBRP_LARGE_RECTS
+   context->extra[1].y = (1<<30);
+#else
+   context->extra[1].y = 65535;
+#endif
+   context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
+{
+   stbrp_node *node = first;
+   int x1 = x0 + width;
+   int min_y, visited_width, waste_area;
+
+   STBRP__NOTUSED(c);
+
+   STBRP_ASSERT(first->x <= x0);
+
+   #if 0
+   // skip in case we're past the node
+   while (node->next->x <= x0)
+      ++node;
+   #else
+   STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+   #endif
+
+   STBRP_ASSERT(node->x <= x0);
+
+   min_y = 0;
+   waste_area = 0;
+   visited_width = 0;
+   while (node->x < x1) {
+      if (node->y > min_y) {
+         // raise min_y higher.
+         // we've accounted for all waste up to min_y,
+         // but we'll now add more waste for everything we've visted
+         waste_area += visited_width * (node->y - min_y);
+         min_y = node->y;
+         // the first time through, visited_width might be reduced
+         if (node->x < x0)
+            visited_width += node->next->x - x0;
+         else
+            visited_width += node->next->x - node->x;
+      } else {
+         // add waste area
+         int under_width = node->next->x - node->x;
+         if (under_width + visited_width > width)
+            under_width = width - visited_width;
+         waste_area += under_width * (min_y - node->y);
+         visited_width += under_width;
+      }
+      node = node->next;
+   }
+
+   *pwaste = waste_area;
+   return min_y;
+}
+
+typedef struct
+{
+   int x,y;
+   stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
+{
+   int best_waste = (1<<30), best_x, best_y = (1 << 30);
+   stbrp__findresult fr;
+   stbrp_node **prev, *node, *tail, **best = NULL;
+
+   // align to multiple of c->align
+   width = (width + c->align - 1);
+   width -= width % c->align;
+   STBRP_ASSERT(width % c->align == 0);
+
+   node = c->active_head;
+   prev = &c->active_head;
+   while (node->x + width <= c->width) {
+      int y,waste;
+      y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+      if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
+         // bottom left
+         if (y < best_y) {
+            best_y = y;
+            best = prev;
+         }
+      } else {
+         // best-fit
+         if (y + height <= c->height) {
+            // can only use it if it first vertically
+            if (y < best_y || (y == best_y && waste < best_waste)) {
+               best_y = y;
+               best_waste = waste;
+               best = prev;
+            }
+         }
+      }
+      prev = &node->next;
+      node = node->next;
+   }
+
+   best_x = (best == NULL) ? 0 : (*best)->x;
+
+   // if doing best-fit (BF), we also have to try aligning right edge to each node position
+   //
+   // e.g, if fitting
+   //
+   //     ____________________
+   //    |____________________|
+   //
+   //            into
+   //
+   //   |                         |
+   //   |             ____________|
+   //   |____________|
+   //
+   // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+   //
+   // This makes BF take about 2x the time
+
+   if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+      tail = c->active_head;
+      node = c->active_head;
+      prev = &c->active_head;
+      // find first node that's admissible
+      while (tail->x < width)
+         tail = tail->next;
+      while (tail) {
+         int xpos = tail->x - width;
+         int y,waste;
+         STBRP_ASSERT(xpos >= 0);
+         // find the left position that matches this
+         while (node->next->x <= xpos) {
+            prev = &node->next;
+            node = node->next;
+         }
+         STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+         y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+         if (y + height < c->height) {
+            if (y <= best_y) {
+               if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
+                  best_x = xpos;
+                  STBRP_ASSERT(y <= best_y);
+                  best_y = y;
+                  best_waste = waste;
+                  best = prev;
+               }
+            }
+         }
+         tail = tail->next;
+      }         
+   }
+
+   fr.prev_link = best;
+   fr.x = best_x;
+   fr.y = best_y;
+   return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
+{
+   // find best position according to heuristic
+   stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+   stbrp_node *node, *cur;
+
+   // bail if:
+   //    1. it failed
+   //    2. the best node doesn't fit (we don't always check this)
+   //    3. we're out of memory
+   if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+      res.prev_link = NULL;
+      return res;
+   }
+
+   // on success, create new node
+   node = context->free_head;
+   node->x = (stbrp_coord) res.x;
+   node->y = (stbrp_coord) (res.y + height);
+
+   context->free_head = node->next;
+
+   // insert the new node into the right starting point, and
+   // let 'cur' point to the remaining nodes needing to be
+   // stiched back in
+
+   cur = *res.prev_link;
+   if (cur->x < res.x) {
+      // preserve the existing one, so start testing with the next one
+      stbrp_node *next = cur->next;
+      cur->next = node;
+      cur = next;
+   } else {
+      *res.prev_link = node;
+   }
+
+   // from here, traverse cur and free the nodes, until we get to one
+   // that shouldn't be freed
+   while (cur->next && cur->next->x <= res.x + width) {
+      stbrp_node *next = cur->next;
+      // move the current node to the free list
+      cur->next = context->free_head;
+      context->free_head = cur;
+      cur = next;
+   }
+
+   // stitch the list back in
+   node->next = cur;
+
+   if (cur->x < res.x + width)
+      cur->x = (stbrp_coord) (res.x + width);
+
+#ifdef _DEBUG
+   cur = context->active_head;
+   while (cur->x < context->width) {
+      STBRP_ASSERT(cur->x < cur->next->x);
+      cur = cur->next;
+   }
+   STBRP_ASSERT(cur->next == NULL);
+
+   {
+      int count=0;
+      cur = context->active_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      cur = context->free_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      STBRP_ASSERT(count == context->num_nodes+2);
+   }
+#endif
+
+   return res;
+}
+
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   if (p->h > q->h)
+      return -1;
+   if (p->h < q->h)
+      return  1;
+   return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+#ifdef STBRP_LARGE_RECTS
+#define STBRP__MAXVAL  0xffffffff
+#else
+#define STBRP__MAXVAL  0xffff
+#endif
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
+{
+   int i, all_rects_packed = 1;
+
+   // we use the 'was_packed' field internally to allow sorting/unsorting
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = i;
+      #ifndef STBRP_LARGE_RECTS
+      STBRP_ASSERT(rects[i].w <= 0xffff && rects[i].h <= 0xffff);
+      #endif
+   }
+
+   // sort according to heuristic
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+   for (i=0; i < num_rects; ++i) {
+      if (rects[i].w == 0 || rects[i].h == 0) {
+         rects[i].x = rects[i].y = 0;  // empty rect needs no space
+      } else {
+         stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+         if (fr.prev_link) {
+            rects[i].x = (stbrp_coord) fr.x;
+            rects[i].y = (stbrp_coord) fr.y;
+         } else {
+            rects[i].x = rects[i].y = STBRP__MAXVAL;
+         }
+      }
+   }
+
+   // unsort
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+   // set was_packed flags and all_rects_packed status
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+      if (!rects[i].was_packed)
+         all_rects_packed = 0;
+   }
+
+   // return the all_rects_packed status
+   return all_rects_packed;
+}
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do 
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 
+software, either in source code form or as a compiled binary, for any purpose, 
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this 
+software dedicate any and all copyright interest in the software to the public 
+domain. We make this dedication for the benefit of the public at large and to 
+the detriment of our heirs and successors. We intend this dedication to be an 
+overt act of relinquishment in perpetuity of all present and future rights to 
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/

src/libslic3r/CMakeLists.txt

@@ -174,7 +174,7 @@ if (NOT SLIC3R_SYNTAXONLY)
 endif ()
 
 target_compile_definitions(libslic3r PUBLIC -DUSE_TBB ${PNG_DEFINITIONS})
-target_include_directories(libslic3r PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ${LIBNEST2D_INCLUDES} ${PNG_INCLUDE_DIRS})
+target_include_directories(libslic3r PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${LIBNEST2D_INCLUDES} ${PNG_INCLUDE_DIRS} PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
 target_link_libraries(libslic3r
     libnest2d
     admesh

src/libslic3r/ClipperUtils.hpp

@@ -1,7 +1,7 @@
 #ifndef slic3r_ClipperUtils_hpp_
 #define slic3r_ClipperUtils_hpp_
 
-#include <libslic3r.h>
+#include "libslic3r.h"
 #include "clipper.hpp"
 #include "ExPolygon.hpp"
 #include "Polygon.hpp"

src/libslic3r/GCode/Analyzer.hpp

@@ -5,8 +5,8 @@
 #include "../PrintConfig.hpp"
 #include "../ExtrusionEntity.hpp"
 
-#include "Point.hpp"
-#include "GCodeReader.hpp"
+#include "../Point.hpp"
+#include "../GCodeReader.hpp"
 
 namespace Slic3r {
 

src/libslic3r/GCode/PreviewData.hpp

@@ -3,8 +3,7 @@
 
 #include "../libslic3r.h"
 #include "../ExtrusionEntity.hpp"
-
-#include "Point.hpp"
+#include "../Point.hpp"
 
 namespace Slic3r {
 

src/libslic3r/Model.cpp

@@ -981,63 +981,76 @@ template<class T> static void cut_reset_transform(T *thing) {
     thing->set_offset(offset);
 }
 
-ModelObjectPtrs ModelObject::cut(size_t instance, coordf_t z)
+ModelObjectPtrs ModelObject::cut(size_t instance, coordf_t z, bool keep_upper, bool keep_lower, bool rotate_lower)
 {
     // Clone the object to duplicate instances, materials etc.
-    ModelObject* upper = ModelObject::new_clone(*this);
-    ModelObject* lower = ModelObject::new_clone(*this);
-    upper->set_model(nullptr);
-    lower->set_model(nullptr);
-    upper->sla_support_points.clear();
-    lower->sla_support_points.clear();
-    upper->clear_volumes();
-    lower->clear_volumes();
-    upper->input_file = "";
-    lower->input_file = "";
+    ModelObject* upper = keep_upper ? ModelObject::new_clone(*this) : nullptr;
+    ModelObject* lower = keep_lower ? ModelObject::new_clone(*this) : nullptr;
+
+    if (keep_upper) {
+        upper->set_model(nullptr);
+        upper->sla_support_points.clear();
+        upper->clear_volumes();
+        upper->input_file = "";
+    }
+
+    if (keep_lower) {
+        lower->set_model(nullptr);
+        lower->sla_support_points.clear();
+        lower->clear_volumes();
+        lower->input_file = "";
+    }
 
     const auto instance_matrix = instances[instance]->get_matrix(true);
 
     // Because transformations are going to be applied to meshes directly,
     // we reset transformation of all instances and volumes,
-    // _except_ for translation, which is preserved in the transformation matrix
+    // except for translation, which is preserved in the transformation matrix
     // and not applied to the mesh transform.
     // TODO: Do the same for Z-rotation as well?
 
-    // Convert z from relative to bb's base to object coordinates
-    // FIXME: doesn't work well for rotated objects
-    const auto bb = instance_bounding_box(instance, true);
-    z -= bb.min(2);
-
-    for (auto *instance : upper->instances) { cut_reset_transform(instance); }
-    for (auto *instance : lower->instances) { cut_reset_transform(instance); }
+    if (keep_upper) {
+        for (auto *instance : upper->instances) { cut_reset_transform(instance); }
+    }
+    if (keep_lower) {
+        for (auto *instance : lower->instances) { cut_reset_transform(instance); }
+    }
 
     for (ModelVolume *volume : volumes) {
         if (! volume->is_model_part()) {
             // don't cut modifiers
-            upper->add_volume(*volume);
-            lower->add_volume(*volume);
+            if (keep_upper) { upper->add_volume(*volume); }
+            if (keep_lower) { lower->add_volume(*volume); }
         } else {
             TriangleMesh upper_mesh, lower_mesh;
 
             // Transform the mesh by the object transformation matrix
-            volume->mesh.transform(instance_matrix * volume->get_matrix(true));
+            const auto volume_tr = instance_matrix * volume->get_matrix(true);
+            volume->mesh.transform(volume_tr);
             cut_reset_transform(volume);
 
+            // Transform z from world to object
+            const auto local_z = volume_tr * Vec3d(0.0, 0.0, z);
+
             TriangleMeshSlicer tms(&volume->mesh);
-            tms.cut(z, &upper_mesh, &lower_mesh);
+            tms.cut(local_z(2), &upper_mesh, &lower_mesh);
 
-            upper_mesh.repair();
-            lower_mesh.repair();
-            upper_mesh.reset_repair_stats();
-            lower_mesh.reset_repair_stats();
+            if (keep_upper) {
+                upper_mesh.repair();
+                upper_mesh.reset_repair_stats();
+            }
+            if (keep_lower) {
+                lower_mesh.repair();
+                lower_mesh.reset_repair_stats();
+            }
 
-            if (upper_mesh.facets_count() > 0) {
+            if (keep_upper && upper_mesh.facets_count() > 0) {
                 ModelVolume* vol    = upper->add_volume(upper_mesh);
                 vol->name           = volume->name;
                 vol->config         = volume->config;
                 vol->set_material(volume->material_id(), *volume->material());
             }
-            if (lower_mesh.facets_count() > 0) {
+            if (keep_lower && lower_mesh.facets_count() > 0) {
                 ModelVolume* vol    = lower->add_volume(lower_mesh);
                 vol->name           = volume->name;
                 vol->config         = volume->config;
@@ -1046,12 +1059,27 @@ ModelObjectPtrs ModelObject::cut(size_t instance, coordf_t z)
         }
     }
 
-    upper->invalidate_bounding_box();
-    lower->invalidate_bounding_box();
+    if (keep_lower && rotate_lower) {
+        for (auto *instance : lower->instances) {
+            Geometry::Transformation tr;
+            tr.set_offset(instance->get_offset());
+            tr.set_rotation({Geometry::deg2rad(180.0), 0.0, 0.0});
+            instance->set_transformation(tr);
+        }
+    }
 
     ModelObjectPtrs res;
-    if (upper->volumes.size() > 0) { res.push_back(upper); }
-    if (lower->volumes.size() > 0) { res.push_back(lower); }
+
+    if (keep_upper && upper->volumes.size() > 0) {
+        upper->invalidate_bounding_box();
+        upper->center_around_origin();
+        res.push_back(upper);
+    }
+    if (keep_lower && lower->volumes.size() > 0) {
+        lower->invalidate_bounding_box();
+        lower->center_around_origin();
+        res.push_back(lower);
+    }
 
     return res;
 }

src/libslic3r/Model.hpp

@@ -238,7 +238,7 @@ public:
     size_t materials_count() const;
     size_t facets_count() const;
     bool needed_repair() const;
-    ModelObjectPtrs cut(size_t instance, coordf_t z);
+    ModelObjectPtrs cut(size_t instance, coordf_t z, bool keep_upper = true, bool keep_lower = true, bool rotate_lower = false);    // Note: z is in world coordinates
     void split(ModelObjectPtrs* new_objects);
     void repair();
 

src/libslic3r/Technologies.hpp

@@ -33,6 +33,8 @@
 #define ENABLE_WORLD_ROTATIONS (1 && ENABLE_1_42_0)
 // Enables shortcut keys for gizmos
 #define ENABLE_GIZMOS_SHORTCUT (1 && ENABLE_1_42_0)
+// Scene's GUI made using imgui library
+#define ENABLE_IMGUI (1 && ENABLE_1_42_0)
 
 #endif // _technologies_h_
 

src/slic3r.cpp

@@ -12,15 +12,6 @@
     __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 #endif /* WIN32 */
 
-#include "libslic3r/libslic3r_version.h.in"
-#include "Config.hpp"
-#include "Geometry.hpp"
-#include "Model.hpp"
-#include "Print.hpp"
-#include "TriangleMesh.hpp"
-#include "Format/3mf.hpp"
-#include "libslic3r.h"
-#include "Utils.hpp"
 #include <cstdio>
 #include <string>
 #include <cstring>
@@ -31,9 +22,15 @@
 #include <boost/nowide/cenv.hpp>
 #include <boost/nowide/iostream.hpp>
 
-#ifdef USE_WX
-//    #include "GUI/GUI.hpp"
-#endif
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/Print.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/Format/3mf.hpp"
+#include "libslic3r/Utils.hpp"
+
 #include "slic3r/GUI/GUI.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 

src/slic3r/CMakeLists.txt

@@ -48,6 +48,8 @@ add_library(libslic3r_gui STATIC
     GUI/GUI_App.hpp
     GUI/GUI_Utils.cpp
     GUI/GUI_Utils.hpp
+    GUI/I18N.cpp
+    GUI/I18N.hpp
     GUI/MainFrame.cpp
     GUI/MainFrame.hpp
     GUI/Plater.cpp
@@ -82,6 +84,8 @@ add_library(libslic3r_gui STATIC
     GUI/BonjourDialog.hpp
     GUI/ButtonsDescription.cpp
     GUI/ButtonsDescription.hpp
+    GUI/ImGuiWrapper.hpp
+    GUI/ImGuiWrapper.cpp
     Config/Snapshot.cpp
     Config/Snapshot.hpp
     Config/Version.cpp
@@ -123,7 +127,7 @@ add_library(libslic3r_gui STATIC
     Utils/HexFile.hpp
 )
 
-target_link_libraries(libslic3r_gui libslic3r avrdude)
+target_link_libraries(libslic3r_gui libslic3r avrdude imgui)
 if (NOT SLIC3R_SYNTAXONLY)
     add_precompiled_header(libslic3r_gui pchheader.hpp FORCEINCLUDE)
 endif ()

src/slic3r/GUI/2DBed.cpp

@@ -1,9 +1,10 @@
 #include "2DBed.hpp"
 
 #include <wx/dcbuffer.h>
-#include "BoundingBox.hpp"
-#include "Geometry.hpp"
-#include "ClipperUtils.hpp"
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/ClipperUtils.hpp"
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/2DBed.hpp

@@ -2,7 +2,7 @@
 #define slic3r_2DBed_hpp_
 
 #include <wx/wx.h>
-#include "Config.hpp"
+#include "libslic3r/Config.hpp"
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/3DScene.cpp

@@ -9,8 +9,8 @@
 #include "libslic3r/Print.hpp"
 #include "libslic3r/SLAPrint.hpp"
 #include "libslic3r/Slicing.hpp"
+#include "libslic3r/GCode/Analyzer.hpp"
 #include "slic3r/GUI/PresetBundle.hpp"
-#include "GCode/Analyzer.hpp"
 
 #include <stdio.h>
 #include <stdlib.h>

src/slic3r/GUI/AboutDialog.cpp

@@ -1,6 +1,7 @@
 #include "AboutDialog.hpp"
+#include "I18N.hpp"
 
-#include "../../libslic3r/Utils.hpp"
+#include "libslic3r/Utils.hpp"
 
 namespace Slic3r { 
 namespace GUI {

src/slic3r/GUI/BackgroundSlicingProcess.hpp

@@ -8,7 +8,7 @@
 
 #include <wx/event.h>
 
-#include "Print.hpp"
+#include "libslic3r/Print.hpp"
 
 namespace Slic3r {
 

src/slic3r/GUI/BedShapeDialog.cpp

@@ -1,12 +1,14 @@
 #include "BedShapeDialog.hpp"
 
+#include <wx/wx.h> 
+#include <wx/numformatter.h>
 #include <wx/sizer.h>
 #include <wx/statbox.h>
-#include <wx/wx.h> 
-#include "Polygon.hpp"
-#include "BoundingBox.hpp"
-#include <wx/numformatter.h>
-#include "Model.hpp"
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/Polygon.hpp"
+
 #include "boost/nowide/iostream.hpp"
 
 #include <algorithm>

src/slic3r/GUI/BedShapeDialog.hpp

@@ -5,7 +5,7 @@
 
 #include "OptionsGroup.hpp"
 #include "2DBed.hpp"
-
+#include "I18N.hpp"
 
 #include <wx/dialog.h>
 #include <wx/choicebk.h>

src/slic3r/GUI/BonjourDialog.cpp

@@ -12,9 +12,9 @@
 #include <wx/timer.h>
 
 #include "slic3r/GUI/GUI.hpp"
+#include "slic3r/GUI/I18N.hpp"
 #include "slic3r/Utils/Bonjour.hpp"
 
-
 namespace Slic3r {
 
 

src/slic3r/GUI/ButtonsDescription.cpp

@@ -6,6 +6,7 @@
 
 #include "GUI.hpp"
 #include "GUI_App.hpp"
+#include "I18N.hpp"
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/ConfigSnapshotDialog.cpp

@@ -1,9 +1,10 @@
 #include "ConfigSnapshotDialog.hpp"
+#include "I18N.hpp"
 
 #include "../Config/Snapshot.hpp"
 #include "../Utils/Time.hpp"
 
-#include "../../libslic3r/Utils.hpp"
+#include "libslic3r/Utils.hpp"
 
 namespace Slic3r { 
 namespace GUI {

src/slic3r/GUI/Field.cpp

@@ -1,13 +1,14 @@
-#include "GUI.hpp"//"slic3r_gui.hpp"
+#include "GUI.hpp"
+#include "GUI_App.hpp"
+#include "I18N.hpp"
 #include "Field.hpp"
 
-//#include <wx/event.h>
+#include "libslic3r/PrintConfig.hpp"
+
 #include <regex>
 #include <wx/numformatter.h>
 #include <wx/tooltip.h>
-#include "PrintConfig.hpp"
 #include <boost/algorithm/string/predicate.hpp>
-#include "GUI_App.hpp"
 
 namespace Slic3r { namespace GUI {
 

src/slic3r/GUI/Field.hpp

@@ -13,12 +13,11 @@
 #include <wx/spinctrl.h>
 #include <wx/clrpicker.h>
 
-#include "../../libslic3r/libslic3r.h"
-#include "../../libslic3r/Config.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Config.hpp"
+#include "libslic3r/Utils.hpp"
 
-//#include "slic3r_gui.hpp"
 #include "GUI.hpp"
-#include "Utils.hpp"
 
 #ifdef __WXMSW__
 #define wxMSW true

src/slic3r/GUI/FirmwareDialog.cpp

@@ -13,6 +13,7 @@
 #include "libslic3r/Utils.hpp"
 #include "avrdude/avrdude-slic3r.hpp"
 #include "GUI.hpp"
+#include "I18N.hpp"
 #include "MsgDialog.hpp"
 #include "../Utils/HexFile.hpp"
 #include "../Utils/Serial.hpp"

src/slic3r/GUI/GLCanvas3D.cpp

@@ -1,20 +1,22 @@
+#include "slic3r/GUI/GLGizmo.hpp"
 #include "GLCanvas3D.hpp"
 
 #include "admesh/stl.h"
 #include "libslic3r/libslic3r.h"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/GCode/PreviewData.hpp"
+#include "libslic3r/Geometry.hpp"
 #include "slic3r/GUI/3DScene.hpp"
 #include "slic3r/GUI/BackgroundSlicingProcess.hpp"
 #include "slic3r/GUI/GLShader.hpp"
 #include "slic3r/GUI/GUI.hpp"
 #include "slic3r/GUI/PresetBundle.hpp"
-#include "slic3r/GUI/GLGizmo.hpp"
-#include "libslic3r/ClipperUtils.hpp"
-#include "libslic3r/PrintConfig.hpp"
-#include "libslic3r/GCode/PreviewData.hpp"
-#include "libslic3r/Geometry.hpp"
+//#include "slic3r/GUI/GLGizmo.hpp"
 #include "GUI_App.hpp"
 #include "GUI_ObjectList.hpp"
 #include "GUI_ObjectManipulation.hpp"
+#include "I18N.hpp"
 
 #include <GL/glew.h>
 
@@ -2893,7 +2895,7 @@ void GLCanvas3D::Gizmos::render_current_gizmo_for_picking_pass(const GLCanvas3D:
         curr->render_for_picking(selection);
 }
 
-void GLCanvas3D::Gizmos::render_overlay(const GLCanvas3D& canvas) const
+void GLCanvas3D::Gizmos::render_overlay(const GLCanvas3D& canvas, const GLCanvas3D::Selection& selection) const
 {
     if (!m_enabled)
         return;
@@ -2903,17 +2905,19 @@ void GLCanvas3D::Gizmos::render_overlay(const GLCanvas3D& canvas) const
     ::glPushMatrix();
     ::glLoadIdentity();
 
-    _render_overlay(canvas);
+    _render_overlay(canvas, selection);
 
     ::glPopMatrix();
 }
 
+#ifndef ENABLE_IMGUI
 void GLCanvas3D::Gizmos::create_external_gizmo_widgets(wxWindow *parent)
 {
     for (auto &entry : m_gizmos) {
         entry.second->create_external_gizmo_widgets(parent);
     }
 }
+#endif // not ENABLE_IMGUI
 
 void GLCanvas3D::Gizmos::_reset()
 {
@@ -2926,12 +2930,15 @@ void GLCanvas3D::Gizmos::_reset()
     m_gizmos.clear();
 }
 
-void GLCanvas3D::Gizmos::_render_overlay(const GLCanvas3D& canvas) const
+void GLCanvas3D::Gizmos::_render_overlay(const GLCanvas3D& canvas, const GLCanvas3D::Selection& selection) const
 {
     if (m_gizmos.empty())
         return;
 
     float cnv_w = (float)canvas.get_canvas_size().get_width();
+#if ENABLE_IMGUI
+    float cnv_h = (float)canvas.get_canvas_size().get_height();
+#endif // ENABLE_IMGUI
     float zoom = canvas.get_camera_zoom();
     float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f;
 
@@ -2946,6 +2953,10 @@ void GLCanvas3D::Gizmos::_render_overlay(const GLCanvas3D& canvas) const
 
         float tex_size = (float)it->second->get_textures_size() * OverlayTexturesScale * inv_zoom;
         GLTexture::render_texture(it->second->get_texture_id(), top_x, top_x + tex_size, top_y - tex_size, top_y);
+#if ENABLE_IMGUI
+        if (it->second->get_state() == GLGizmoBase::On)
+            it->second->render_input_window(2.0f * OverlayOffsetX + tex_size * zoom, 0.5f * cnv_h - top_y * zoom, selection);
+#endif // ENABLE_IMGUI
         top_y -= (tex_size + scaled_gap_y);
     }
 }
@@ -3316,9 +3327,12 @@ GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas)
     , m_dynamic_background_enabled(false)
     , m_multisample_allowed(false)
     , m_regenerate_volumes(true)
+    , m_moving(false)
     , m_color_by("volume")
     , m_reload_delayed(false)
+#ifndef ENABLE_IMGUI
     , m_external_gizmo_widgets_parent(nullptr)
+#endif // not ENABLE_IMGUI
 {
     if (m_canvas != nullptr)
     {
@@ -3426,10 +3440,12 @@ bool GLCanvas3D::init(bool useVBOs, bool use_legacy_opengl)
             return false;
         }
 
+#ifndef ENABLE_IMGUI
         if (m_external_gizmo_widgets_parent != nullptr) {
             m_gizmos.create_external_gizmo_widgets(m_external_gizmo_widgets_parent);
             m_canvas->GetParent()->Layout();
         }
+#endif // not ENABLE_IMGUI
     }
 
     if (!_init_toolbar())
@@ -3744,6 +3760,10 @@ void GLCanvas3D::render()
 
     set_tooltip("");
 
+#if ENABLE_IMGUI
+    wxGetApp().imgui()->new_frame();
+#endif // ENABLE_IMGUI
+
     // picking pass
     _picking_pass();
 
@@ -3786,6 +3806,10 @@ void GLCanvas3D::render()
     _render_toolbar();
     _render_layer_editing_overlay();
 
+#if ENABLE_IMGUI
+    wxGetApp().imgui()->render();
+#endif // ENABLE_IMGUI
+
     m_canvas->SwapBuffers();
 }
 
@@ -4445,6 +4469,16 @@ void GLCanvas3D::on_timer(wxTimerEvent& evt)
 
 void GLCanvas3D::on_mouse(wxMouseEvent& evt)
 {
+#if ENABLE_IMGUI
+    auto imgui = wxGetApp().imgui();
+    if (imgui->update_mouse_data(evt)) {
+        render();
+        if (imgui->want_any_input()) {
+            return;
+        }
+    }
+#endif // ENABLE_IMGUI
+
     Point pos(evt.GetX(), evt.GetY());
 
     int selected_object_idx = m_selection.get_object_idx();
@@ -4631,6 +4665,7 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
 #else
                         m_mouse.drag.start_position_3D = pos3d;
 #endif // ENABLE_GIZMOS_ON_TOP
+                        m_moving = true;
                     }
                 }
                 else if (evt.RightDown())
@@ -4846,6 +4881,7 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
             post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
         }
 
+        m_moving = false;
         m_mouse.drag.move_volume_idx = -1;
         m_mouse.set_start_position_3D_as_invalid();
         m_mouse.set_start_position_2D_as_invalid();
@@ -4935,10 +4971,12 @@ void GLCanvas3D::set_tooltip(const std::string& tooltip) const
     }
 }
 
+#ifndef ENABLE_IMGUI
 void GLCanvas3D::set_external_gizmo_widgets_parent(wxWindow *parent)
 {
     m_external_gizmo_widgets_parent = parent;
 }
+#endif // not ENABLE_IMGUI
 
 void GLCanvas3D::do_move()
 {
@@ -5300,6 +5338,10 @@ void GLCanvas3D::_resize(unsigned int w, unsigned int h)
     if ((m_canvas == nullptr) && (m_context == nullptr))
         return;
 
+#if ENABLE_IMGUI
+    wxGetApp().imgui()->set_display_size((float)w, (float)h);
+#endif // ENABLE_IMGUI
+
     // ensures that this canvas is current
 #if ENABLE_USE_UNIQUE_GLCONTEXT
     _set_current();
@@ -5770,7 +5812,7 @@ void GLCanvas3D::_render_current_gizmo() const
 
 void GLCanvas3D::_render_gizmos_overlay() const
 {
-    m_gizmos.render_overlay(*this);
+    m_gizmos.render_overlay(*this, m_selection);
 }
 
 void GLCanvas3D::_render_toolbar() const

src/slic3r/GUI/GLCanvas3D.hpp

@@ -636,14 +636,16 @@ private:
         void render_current_gizmo(const Selection& selection) const;
         void render_current_gizmo_for_picking_pass(const Selection& selection) const;
 
-        void render_overlay(const GLCanvas3D& canvas) const;
+        void render_overlay(const GLCanvas3D& canvas, const Selection& selection) const;
 
+#ifndef ENABLE_IMGUI
         void create_external_gizmo_widgets(wxWindow *parent);
+#endif // not ENABLE_IMGUI
 
     private:
         void _reset();
 
-        void _render_overlay(const GLCanvas3D& canvas) const;
+        void _render_overlay(const GLCanvas3D& canvas, const Selection& selection) const;
         void _render_current_gizmo(const Selection& selection) const;
 
         float _get_total_overlay_height() const;
@@ -724,6 +726,7 @@ private:
     bool m_dynamic_background_enabled;
     bool m_multisample_allowed;
     bool m_regenerate_volumes;
+    bool m_moving;
 
     std::string m_color_by;
 
@@ -731,9 +734,10 @@ private:
 
     GCodePreviewVolumeIndex m_gcode_preview_volume_index;
 
+#ifndef ENABLE_IMGUI
     wxWindow *m_external_gizmo_widgets_parent;
+#endif // not ENABLE_IMGUI
 
-    void post_event(wxEvent &&event);
     void viewport_changed();
 
 public:
@@ -747,6 +751,7 @@ public:
     wxGLCanvas* get_wxglcanvas() { return m_canvas; }
 
     bool init(bool useVBOs, bool use_legacy_opengl);
+    void post_event(wxEvent &&event);
 
 #if !ENABLE_USE_UNIQUE_GLCONTEXT
     bool set_current();
@@ -811,7 +816,7 @@ public:
 
     Rect get_gizmo_reset_rect(const GLCanvas3D& canvas, bool viewport) const;
     bool gizmo_reset_rect_contains(const GLCanvas3D& canvas, float x, float y) const;
-    bool is_gizmo_dragging() const { return m_gizmos.is_dragging(); }
+    bool is_dragging() const { return m_gizmos.is_dragging() || m_moving; }
 
     void render();
 
@@ -851,7 +856,9 @@ public:
 
     void set_tooltip(const std::string& tooltip) const;
 
+#ifndef ENABLE_IMGUI
     void set_external_gizmo_widgets_parent(wxWindow *parent);
+#endif // not ENABLE_IMGUI
 
     void do_move();
     void do_rotate();

src/slic3r/GUI/GLGizmo.cpp

@@ -1,19 +1,11 @@
-#include "libslic3r/libslic3r.h"
-#include "GLGizmo.hpp"
-
-#include "GUI.hpp"
-#include "GUI_App.hpp"
-
-#include "../../libslic3r/Utils.hpp"
-#include "PresetBundle.hpp"
-
-#include <Eigen/Dense>
-#include "libslic3r/Geometry.hpp"
-
-#include <igl/unproject_onto_mesh.h>
+// #include <igl/unproject_onto_mesh.h>
 #include <GL/glew.h>
+#include <Eigen/Dense>
 
-#include <SLA/SLASupportTree.hpp>
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/SLA/SLASupportTree.hpp"
 
 #include <cstdio>
 #include <numeric>
@@ -29,6 +21,9 @@
 #include "GUI.hpp"
 #include "GUI_Utils.hpp"
 #include "GUI_App.hpp"
+#include "I18N.hpp"
+#include "GLGizmo.hpp"
+#include "PresetBundle.hpp"
 
 #if ENABLE_GIZMOS_SHORTCUT
 #include <wx/defs.h>
@@ -170,6 +165,7 @@ GLGizmoBase::GLGizmoBase(GLCanvas3D& parent)
 #endif // ENABLE_GIZMOS_SHORTCUT
     , m_hover_id(-1)
     , m_dragging(false)
+    , m_imgui(wxGetApp().imgui())
 {
     ::memcpy((void*)m_base_color, (const void*)DEFAULT_BASE_COLOR, 3 * sizeof(float));
     ::memcpy((void*)m_drag_color, (const void*)DEFAULT_DRAG_COLOR, 3 * sizeof(float));
@@ -273,7 +269,9 @@ void GLGizmoBase::render_grabbers_for_picking(const BoundingBoxf3& box) const
     }
 }
 
+#ifndef ENABLE_IMGUI
 void GLGizmoBase::create_external_gizmo_widgets(wxWindow *parent) {}
+#endif // not ENABLE_IMGUI
 
 void GLGizmoBase::set_tooltip(const std::string& tooltip) const
 {
@@ -686,6 +684,20 @@ void GLGizmoRotate3D::on_render(const GLCanvas3D::Selection& selection) const
         m_gizmos[Z].render(selection);
 }
 
+#if ENABLE_IMGUI
+void GLGizmoRotate3D::on_render_input_window(float x, float y, const GLCanvas3D::Selection& selection)
+{
+    Vec3d rotation(Geometry::rad2deg(m_gizmos[0].get_angle()), Geometry::rad2deg(m_gizmos[1].get_angle()), Geometry::rad2deg(m_gizmos[2].get_angle()));
+    wxString label = _(L("Rotation (deg)"));
+
+    m_imgui->set_next_window_pos(x, y, ImGuiCond_Always);
+    m_imgui->set_next_window_bg_alpha(0.5f);
+    m_imgui->begin(label, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
+    m_imgui->input_vec3("", rotation, 100.0f, "%.2f");
+    m_imgui->end();
+}
+#endif // ENABLE_IMGUI
+
 const float GLGizmoScale3D::Offset = 5.0f;
 
 GLGizmoScale3D::GLGizmoScale3D(GLCanvas3D& parent)
@@ -972,6 +984,20 @@ void GLGizmoScale3D::on_render_for_picking(const GLCanvas3D::Selection& selectio
     render_grabbers_for_picking(selection.get_bounding_box());
 }
 
+#if ENABLE_IMGUI
+void GLGizmoScale3D::on_render_input_window(float x, float y, const GLCanvas3D::Selection& selection)
+{
+    bool single_instance = selection.is_single_full_instance();
+    wxString label = _(L("Scale (%)"));
+
+    m_imgui->set_next_window_pos(x, y, ImGuiCond_Always);
+    m_imgui->set_next_window_bg_alpha(0.5f);
+    m_imgui->begin(label, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
+    m_imgui->input_vec3("", m_scale, 100.0f, "%.2f");
+    m_imgui->end();
+}
+#endif // ENABLE_IMGUI
+
 void GLGizmoScale3D::render_grabbers_connection(unsigned int id_1, unsigned int id_2) const
 {
     unsigned int grabbers_count = (unsigned int)m_grabbers.size();
@@ -1185,6 +1211,24 @@ void GLGizmoMove3D::on_render_for_picking(const GLCanvas3D::Selection& selection
     render_grabbers_for_picking(selection.get_bounding_box());
 }
 
+#if ENABLE_IMGUI
+void GLGizmoMove3D::on_render_input_window(float x, float y, const GLCanvas3D::Selection& selection)
+{
+    bool show_position = selection.is_single_full_instance();
+    const Vec3d& position = selection.get_bounding_box().center();
+
+    Vec3d displacement = show_position ? position : m_displacement;
+    wxString label = show_position ? _(L("Position (mm)")) : _(L("Displacement (mm)"));
+
+    m_imgui->set_next_window_pos(x, y, ImGuiCond_Always);
+    m_imgui->set_next_window_bg_alpha(0.5f);
+    m_imgui->begin(label, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
+    m_imgui->input_vec3("", displacement, 100.0f, "%.2f");
+
+    m_imgui->end();
+}
+#endif // ENABLE_IMGUI
+
 double GLGizmoMove3D::calc_projection(const UpdateData& data) const
 {
     double projection = 0.0;
@@ -1264,16 +1308,18 @@ void GLGizmoFlatten::on_render(const GLCanvas3D::Selection& selection) const
     if (dragged_offset.norm() > 0.001)
         return;
 
-    ::glEnable(GL_BLEND);
+
+#if ENABLE_GIZMOS_ON_TOP
+    ::glClear(GL_DEPTH_BUFFER_BIT);
+#endif // ENABLE_GIZMOS_ON_TOP
     ::glEnable(GL_DEPTH_TEST);
-    ::glDisable(GL_CULL_FACE);
+    ::glEnable(GL_BLEND);
 
     if (selection.is_from_single_object()) {
-        const std::set<int>& instances_list = selection.get_instance_idxs();
-
-        if (!instances_list.empty() && m_model_object) {
-            for (const int instance_idx : instances_list) {
-            Transform3d m = m_model_object->instances[instance_idx]->get_matrix();
+        if (m_model_object) {
+            //for (const int instance_idx : instances_list) {
+            for (const ModelInstance* inst : m_model_object->instances) {
+                Transform3d m = inst->get_matrix();
                 for (int i=0; i<(int)m_planes.size(); ++i) {
                     if (i == m_hover_id)
                         ::glColor4f(0.9f, 0.9f, 0.9f, 0.75f);
@@ -1299,16 +1345,16 @@ void GLGizmoFlatten::on_render(const GLCanvas3D::Selection& selection) const
 
 void GLGizmoFlatten::on_render_for_picking(const GLCanvas3D::Selection& selection) const
 {
-    ::glEnable(GL_DEPTH_TEST);
-    ::glDisable(GL_CULL_FACE);
+    ::glDisable(GL_DEPTH_TEST);
+    ::glDisable(GL_BLEND);
+
     if (selection.is_from_single_object()) {
-        const std::set<int>& instances_list = selection.get_instance_idxs();
-        if (!instances_list.empty() && m_model_object) {
-            for (const int instance_idx : instances_list) {
+        if (m_model_object)
+            for (const ModelInstance* inst : m_model_object->instances) {
                 for (int i=0; i<(int)m_planes.size(); ++i) {
                     ::glColor3f(1.0f, 1.0f, picking_color_component(i));
                     ::glPushMatrix();
-                    ::glMultMatrixd(m_model_object->instances[instance_idx]->get_matrix().data());
+                    ::glMultMatrixd(inst->get_matrix().data());
                     ::glBegin(GL_POLYGON);
                     for (const Vec3d& vertex : m_planes[i].vertices)
                         ::glVertex3dv(vertex.data());
@@ -1316,7 +1362,6 @@ void GLGizmoFlatten::on_render_for_picking(const GLCanvas3D::Selection& selectio
                     ::glPopMatrix();
                 }
             }
-        }
     }
 
     ::glEnable(GL_CULL_FACE);
@@ -1338,6 +1383,8 @@ void GLGizmoFlatten::update_planes()
     for (const ModelVolume* vol : m_model_object->volumes)
 #if ENABLE_MODELVOLUME_TRANSFORM
     {
+        if (vol->type() != ModelVolume::Type::MODEL_PART)
+            continue;
         TriangleMesh vol_ch = vol->get_convex_hull();
         vol_ch.transform(vol->get_matrix());
         ch.merge(vol_ch);
@@ -1578,7 +1625,11 @@ void GLGizmoSlaSupports::set_model_object_ptr(ModelObject* model_object)
     {
         m_starting_center = Vec3d::Zero();
         m_model_object = model_object;
-        m_model_object_matrix = model_object->instances.front()->get_matrix();
+
+        int selected_instance = m_parent.get_selection().get_instance_idx();
+        assert(selected_instance < (int)model_object->instances.size());
+
+        m_instance_matrix = model_object->instances[selected_instance]->get_matrix();
         if (is_mesh_update_necessary())
             update_mesh();
     }
@@ -1590,7 +1641,7 @@ void GLGizmoSlaSupports::on_render(const GLCanvas3D::Selection& selection) const
     ::glEnable(GL_DEPTH_TEST);
 
     // the dragged_offset is a vector measuring where was the object moved
-    // with the gizmo being on. This is reset in set_flattening_data and
+    // with the gizmo being on. This is reset in set_model_object_ptr and
     // does not work correctly when there are multiple copies.
     
     if (m_starting_center == Vec3d::Zero())
@@ -1604,7 +1655,7 @@ void GLGizmoSlaSupports::on_render(const GLCanvas3D::Selection& selection) const
     }
 
     ::glPushMatrix();
-    ::glTranslatef((GLfloat)dragged_offset(0), (GLfloat)dragged_offset(1), (GLfloat)dragged_offset(2));
+    //::glTranslatef((GLfloat)dragged_offset(0), (GLfloat)dragged_offset(1), (GLfloat)dragged_offset(2));
     render_grabbers();
     ::glPopMatrix();
 
@@ -1626,33 +1677,35 @@ void GLGizmoSlaSupports::on_render_for_picking(const GLCanvas3D::Selection& sele
 
 void GLGizmoSlaSupports::render_grabbers(bool picking) const
 {
-    for (int i = 0; i < (int)m_grabbers.size(); ++i)
-    {
-        if (!m_grabbers[i].enabled)
-            continue;
+    for (const ModelInstance* inst : m_model_object->instances) {
+        for (int i = 0; i < (int)m_grabbers.size(); ++i)
+        {
+            if (!m_grabbers[i].enabled)
+                continue;
 
-        float render_color[3];
-        if (!picking && m_hover_id == i) {
-            render_color[0] = 1.0f - m_grabbers[i].color[0];
-            render_color[1] = 1.0f - m_grabbers[i].color[1];
-            render_color[2] = 1.0f - m_grabbers[i].color[2];
+            float render_color[3];
+            if (!picking && m_hover_id == i) {
+                render_color[0] = 1.0f - m_grabbers[i].color[0];
+                render_color[1] = 1.0f - m_grabbers[i].color[1];
+                render_color[2] = 1.0f - m_grabbers[i].color[2];
+            }
+            else
+                ::memcpy((void*)render_color, (const void*)m_grabbers[i].color, 3 * sizeof(float));
+            if (!picking)
+                ::glEnable(GL_LIGHTING);
+            ::glColor3f((GLfloat)render_color[0], (GLfloat)render_color[1], (GLfloat)render_color[2]);
+            ::glPushMatrix();
+            Vec3d center = inst->get_matrix() * m_grabbers[i].center;
+            ::glTranslatef((GLfloat)center(0), (GLfloat)center(1), (GLfloat)center(2));
+            GLUquadricObj *quadric;
+            quadric = ::gluNewQuadric();
+            ::gluQuadricDrawStyle(quadric, GLU_FILL );
+            ::gluSphere( quadric , 0.75f, 36 , 18 );
+            ::gluDeleteQuadric(quadric);
+            ::glPopMatrix();
+            if (!picking)
+                ::glDisable(GL_LIGHTING);
         }
-        else
-            ::memcpy((void*)render_color, (const void*)m_grabbers[i].color, 3 * sizeof(float));
-        if (!picking)
-            ::glEnable(GL_LIGHTING);
-        ::glColor3f((GLfloat)render_color[0], (GLfloat)render_color[1], (GLfloat)render_color[2]);
-        ::glPushMatrix();
-        Vec3d center = m_model_object_matrix * m_grabbers[i].center;
-        ::glTranslatef((GLfloat)center(0), (GLfloat)center(1), (GLfloat)center(2));
-        GLUquadricObj *quadric;
-        quadric = ::gluNewQuadric();
-        ::gluQuadricDrawStyle(quadric, GLU_FILL );
-        ::gluSphere( quadric , 0.75f, 36 , 18 );
-        ::gluDeleteQuadric(quadric);
-        ::glPopMatrix();
-        if (!picking)
-            ::glDisable(GL_LIGHTING);
     }
 }
 
@@ -1661,7 +1714,7 @@ bool GLGizmoSlaSupports::is_mesh_update_necessary() const
     if (m_state != On || !m_model_object || m_model_object->instances.empty())
         return false;
 
-    if ((m_model_object->instances.front()->get_matrix() * m_source_data.matrix.inverse() * Vec3d(1., 1., 1.) - Vec3d(1., 1., 1.)).norm() > 0.001)
+    if ((m_instance_matrix * m_source_data.matrix.inverse() * Vec3d(1., 1., 1.) - Vec3d(1., 1., 1.)).norm() > 0.001)
         return true;
 
     // following should detect direct mesh changes (can be removed after the mesh is made completely immutable):
@@ -1677,7 +1730,7 @@ void GLGizmoSlaSupports::update_mesh()
 {
     Eigen::MatrixXf& V = m_V;
     Eigen::MatrixXi& F = m_F;
-    TriangleMesh mesh(m_model_object->mesh());
+    TriangleMesh mesh = m_model_object->mesh();
     const stl_file& stl = mesh.stl;
     V.resize(3 * stl.stats.number_of_facets, 3);
     F.resize(stl.stats.number_of_facets, 3);
@@ -1690,15 +1743,19 @@ void GLGizmoSlaSupports::update_mesh()
         F(i, 1) = 3*i+1;
         F(i, 2) = 3*i+2;
     }
-    m_source_data.matrix = m_model_object->instances.front()->get_matrix();
-    const float* first_vertex = m_model_object->volumes.front()->get_convex_hull().first_vertex();
-    m_source_data.mesh_first_point = Vec3d((double)first_vertex[0], (double)first_vertex[1], (double)first_vertex[2]);
+
+    m_AABB = igl::AABB<Eigen::MatrixXf,3>();
+    m_AABB.init(m_V, m_F);
+
+    m_source_data.matrix = m_instance_matrix;
+
     // we'll now reload Grabbers (selection might have changed):
     m_grabbers.clear();
     for (const Vec3f& point : m_model_object->sla_support_points) {
         m_grabbers.push_back(Grabber());
         m_grabbers.back().center = point.cast<double>();
     }
+    m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
 }
 
 Vec3f GLGizmoSlaSupports::unproject_on_mesh(const Vec2d& mouse_pos)
@@ -1714,24 +1771,21 @@ Vec3f GLGizmoSlaSupports::unproject_on_mesh(const Vec2d& mouse_pos)
     Eigen::Matrix<GLdouble, 4, 4, Eigen::DontAlign> projection_matrix;
     ::glGetDoublev(GL_PROJECTION_MATRIX, projection_matrix.data());
 
-    int fid = 0;
-    Eigen::Vector3f bc(0, 0, 0);
-    if (!igl::unproject_onto_mesh(Vec2f(mouse_pos(0), viewport(3)-mouse_pos(1)), modelview_matrix.cast<float>(), projection_matrix.cast<float>(), viewport.cast<float>(), m_V, m_F, fid, bc))
-    /*if (!igl::embree::unproject_onto_mesh(Vec2f(mouse_pos(0), viewport(3)-mouse_pos(1)),
-                                 m_F,
-                                 modelview_matrix.cast<float>(),
-                                 projection_matrix.cast<float>(),
-                                 viewport.cast<float>(),
-                                 m_intersector,
-                                 fid,
-                                 bc))*/
-        throw "unable to unproject_onto_mesh";
+    Vec3d point1;
+    Vec3d point2;
+    ::gluUnProject(mouse_pos(0), viewport(3)-mouse_pos(1), 0.f, modelview_matrix.data(), projection_matrix.data(), viewport.data(), &point1(0), &point1(1), &point1(2));
+    ::gluUnProject(mouse_pos(0), viewport(3)-mouse_pos(1), 1.f, modelview_matrix.data(), projection_matrix.data(), viewport.data(), &point2(0), &point2(1), &point2(2));
 
-    const Vec3f& a = m_V.row(m_F(fid, 0));
-    const Vec3f& b = m_V.row(m_F(fid, 1));
-    const Vec3f& c = m_V.row(m_F(fid, 2));
-    Vec3f point = bc(0)*a + bc(1)*b + bc(2)*c;
-    return m_model_object->instances.front()->get_matrix().inverse().cast<float>() * point;
+    igl::Hit hit;
+
+    if (!m_AABB.intersect_ray(m_V, m_F, point1.cast<float>(), (point2-point1).cast<float>(), hit))
+        throw std::invalid_argument("unproject_on_mesh(): No intersection found.");
+
+    int fid = hit.id;
+    Vec3f bc(1-hit.u-hit.v, hit.u, hit.v);
+    Vec3f point = bc(0) * m_V.row(m_F(fid, 0)) + bc(1) * m_V.row(m_F(fid, 1)) + bc(2)*m_V.row(m_F(fid, 2));
+
+    return m_instance_matrix.inverse().cast<float>() * point;
 }
 
 void GLGizmoSlaSupports::clicked_on_object(const Vec2d& mouse_position)
@@ -1739,14 +1793,17 @@ void GLGizmoSlaSupports::clicked_on_object(const Vec2d& mouse_position)
     Vec3f new_pos;
     try {
         new_pos = unproject_on_mesh(mouse_position); // this can throw - we don't want to create a new grabber in that case
-        m_grabbers.push_back(Grabber());
-        m_grabbers.back().center = new_pos.cast<double>();
-        m_model_object->sla_support_points.push_back(new_pos);
-
-        // This should trigger the support generation
-        // wxGetApp().plater()->reslice();
     }
-    catch (...) {}
+    catch (...) { return; }
+
+    m_grabbers.push_back(Grabber());
+    m_grabbers.back().center = new_pos.cast<double>();
+    m_model_object->sla_support_points.push_back(new_pos);
+
+    // This should trigger the support generation
+    // wxGetApp().plater()->reslice();
+
+    m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
 }
 
 void GLGizmoSlaSupports::delete_current_grabber(bool delete_all)
@@ -1767,6 +1824,8 @@ void GLGizmoSlaSupports::delete_current_grabber(bool delete_all)
             // This should trigger the support generation
             // wxGetApp().plater()->reslice();
         }
+
+    m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
 }
 
 void GLGizmoSlaSupports::on_update(const UpdateData& data)
@@ -1775,20 +1834,21 @@ void GLGizmoSlaSupports::on_update(const UpdateData& data)
         Vec3f new_pos;
         try {
             new_pos = unproject_on_mesh(Vec2d((*data.mouse_pos)(0), (*data.mouse_pos)(1)));
-            m_grabbers[m_hover_id].center = new_pos.cast<double>();
-            m_model_object->sla_support_points[m_hover_id] = new_pos;
         }
-        catch (...) {}
+        catch (...) { return; }
+        m_grabbers[m_hover_id].center = new_pos.cast<double>();
+        m_model_object->sla_support_points[m_hover_id] = new_pos;
+        m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
     }
 }
 
 
 void GLGizmoSlaSupports::render_tooltip_texture() const {
     if (m_tooltip_texture.get_id() == 0)
-        if (!m_tooltip_texture.load_from_file(resources_dir() + "/icons/variable_layer_height_tooltip.png", false))
+        if (!m_tooltip_texture.load_from_file(resources_dir() + "/icons/sla_support_points_tooltip.png", false))
             return;
     if (m_reset_texture.get_id() == 0)
-        if (!m_reset_texture.load_from_file(resources_dir() + "/icons/variable_layer_height_reset.png", false))
+        if (!m_reset_texture.load_from_file(resources_dir() + "/icons/sla_support_points_reset.png", false))
             return;
 
     float zoom = m_parent.get_camera_zoom();
@@ -1814,7 +1874,8 @@ void GLGizmoSlaSupports::render_tooltip_texture() const {
 
 bool GLGizmoSlaSupports::on_is_activable(const GLCanvas3D::Selection& selection) const
 {
-    return (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA);
+    return (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA)
+        && selection.is_from_single_instance();
 }
 
 bool GLGizmoSlaSupports::on_is_selectable() const
@@ -1879,9 +1940,15 @@ const std::array<float, 3> GLGizmoCut::GrabberColor = { 1.0, 0.5, 0.0 };
 GLGizmoCut::GLGizmoCut(GLCanvas3D& parent)
     : GLGizmoBase(parent)
     , m_cut_z(0.0)
+#ifndef ENABLE_IMGUI
     , m_panel(nullptr)
+#endif // not ENABLE_IMGUI
+    , m_keep_upper(true)
+    , m_keep_lower(true)
+    , m_rotate_lower(false)
 {}
 
+#ifndef ENABLE_IMGUI
 void GLGizmoCut::create_external_gizmo_widgets(wxWindow *parent)
 {
     wxASSERT(m_panel == nullptr);
@@ -1896,9 +1963,10 @@ void GLGizmoCut::create_external_gizmo_widgets(wxWindow *parent)
 
     m_panel->Hide();
     m_panel->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
-        perform_cut();
+        perform_cut(m_parent.get_selection());
     }, wxID_OK);
 }
+#endif // not ENABLE_IMGUI
 
 bool GLGizmoCut::on_init()
 {
@@ -1936,13 +2004,15 @@ void GLGizmoCut::on_set_state()
 {
     // Reset m_cut_z on gizmo activation
     if (get_state() == On) {
-        m_cut_z = 0.0;
+        m_cut_z = m_parent.get_selection().get_bounding_box().size()(2) / 2.0;
     }
 
+#ifndef ENABLE_IMGUI
     // Display or hide the extra panel
     if (m_panel != nullptr) {
         m_panel->display(get_state() == On);
     }
+#endif // not ENABLE_IMGUI
 }
 
 bool GLGizmoCut::on_is_activable(const GLCanvas3D::Selection& selection) const
@@ -1956,10 +2026,10 @@ void GLGizmoCut::on_start_dragging(const GLCanvas3D::Selection& selection)
 
     const BoundingBoxf3& box = selection.get_bounding_box();
     m_start_z = m_cut_z;
-    m_max_z = box.size()(2) / 2.0;
+    m_max_z = box.size()(2);
     m_drag_pos = m_grabbers[m_hover_id].center;
     m_drag_center = box.center();
-    m_drag_center(2) += m_cut_z;
+    m_drag_center(2) = m_cut_z;
 }
 
 void GLGizmoCut::on_update(const UpdateData& data)
@@ -1967,7 +2037,7 @@ void GLGizmoCut::on_update(const UpdateData& data)
     if (m_hover_id != -1) {
         // Clamp the plane to the object's bounding box
         const double new_z = m_start_z + calc_projection(data.mouse_ray);
-        m_cut_z = std::max(-m_max_z, std::min(m_max_z, new_z));
+        m_cut_z = std::max(0.0, std::min(m_max_z, new_z));
     }
 }
 
@@ -1979,7 +2049,7 @@ void GLGizmoCut::on_render(const GLCanvas3D::Selection& selection) const
 
     const BoundingBoxf3& box = selection.get_bounding_box();
     Vec3d plane_center = box.center();
-    plane_center(2) += m_cut_z;
+    plane_center(2) = m_cut_z;
 
     const float min_x = box.min(0) - Margin;
     const float max_x = box.max(0) + Margin;
@@ -2027,16 +2097,38 @@ void GLGizmoCut::on_render_for_picking(const GLCanvas3D::Selection& selection) c
     render_grabbers_for_picking(selection.get_bounding_box());
 }
 
-void GLGizmoCut::perform_cut()
+#if ENABLE_IMGUI
+void GLGizmoCut::on_render_input_window(float x, float y, const GLCanvas3D::Selection& selection)
 {
-    const auto &selection = m_parent.get_selection();
+    m_imgui->set_next_window_pos(x, y, ImGuiCond_Always);
+    m_imgui->set_next_window_bg_alpha(0.5f);
+    m_imgui->begin(_(L("Cut")), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
 
+    ImGui::PushItemWidth(100.0f);
+    bool _value_changed = ImGui::InputDouble("Z", &m_cut_z, 0.0f, 0.0f, "%.2f");
+
+    m_imgui->checkbox(_(L("Keep upper part")), m_keep_upper);
+    m_imgui->checkbox(_(L("Keep lower part")), m_keep_lower);
+    m_imgui->checkbox(_(L("Rotate lower part upwards")), m_rotate_lower);
+
+    const bool cut_clicked = m_imgui->button(_(L("Perform cut")));
+
+    m_imgui->end();
+
+    if (cut_clicked) {
+        perform_cut(selection);
+    }
+}
+#endif // ENABLE_IMGUI
+
+void GLGizmoCut::perform_cut(const GLCanvas3D::Selection& selection)
+{
     const auto instance_idx = selection.get_instance_idx();
     const auto object_idx = selection.get_object_idx();
 
     wxCHECK_RET(instance_idx >= 0 && object_idx >= 0, "GLGizmoCut: Invalid object selection");
 
-    wxGetApp().plater()->cut(object_idx, instance_idx, m_cut_z);
+    wxGetApp().plater()->cut(object_idx, instance_idx, m_cut_z, m_keep_upper, m_keep_lower, m_rotate_lower);
 }
 
 double GLGizmoCut::calc_projection(const Linef3& mouse_ray) const

src/slic3r/GUI/GLGizmo.hpp

@@ -1,6 +1,8 @@
 #ifndef slic3r_GLGizmo_hpp_
 #define slic3r_GLGizmo_hpp_
 
+#include <igl/AABB.h>
+
 #include "../../slic3r/GUI/GLTexture.hpp"
 #include "../../slic3r/GUI/GLCanvas3D.hpp"
 #include "../../libslic3r/Point.hpp"
@@ -23,6 +25,7 @@ class ModelObject;
 namespace GUI {
 
 class GLCanvas3D;
+class ImGuiWrapper;
 
 class GLGizmoBase
 {
@@ -88,6 +91,7 @@ protected:
     float m_drag_color[3];
     float m_highlight_color[3];
     mutable std::vector<Grabber> m_grabbers;
+    ImGuiWrapper* m_imgui;
 
 public:
     explicit GLGizmoBase(GLCanvas3D& parent);
@@ -135,7 +139,13 @@ public:
     void render(const GLCanvas3D::Selection& selection) const { on_render(selection); }
     void render_for_picking(const GLCanvas3D::Selection& selection) const { on_render_for_picking(selection); }
 
+#ifndef ENABLE_IMGUI
     virtual void create_external_gizmo_widgets(wxWindow *parent);
+#endif // not ENABLE_IMGUI
+
+#if ENABLE_IMGUI
+    void render_input_window(float x, float y, const GLCanvas3D::Selection& selection) { on_render_input_window(x, y, selection); }
+#endif // ENABLE_IMGUI
 
 protected:
     virtual bool on_init() = 0;
@@ -155,6 +165,10 @@ protected:
     virtual void on_render(const GLCanvas3D::Selection& selection) const = 0;
     virtual void on_render_for_picking(const GLCanvas3D::Selection& selection) const = 0;
 
+#if ENABLE_IMGUI
+    virtual void on_render_input_window(float x, float y, const GLCanvas3D::Selection& selection) {}
+#endif // ENABLE_IMGUI
+
     float picking_color_component(unsigned int id) const;
     void render_grabbers(const BoundingBoxf3& box) const;
     void render_grabbers_for_picking(const BoundingBoxf3& box) const;
@@ -291,6 +305,10 @@ protected:
             g.render_for_picking(selection);
         }
     }
+
+#if ENABLE_IMGUI
+    virtual void on_render_input_window(float x, float y, const GLCanvas3D::Selection& selection);
+#endif // ENABLE_IMGUI
 };
 
 class GLGizmoScale3D : public GLGizmoBase
@@ -328,6 +346,10 @@ protected:
     virtual void on_render(const GLCanvas3D::Selection& selection) const;
     virtual void on_render_for_picking(const GLCanvas3D::Selection& selection) const;
 
+#if ENABLE_IMGUI
+    virtual void on_render_input_window(float x, float y, const GLCanvas3D::Selection& selection);
+#endif // ENABLE_IMGUI
+
 private:
     void render_grabbers_connection(unsigned int id_1, unsigned int id_2) const;
 
@@ -368,6 +390,10 @@ protected:
     virtual void on_render(const GLCanvas3D::Selection& selection) const;
     virtual void on_render_for_picking(const GLCanvas3D::Selection& selection) const;
 
+#if ENABLE_IMGUI
+    virtual void on_render_input_window(float x, float y, const GLCanvas3D::Selection& selection);
+#endif // ENABLE_IMGUI
+
 private:
     double calc_projection(const UpdateData& data) const;
 };
@@ -425,11 +451,13 @@ class GLGizmoSlaSupports : public GLGizmoBase
 {
 private:
     ModelObject* m_model_object = nullptr;
-    Transform3d m_model_object_matrix;
+    Transform3d m_instance_matrix;
     Vec3f unproject_on_mesh(const Vec2d& mouse_pos);
 
     Eigen::MatrixXf m_V; // vertices
     Eigen::MatrixXi m_F; // facets indices
+    igl::AABB<Eigen::MatrixXf,3> m_AABB;
+
     struct SourceDataSummary {
         BoundingBoxf3 bounding_box;
         Transform3d matrix;
@@ -474,7 +502,9 @@ protected:
 };
 
 
+#ifndef ENABLE_IMGUI
 class GLGizmoCutPanel;
+#endif // not ENABLE_IMGUI
 
 class GLGizmoCut : public GLGizmoBase
 {
@@ -487,12 +517,21 @@ class GLGizmoCut : public GLGizmoBase
     double m_max_z;
     Vec3d m_drag_pos;
     Vec3d m_drag_center;
+    bool m_keep_upper;
+    bool m_keep_lower;
+    bool m_rotate_lower;
+#ifndef ENABLE_IMGUI
     GLGizmoCutPanel *m_panel;
+#endif // not ENABLE_IMGUI
 
 public:
     explicit GLGizmoCut(GLCanvas3D& parent);
 
+#ifndef ENABLE_IMGUI
     virtual void create_external_gizmo_widgets(wxWindow *parent);
+#endif // not ENABLE_IMGUI
+#ifndef ENABLE_IMGUI
+#endif // not ENABLE_IMGUI
 
 protected:
     virtual bool on_init();
@@ -504,8 +543,11 @@ protected:
     virtual void on_render(const GLCanvas3D::Selection& selection) const;
     virtual void on_render_for_picking(const GLCanvas3D::Selection& selection) const;
 
+#if ENABLE_IMGUI
+    virtual void on_render_input_window(float x, float y, const GLCanvas3D::Selection& selection);
+#endif // ENABLE_IMGUI
 private:
-    void perform_cut();
+    void perform_cut(const GLCanvas3D::Selection& selection);
     double calc_projection(const Linef3& mouse_ray) const;
 };
 

src/slic3r/GUI/GUI.cpp

@@ -1,5 +1,6 @@
 #include "GUI.hpp"
 #include "GUI_App.hpp"
+#include "I18N.hpp"
 #include "WipeTowerDialog.hpp"
 
 #include <assert.h>
@@ -33,8 +34,8 @@
 #include "PresetBundle.hpp"
 #include "UpdateDialogs.hpp"
 
-#include "../../libslic3r/Utils.hpp"
-#include "../../libslic3r/Print.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/Print.hpp"
 
 namespace Slic3r { namespace GUI {
 
@@ -307,12 +308,6 @@ AppConfig* get_app_config()
     return wxGetApp().app_config;
 }
 
-wxString L_str(const std::string &str)
-{
-	//! Explicitly specify that the source string is already in UTF-8 encoding
-	return wxGetTranslation(wxString(str.c_str(), wxConvUTF8));
-}
-
 wxString from_u8(const std::string &str)
 {
 	return wxString::FromUTF8(str.c_str());

src/slic3r/GUI/GUI.hpp

@@ -1,16 +1,14 @@
 #ifndef slic3r_GUI_hpp_
 #define slic3r_GUI_hpp_
 
-#include "Config.hpp"
-#include "callback.hpp"
-
-#include <wx/intl.h>
+#include "libslic3r/Config.hpp"
 
 class wxWindow;
 class wxMenuBar;
 class wxNotebook;
 class wxComboCtrl;
 class wxFileDialog;
+class wxString;
 class wxTopLevelWindow;
 
 namespace Slic3r { 
@@ -19,32 +17,6 @@ class AppConfig;
 class DynamicPrintConfig;
 class Print;
 class GCodePreviewData;
-class AppControllerBase;
-
-using AppControllerPtr = std::shared_ptr<AppControllerBase>;
-
-#define _(s)    Slic3r::GUI::I18N::translate((s))
-
-namespace GUI { namespace I18N {
-	inline wxString translate(const char *s)    	 { return wxGetTranslation(wxString(s, wxConvUTF8)); }
-	inline wxString translate(const wchar_t *s) 	 { return wxGetTranslation(s); }
-	inline wxString translate(const std::string &s)  { return wxGetTranslation(wxString(s.c_str(), wxConvUTF8)); }
-	inline wxString translate(const std::wstring &s) { return wxGetTranslation(s.c_str()); }
-} }
-
-// !!! If you needed to translate some wxString,
-// !!! please use _(L(string))
-// !!! _() - is a standard wxWidgets macro to translate
-// !!! L() is used only for marking localizable string 
-// !!! It will be used in "xgettext" to create a Locating Message Catalog.
-#define L(s) s
-
-//! macro used to localization, return wxScopedCharBuffer
-//! With wxConvUTF8 explicitly specify that the source string is already in UTF-8 encoding
-#define _CHB(s) wxGetTranslation(wxString(s, wxConvUTF8)).utf8_str()
-
-// Minimal buffer length for translated string (char buf[MIN_BUF_LENGTH_FOR_L])
-#define MIN_BUF_LENGTH_FOR_L	512
 
 namespace GUI {
 
@@ -55,10 +27,6 @@ void break_to_debugger();
 
 AppConfig*		get_app_config();
 
-AppControllerPtr get_appctl();
-void             set_cli_appctl();
-void             set_gui_appctl();
-
 extern void add_menus(wxMenuBar *menu, int event_preferences_changed, int event_language_change);
 
 // Checks if configuration wizard needs to run, calls config_wizard if so.
@@ -86,16 +54,11 @@ void create_combochecklist(wxComboCtrl* comboCtrl, std::string text, std::string
 // encoded inside an int.
 int combochecklist_get_flags(wxComboCtrl* comboCtrl);
 
-// Return translated std::string as a wxString
-wxString	L_str(const std::string &str);
 // Return wxString from std::string in UTF8
 wxString	from_u8(const std::string &str);
 // Return std::string in UTF8 from wxString
 std::string	into_u8(const wxString &str);
 
-// Callback to trigger a configuration update timer on the Plater.
-static PerlCallback g_on_request_update_callback;
-
 // Returns the dimensions of the screen on which the main frame is displayed
 bool get_current_screen_size(wxWindow *window, unsigned &width, unsigned &height);
 

src/slic3r/GUI/GUI_App.cpp

@@ -1,6 +1,7 @@
 #include "GUI_App.hpp"
 #include "GUI_ObjectList.hpp"
 #include "GUI_ObjectManipulation.hpp"
+#include "I18N.hpp"
 
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
@@ -13,14 +14,17 @@
 #include <wx/menuitem.h>
 #include <wx/filedlg.h>
 #include <wx/dir.h>
+#include <wx/wupdlock.h>
+
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/I18N.hpp"
 
-#include "Utils.hpp"
 #include "GUI.hpp"
 #include "GUI_Utils.hpp"
 #include "AppConfig.hpp"
 #include "PresetBundle.hpp"
 #include "3DScene.hpp"
-#include "Model.hpp"
 
 #include "../Utils/PresetUpdater.hpp"
 #include "ConfigWizard_private.hpp"
@@ -29,8 +33,6 @@
 #include "FirmwareDialog.hpp"
 #include "Preferences.hpp"
 #include "Tab.hpp"
-#include <I18N.hpp>
-#include <wx/wupdlock.h>
 #include "SysInfoDialog.hpp"
 
 namespace Slic3r {
@@ -55,8 +57,18 @@ const wxString file_wildcards[FT_SIZE] = {
 static std::string libslic3r_translate_callback(const char *s) { return wxGetTranslation(wxString(s, wxConvUTF8)).utf8_str().data(); }
 
 IMPLEMENT_APP(GUI_App)
+
+GUI_App::GUI_App()
+    : wxApp()
+    , m_imgui(new ImGuiWrapper())
+{}
+
 bool GUI_App::OnInit()
 {
+#if ENABLE_IMGUI
+    wxCHECK_MSG(m_imgui->init(), false, "Failed to initialize ImGui");
+#endif // ENABLE_IMGUI
+
     SetAppName("Slic3rPE-alpha");
     SetAppDisplayName("Slic3r Prusa Edition");
 

src/slic3r/GUI/GUI_App.hpp

@@ -1,13 +1,18 @@
 #ifndef slic3r_GUI_App_hpp_
 #define slic3r_GUI_App_hpp_
 
+#include <memory>
 #include <string>
-#include "PrintConfig.hpp"
+#include "libslic3r/PrintConfig.hpp"
 #include "MainFrame.hpp"
+#if ENABLE_IMGUI
+#include "ImGuiWrapper.hpp"
+#endif // ENABLE_IMGUI
 
 #include <wx/app.h>
 #include <wx/colour.h>
 #include <wx/font.h>
+#include <wx/string.h>
 
 #include <mutex>
 #include <stack>
@@ -82,9 +87,14 @@ class GUI_App : public wxApp
 
     wxLocale*	    m_wxLocale{ nullptr };
 
+#if ENABLE_IMGUI
+    std::unique_ptr<ImGuiWrapper> m_imgui;
+#endif // ENABLE_IMGUI
+
 public:
     bool            OnInit() override;
-    GUI_App() : wxApp() {}
+
+    GUI_App();
 
     unsigned        get_colour_approx_luma(const wxColour &colour);
     void            init_label_colours();
@@ -151,6 +161,10 @@ public:
 
     std::vector<Tab *>      tabs_list;
 
+#if ENABLE_IMGUI
+    ImGuiWrapper* imgui() { return m_imgui.get(); }
+#endif // ENABLE_IMGUI
+
 };
 DECLARE_APP(GUI_App)
 

src/slic3r/GUI/GUI_ObjectList.cpp

@@ -1,12 +1,13 @@
 #include "GUI_ObjectList.hpp"
 #include "GUI_ObjectManipulation.hpp"
 #include "GUI_App.hpp"
+#include "I18N.hpp"
 
 #include "OptionsGroup.hpp"
 #include "PresetBundle.hpp"
 #include "Tab.hpp"
 #include "wxExtensions.hpp"
-#include "Model.hpp"
+#include "libslic3r/Model.hpp"
 #include "LambdaObjectDialog.hpp"
 #include "GLCanvas3D.hpp"
 

src/slic3r/GUI/GUI_ObjectManipulation.cpp

@@ -1,11 +1,12 @@
 #include "GUI_ObjectManipulation.hpp"
 #include "GUI_ObjectList.hpp"
+#include "I18N.hpp"
 
 #include "OptionsGroup.hpp"
 #include "wxExtensions.hpp"
 #include "PresetBundle.hpp"
-#include "Model.hpp"
-#include "Geometry.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/Geometry.hpp"
 
 #include <boost/algorithm/string.hpp>
 

src/slic3r/GUI/GUI_ObjectSettings.cpp

@@ -4,10 +4,12 @@
 #include "OptionsGroup.hpp"
 #include "wxExtensions.hpp"
 #include "PresetBundle.hpp"
-#include "Model.hpp"
+#include "libslic3r/Model.hpp"
 
 #include <boost/algorithm/string.hpp>
 
+#include "I18N.hpp"
+
 namespace Slic3r
 {
 namespace GUI

src/slic3r/GUI/GUI_Preview.cpp

@@ -3,6 +3,7 @@
 #include "GUI_Preview.hpp"
 #include "GUI_App.hpp"
 #include "GUI.hpp"
+#include "I18N.hpp"
 #include "AppConfig.hpp"
 #include "3DScene.hpp"
 #include "BackgroundSlicingProcess.hpp"
@@ -20,7 +21,7 @@
 #include <wx/checkbox.h>
 
 // this include must follow the wxWidgets ones or it won't compile on Windows -> see http://trac.wxwidgets.org/ticket/2421
-#include "../../libslic3r/Print.hpp"
+#include "libslic3r/Print.hpp"
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/I18N.cpp

@@ -0,0 +1,11 @@
+#include "I18N.hpp"
+
+namespace Slic3r { namespace GUI { 
+
+wxString L_str(const std::string &str)
+{
+	//! Explicitly specify that the source string is already in UTF-8 encoding
+	return wxGetTranslation(wxString(str.c_str(), wxConvUTF8));
+}
+
+} }

src/slic3r/GUI/I18N.hpp

@@ -0,0 +1,39 @@
+#ifndef _
+#define _(s)    Slic3r::GUI::I18N::translate((s))
+#endif /* _ */
+
+#ifndef L
+// !!! If you needed to translate some wxString,
+// !!! please use _(L(string))
+// !!! _() - is a standard wxWidgets macro to translate
+// !!! L() is used only for marking localizable string 
+// !!! It will be used in "xgettext" to create a Locating Message Catalog.
+#define L(s) s
+#endif /* L */
+
+#ifndef _CHB
+//! macro used to localization, return wxScopedCharBuffer
+//! With wxConvUTF8 explicitly specify that the source string is already in UTF-8 encoding
+#define _CHB(s) wxGetTranslation(wxString(s, wxConvUTF8)).utf8_str()
+#endif /* _CHB */
+
+#ifndef slic3r_GUI_I18N_hpp_
+#define slic3r_GUI_I18N_hpp_
+
+#include <wx/intl.h>
+
+namespace Slic3r { namespace GUI { 
+
+namespace I18N {
+	inline wxString translate(const char *s)    	 { return wxGetTranslation(wxString(s, wxConvUTF8)); }
+	inline wxString translate(const wchar_t *s) 	 { return wxGetTranslation(s); }
+	inline wxString translate(const std::string &s)  { return wxGetTranslation(wxString(s.c_str(), wxConvUTF8)); }
+	inline wxString translate(const std::wstring &s) { return wxGetTranslation(s.c_str()); }
+} 
+
+// Return translated std::string as a wxString
+wxString	L_str(const std::string &str);
+
+} }
+
+#endif /* slic3r_GUI_I18N_hpp_ */

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -0,0 +1,622 @@
+#include "ImGuiWrapper.hpp"
+
+#include <vector>
+
+#include <boost/format.hpp>
+#include <boost/log/trivial.hpp>
+
+#include <wx/string.h>
+#include <wx/event.h>
+#include <wx/debug.h>
+
+#include <GL/glew.h>
+
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Utils.hpp"
+#include "GUI.hpp"
+
+namespace Slic3r {
+namespace GUI {
+
+
+ImGuiWrapper::ImGuiWrapper()
+    : m_glsl_version_string("")
+    , m_shader_handle(0)
+    , m_vert_handle(0)
+    , m_frag_handle(0)
+    , m_font_texture(0)
+    , m_vbo_handle(0)
+    , m_elements_handle(0)
+    , m_attrib_location_tex(0)
+    , m_attrib_location_proj_mtx(0)
+    , m_attrib_location_position(0)
+    , m_attrib_location_uv(0)
+    , m_attrib_location_color(0)
+    , m_mouse_buttons(0)
+{
+}
+
+ImGuiWrapper::~ImGuiWrapper()
+{
+    destroy_device_objects();
+    ImGui::DestroyContext();
+}
+
+bool ImGuiWrapper::init()
+{
+    // Store GLSL version string so we can refer to it later in case we recreate shaders. Note: GLSL version is NOT the same as GL version. Leave this to NULL if unsure.
+    std::string glsl_version;
+
+#ifdef USE_GL_ES3
+    glsl_version = "#version 300 es";
+#else
+    glsl_version = "#version 130";
+#endif
+
+    m_glsl_version_string = glsl_version + "\n";
+
+    ImGui::CreateContext();
+
+    ImGuiIO& io = ImGui::GetIO();
+    ImFont* font = io.Fonts->AddFontFromFileTTF((Slic3r::resources_dir() + "/fonts/NotoSans-Regular.ttf").c_str(), 18.0f);
+    if (font == nullptr) {
+        font = io.Fonts->AddFontDefault();
+        if (font == nullptr)
+            return false;
+    }
+    else {
+        m_fonts.insert(FontsMap::value_type("Noto Sans Regular 18", font));
+    }
+
+    io.IniFilename = nullptr;
+
+    return true;
+}
+
+void ImGuiWrapper::set_display_size(float w, float h)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    io.DisplaySize = ImVec2(w, h);
+    io.DisplayFramebufferScale = ImVec2(1.0f, 1.0f);
+}
+
+bool ImGuiWrapper::update_mouse_data(wxMouseEvent& evt)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    io.MousePos = ImVec2((float)evt.GetX(), (float)evt.GetY());
+    io.MouseDown[0] = evt.LeftDown();
+    io.MouseDown[1] = evt.RightDown();
+    io.MouseDown[2] = evt.MiddleDown();
+
+    unsigned buttons = (evt.LeftDown() ? 1 : 0) | (evt.RightDown() ? 2 : 0) | (evt.MiddleDown() ? 4 : 0);
+    bool res = buttons != m_mouse_buttons;
+    m_mouse_buttons = buttons;
+    return res;
+}
+
+void ImGuiWrapper::new_frame()
+{
+    if (m_font_texture == 0)
+        create_device_objects();
+
+    ImGui::NewFrame();
+}
+
+void ImGuiWrapper::render()
+{
+    ImGui::Render();
+    render_draw_data(ImGui::GetDrawData());
+}
+
+void ImGuiWrapper::set_next_window_pos(float x, float y, int flag)
+{
+    ImGui::SetNextWindowPos(ImVec2(x, y), (ImGuiCond)flag);
+}
+
+void ImGuiWrapper::set_next_window_bg_alpha(float alpha)
+{
+    ImGui::SetNextWindowBgAlpha(alpha);
+}
+
+bool ImGuiWrapper::begin(const std::string &name, int flags)
+{
+    return ImGui::Begin(name.c_str(), nullptr, (ImGuiWindowFlags)flags);
+}
+
+bool ImGuiWrapper::begin(const wxString &name, int flags)
+{
+    return begin(into_u8(name), flags);
+}
+
+void ImGuiWrapper::end()
+{
+    ImGui::End();
+}
+
+bool ImGuiWrapper::button(const wxString &label)
+{
+    auto label_utf8 = into_u8(label);
+    return ImGui::Button(label_utf8.c_str());
+}
+
+bool ImGuiWrapper::input_double(const std::string &label, const double &value, const std::string &format)
+{
+    return ImGui::InputDouble(label.c_str(), const_cast<double*>(&value), 0.0f, 0.0f, format.c_str());
+}
+
+bool ImGuiWrapper::input_vec3(const std::string &label, const Vec3d &value, float width, const std::string &format)
+{
+    bool value_changed = false;
+
+    ImGui::BeginGroup();
+
+    for (int i = 0; i < 3; ++i)
+    {
+        std::string item_label = (i == 0) ? "X" : ((i == 1) ? "Y" : "Z");
+        ImGui::PushID(i);
+        ImGui::PushItemWidth(width);
+        value_changed |= ImGui::InputDouble(item_label.c_str(), const_cast<double*>(&value(i)), 0.0f, 0.0f, format.c_str());
+        ImGui::PopID();
+    }
+    ImGui::EndGroup();
+
+    return value_changed;
+}
+
+bool ImGuiWrapper::checkbox(const wxString &label, bool &value)
+{
+    auto label_utf8 = into_u8(label);
+    return ImGui::Checkbox(label_utf8.c_str(), &value);
+}
+
+bool ImGuiWrapper::want_mouse() const
+{
+    return ImGui::GetIO().WantCaptureMouse;
+}
+
+bool ImGuiWrapper::want_keyboard() const
+{
+    return ImGui::GetIO().WantCaptureKeyboard;
+}
+
+bool ImGuiWrapper::want_text_input() const
+{
+    return ImGui::GetIO().WantTextInput;
+}
+
+bool ImGuiWrapper::want_any_input() const
+{
+    const auto io = ImGui::GetIO();
+    return io.WantCaptureMouse || io.WantCaptureKeyboard || io.WantTextInput;
+}
+
+void ImGuiWrapper::create_device_objects()
+{
+    // Backup GL state
+    GLint last_texture, last_array_buffer, last_vertex_array;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
+    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
+
+    // Parse GLSL version string
+    int glsl_version = 130;
+    ::sscanf(m_glsl_version_string.c_str(), "#version %d", &glsl_version);
+
+    const GLchar* vertex_shader_glsl_120 =
+        "uniform mat4 ProjMtx;\n"
+        "attribute vec2 Position;\n"
+        "attribute vec2 UV;\n"
+        "attribute vec4 Color;\n"
+        "varying vec2 Frag_UV;\n"
+        "varying vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
+
+    const GLchar* vertex_shader_glsl_130 =
+        "uniform mat4 ProjMtx;\n"
+        "in vec2 Position;\n"
+        "in vec2 UV;\n"
+        "in vec4 Color;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
+
+    const GLchar* vertex_shader_glsl_300_es =
+        "precision mediump float;\n"
+        "layout (location = 0) in vec2 Position;\n"
+        "layout (location = 1) in vec2 UV;\n"
+        "layout (location = 2) in vec4 Color;\n"
+        "uniform mat4 ProjMtx;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
+
+    const GLchar* vertex_shader_glsl_410_core =
+        "layout (location = 0) in vec2 Position;\n"
+        "layout (location = 1) in vec2 UV;\n"
+        "layout (location = 2) in vec4 Color;\n"
+        "uniform mat4 ProjMtx;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
+
+    const GLchar* fragment_shader_glsl_120 =
+        "#ifdef GL_ES\n"
+        "    precision mediump float;\n"
+        "#endif\n"
+        "uniform sampler2D Texture;\n"
+        "varying vec2 Frag_UV;\n"
+        "varying vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);\n"
+        "}\n";
+
+    const GLchar* fragment_shader_glsl_130 =
+        "uniform sampler2D Texture;\n"
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+        "}\n";
+
+    const GLchar* fragment_shader_glsl_300_es =
+        "precision mediump float;\n"
+        "uniform sampler2D Texture;\n"
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "layout (location = 0) out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+        "}\n";
+
+    const GLchar* fragment_shader_glsl_410_core =
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "uniform sampler2D Texture;\n"
+        "layout (location = 0) out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+        "}\n";
+
+    // Select shaders matching our GLSL versions
+    const GLchar* vertex_shader = nullptr;
+    const GLchar* fragment_shader = nullptr;
+    if (glsl_version < 130)
+    {
+        vertex_shader = vertex_shader_glsl_120;
+        fragment_shader = fragment_shader_glsl_120;
+    }
+    else if (glsl_version == 410)
+    {
+        vertex_shader = vertex_shader_glsl_410_core;
+        fragment_shader = fragment_shader_glsl_410_core;
+    }
+    else if (glsl_version == 300)
+    {
+        vertex_shader = vertex_shader_glsl_300_es;
+        fragment_shader = fragment_shader_glsl_300_es;
+    }
+    else
+    {
+        vertex_shader = vertex_shader_glsl_130;
+        fragment_shader = fragment_shader_glsl_130;
+    }
+
+    // Create shaders
+    const GLchar* vertex_shader_with_version[2] = { m_glsl_version_string.c_str(), vertex_shader };
+    m_vert_handle = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(m_vert_handle, 2, vertex_shader_with_version, nullptr);
+    glCompileShader(m_vert_handle);
+    wxASSERT(check_shader(m_vert_handle, "vertex shader"));
+
+    const GLchar* fragment_shader_with_version[2] = { m_glsl_version_string.c_str(), fragment_shader };
+    m_frag_handle = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(m_frag_handle, 2, fragment_shader_with_version, nullptr);
+    glCompileShader(m_frag_handle);
+    wxASSERT(check_shader(m_frag_handle, "fragment shader"));
+
+    m_shader_handle = glCreateProgram();
+    glAttachShader(m_shader_handle, m_vert_handle);
+    glAttachShader(m_shader_handle, m_frag_handle);
+    glLinkProgram(m_shader_handle);
+    wxASSERT(check_program(m_shader_handle, "shader program"));
+
+    m_attrib_location_tex = glGetUniformLocation(m_shader_handle, "Texture");
+    m_attrib_location_proj_mtx = glGetUniformLocation(m_shader_handle, "ProjMtx");
+    m_attrib_location_position = glGetAttribLocation(m_shader_handle, "Position");
+    m_attrib_location_uv = glGetAttribLocation(m_shader_handle, "UV");
+    m_attrib_location_color = glGetAttribLocation(m_shader_handle, "Color");
+
+    // Create buffers
+    glGenBuffers(1, &m_vbo_handle);
+    glGenBuffers(1, &m_elements_handle);
+
+    create_fonts_texture();
+
+    // Restore modified GL state
+    glBindTexture(GL_TEXTURE_2D, last_texture);
+    glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
+    glBindVertexArray(last_vertex_array);
+}
+
+void ImGuiWrapper::create_fonts_texture()
+{
+    // Build texture atlas
+    ImGuiIO& io = ImGui::GetIO();
+    unsigned char* pixels;
+    int width, height;
+    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);   // Load as RGBA 32-bits (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
+
+    // Upload texture to graphics system
+    GLint last_texture;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
+    glGenTextures(1, &m_font_texture);
+    glBindTexture(GL_TEXTURE_2D, m_font_texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+
+    // Store our identifier
+    io.Fonts->TexID = (ImTextureID)(intptr_t)m_font_texture;
+
+    // Restore state
+    glBindTexture(GL_TEXTURE_2D, last_texture);
+}
+
+bool ImGuiWrapper::check_program(unsigned int handle, const char* desc)
+{
+    GLint status = 0, log_length = 0;
+    glGetProgramiv(handle, GL_LINK_STATUS, &status);
+    glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &log_length);
+
+    if (status == GL_FALSE) {
+        BOOST_LOG_TRIVIAL(error) << boost::format("ImGuiWrapper::check_program(): failed to link %1% (GLSL `%1%`)") % desc, m_glsl_version_string;
+    }
+
+    if (log_length > 0) {
+        std::vector<GLchar> buf(log_length + 1, 0);
+        glGetProgramInfoLog(handle, log_length, nullptr, buf.data());
+        BOOST_LOG_TRIVIAL(error) << boost::format("ImGuiWrapper::check_program(): error log:\n%1%\n") % buf.data();
+    }
+
+    return status == GL_TRUE;
+}
+
+bool ImGuiWrapper::check_shader(unsigned int handle, const char *desc)
+{
+    GLint status = 0, log_length = 0;
+    glGetShaderiv(handle, GL_COMPILE_STATUS, &status);
+    glGetShaderiv(handle, GL_INFO_LOG_LENGTH, &log_length);
+
+    if (status == GL_FALSE) {
+        BOOST_LOG_TRIVIAL(error) << boost::format("ImGuiWrapper::check_shader(): failed to compile %1%") % desc;
+    }
+
+    if (log_length > 0) {
+        std::vector<GLchar> buf(log_length + 1, 0);
+        glGetProgramInfoLog(handle, log_length, nullptr, buf.data());
+        BOOST_LOG_TRIVIAL(error) << boost::format("ImGuiWrapper::check_program(): error log:\n%1%\n") % buf.data();
+    }
+
+    return status == GL_TRUE;
+}
+
+void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
+{
+    // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
+    ImGuiIO& io = ImGui::GetIO();
+    int fb_width = (int)(draw_data->DisplaySize.x * io.DisplayFramebufferScale.x);
+    int fb_height = (int)(draw_data->DisplaySize.y * io.DisplayFramebufferScale.y);
+    if (fb_width <= 0 || fb_height <= 0)
+        return;
+    draw_data->ScaleClipRects(io.DisplayFramebufferScale);
+
+    // Backup GL state
+    GLenum last_active_texture; glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&last_active_texture);
+    glActiveTexture(GL_TEXTURE0);
+    GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
+    GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
+#ifdef GL_SAMPLER_BINDING
+    GLint last_sampler; glGetIntegerv(GL_SAMPLER_BINDING, &last_sampler);
+#endif
+    GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
+    GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
+#ifdef GL_POLYGON_MODE
+    GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode);
+#endif
+    GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
+    GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
+    GLenum last_blend_src_rgb; glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&last_blend_src_rgb);
+    GLenum last_blend_dst_rgb; glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&last_blend_dst_rgb);
+    GLenum last_blend_src_alpha; glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&last_blend_src_alpha);
+    GLenum last_blend_dst_alpha; glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&last_blend_dst_alpha);
+    GLenum last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&last_blend_equation_rgb);
+    GLenum last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&last_blend_equation_alpha);
+    GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
+    GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
+    GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
+    GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
+
+    // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill
+    glEnable(GL_BLEND);
+    glBlendEquation(GL_FUNC_ADD);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_SCISSOR_TEST);
+#ifdef GL_POLYGON_MODE
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+#endif
+
+    // Setup viewport, orthographic projection matrix
+    // Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayMin is typically (0,0) for single viewport apps.
+    glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
+    float L = draw_data->DisplayPos.x;
+    float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
+    float T = draw_data->DisplayPos.y;
+    float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
+    const float ortho_projection[4][4] =
+    {
+        { 2.0f / (R - L), 0.0f, 0.0f, 0.0f },
+        { 0.0f, 2.0f / (T - B), 0.0f, 0.0f },
+        { 0.0f, 0.0f, -1.0f, 0.0f },
+        { (R + L) / (L - R), (T + B) / (B - T), 0.0f, 1.0f },
+    };
+    glUseProgram(m_shader_handle);
+    glUniform1i(m_attrib_location_tex, 0);
+    glUniformMatrix4fv(m_attrib_location_proj_mtx, 1, GL_FALSE, &ortho_projection[0][0]);
+#ifdef GL_SAMPLER_BINDING
+    glBindSampler(0, 0); // We use combined texture/sampler state. Applications using GL 3.3 may set that otherwise.
+#endif
+    // Recreate the VAO every time
+    // (This is to easily allow multiple GL contexts. VAO are not shared among GL contexts, and we don't track creation/deletion of windows so we don't have an obvious key to use to cache them.)
+    GLuint vao_handle = 0;
+    glGenVertexArrays(1, &vao_handle);
+    glBindVertexArray(vao_handle);
+    glBindBuffer(GL_ARRAY_BUFFER, m_vbo_handle);
+    glEnableVertexAttribArray(m_attrib_location_position);
+    glEnableVertexAttribArray(m_attrib_location_uv);
+    glEnableVertexAttribArray(m_attrib_location_color);
+    glVertexAttribPointer(m_attrib_location_position, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, pos));
+    glVertexAttribPointer(m_attrib_location_uv, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, uv));
+    glVertexAttribPointer(m_attrib_location_color, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, col));
+
+    // Draw
+    ImVec2 pos = draw_data->DisplayPos;
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
+    {
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        const ImDrawIdx* idx_buffer_offset = 0;
+
+        glBindBuffer(GL_ARRAY_BUFFER, m_vbo_handle);
+        glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.Size * sizeof(ImDrawVert), (const GLvoid*)cmd_list->VtxBuffer.Data, GL_STREAM_DRAW);
+
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elements_handle);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx), (const GLvoid*)cmd_list->IdxBuffer.Data, GL_STREAM_DRAW);
+
+        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
+        {
+            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback)
+            {
+                // User callback (registered via ImDrawList::AddCallback)
+                pcmd->UserCallback(cmd_list, pcmd);
+            }
+            else
+            {
+                ImVec4 clip_rect = ImVec4(pcmd->ClipRect.x - pos.x, pcmd->ClipRect.y - pos.y, pcmd->ClipRect.z - pos.x, pcmd->ClipRect.w - pos.y);
+                if (clip_rect.x < fb_width && clip_rect.y < fb_height && clip_rect.z >= 0.0f && clip_rect.w >= 0.0f)
+                {
+                    // Apply scissor/clipping rectangle
+                    glScissor((int)clip_rect.x, (int)(fb_height - clip_rect.w), (int)(clip_rect.z - clip_rect.x), (int)(clip_rect.w - clip_rect.y));
+
+                    // Bind texture, Draw
+                    glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
+                    glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
+                }
+            }
+            idx_buffer_offset += pcmd->ElemCount;
+        }
+    }
+    glDeleteVertexArrays(1, &vao_handle);
+
+    // Restore modified GL state
+    glUseProgram(last_program);
+    glBindTexture(GL_TEXTURE_2D, last_texture);
+#ifdef GL_SAMPLER_BINDING
+    glBindSampler(0, last_sampler);
+#endif
+    glActiveTexture(last_active_texture);
+    glBindVertexArray(last_vertex_array);
+    glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
+    glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
+    glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha);
+    if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
+    if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
+    if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
+    if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
+#ifdef GL_POLYGON_MODE
+    glPolygonMode(GL_FRONT_AND_BACK, (GLenum)last_polygon_mode[0]);
+#endif
+    glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
+    glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
+}
+
+void ImGuiWrapper::destroy_device_objects()
+{
+    if (m_vbo_handle != 0)
+    {
+        glDeleteBuffers(1, &m_vbo_handle);
+        m_vbo_handle = 0;
+    }
+    if (m_elements_handle != 0)
+    {
+        glDeleteBuffers(1, &m_elements_handle);
+        m_elements_handle = 0;
+    }
+
+    if ((m_shader_handle != 0) && (m_vert_handle != 0))
+        glDetachShader(m_shader_handle, m_vert_handle);
+
+    if (m_vert_handle != 0)
+    {
+        glDeleteShader(m_vert_handle);
+        m_vert_handle = 0;
+    }
+    if ((m_shader_handle != 0) && (m_frag_handle != 0))
+        glDetachShader(m_shader_handle, m_frag_handle);
+
+    if (m_frag_handle != 0)
+    {
+        glDeleteShader(m_frag_handle);
+        m_frag_handle = 0;
+    }
+
+    if (m_shader_handle != 0)
+    {
+        glDeleteProgram(m_shader_handle);
+        m_shader_handle = 0;
+    }
+
+    destroy_fonts_texture();
+}
+
+void ImGuiWrapper::destroy_fonts_texture()
+{
+    if (m_font_texture)
+    {
+        ImGuiIO& io = ImGui::GetIO();
+        io.Fonts->TexID = 0;
+        glDeleteTextures(1, &m_font_texture);
+        m_font_texture = 0;
+    }
+}
+
+} // namespace GUI
+} // namespace Slic3r
+

src/slic3r/GUI/ImGuiWrapper.hpp

@@ -0,0 +1,81 @@
+#ifndef slic3r_ImGuiWrapper_hpp_
+#define slic3r_ImGuiWrapper_hpp_
+
+#include <string>
+#include <map>
+
+#include <imgui/imgui.h>
+
+#include "libslic3r/Point.hpp"
+
+class wxString;
+class wxMouseEvent;
+
+
+namespace Slic3r {
+namespace GUI {
+
+class ImGuiWrapper
+{
+    std::string m_glsl_version_string;
+    unsigned int m_shader_handle;
+    unsigned int m_vert_handle;
+    unsigned int m_frag_handle;
+    unsigned int m_vbo_handle;
+    unsigned int m_elements_handle;
+    int m_attrib_location_tex;
+    int m_attrib_location_proj_mtx;
+    int m_attrib_location_position;
+    int m_attrib_location_uv;
+    int m_attrib_location_color;
+
+    typedef std::map<std::string, ImFont*> FontsMap;
+
+    FontsMap m_fonts;
+    unsigned int m_font_texture;
+
+    unsigned m_mouse_buttons;
+
+public:
+    ImGuiWrapper();
+    ~ImGuiWrapper();
+
+    bool init();
+
+    void set_display_size(float w, float h);
+    bool update_mouse_data(wxMouseEvent &evt);
+
+    void new_frame();
+    void render();
+
+    void set_next_window_pos(float x, float y, int flag);
+    void set_next_window_bg_alpha(float alpha);
+
+    bool begin(const std::string &name, int flags = 0);
+    bool begin(const wxString &name, int flags = 0);
+    void end();
+
+    bool button(const wxString &label);
+    bool input_double(const std::string &label, const double &value, const std::string &format = "%.3f");
+    bool input_vec3(const std::string &label, const Vec3d &value, float width, const std::string &format = "%.3f");
+    bool checkbox(const wxString &label, bool &value);
+
+    bool want_mouse() const;
+    bool want_keyboard() const;
+    bool want_text_input() const;
+    bool want_any_input() const;
+private:
+    void create_device_objects();
+    void create_fonts_texture();
+    bool check_program(unsigned int handle, const char *desc);
+    bool check_shader(unsigned int handle, const char *desc);
+    void render_draw_data(ImDrawData *draw_data);
+    void destroy_device_objects();
+    void destroy_fonts_texture();
+};
+
+} // namespace GUI
+} // namespace Slic3r
+
+#endif // slic3r_ImGuiWrapper_hpp_
+

src/slic3r/GUI/LambdaObjectDialog.cpp

@@ -3,6 +3,7 @@
 #include <wx/window.h>
 #include <wx/button.h>
 #include "OptionsGroup.hpp"
+#include "I18N.hpp"
 
 namespace Slic3r
 {

src/slic3r/GUI/MainFrame.cpp

@@ -10,14 +10,16 @@
 #include <wx/glcanvas.h>
 #include <wx/debug.h>
 
+#include "libslic3r/Print.hpp"
+#include "libslic3r/Polygon.hpp"
+
 #include "Tab.hpp"
 #include "PresetBundle.hpp"
 #include "ProgressStatusBar.hpp"
 #include "3DScene.hpp"
-#include "Print.hpp"
-#include "Polygon.hpp"
 #include "AppConfig.hpp"
 #include "wxExtensions.hpp"
+#include "I18N.hpp"
 
 #include <fstream>
 #include "GUI_App.hpp"

src/slic3r/GUI/MainFrame.hpp

@@ -1,9 +1,10 @@
 #ifndef slic3r_MainFrame_hpp_
 #define slic3r_MainFrame_hpp_
 
-#include "PrintConfig.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 #include <wx/frame.h>
+#include <wx/string.h>
 
 #include <string>
 #include <map>

src/slic3r/GUI/MsgDialog.cpp

@@ -10,6 +10,7 @@
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Utils.hpp"
 #include "GUI.hpp"
+#include "I18N.hpp"
 #include "ConfigWizard.hpp"
 
 namespace Slic3r {

src/slic3r/GUI/OptionsGroup.cpp

@@ -5,7 +5,8 @@
 #include <wx/numformatter.h>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
-#include "Utils.hpp"
+#include "libslic3r/Utils.hpp"
+#include "I18N.hpp"
 
 namespace Slic3r { namespace GUI {
 

src/slic3r/GUI/Plater.cpp

@@ -24,17 +24,19 @@
 #include <wx/debug.h>
 
 #include "libslic3r/libslic3r.h"
-#include "libslic3r/PrintConfig.hpp"
-#include "libslic3r/Model.hpp"
-#include "libslic3r/ModelArrange.hpp"
-#include "libslic3r/Print.hpp"
-#include "libslic3r/SLAPrint.hpp"
-#include "libslic3r/GCode/PreviewData.hpp"
-#include "libslic3r/Utils.hpp"
-#include "libslic3r/Polygon.hpp"
 #include "libslic3r/Format/STL.hpp"
 #include "libslic3r/Format/AMF.hpp"
 #include "libslic3r/Format/3mf.hpp"
+#include "libslic3r/GCode/PreviewData.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/ModelArrange.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Print.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/SLAPrint.hpp"
+#include "libslic3r/SLA/SLARotfinder.hpp"
+#include "libslic3r/Utils.hpp"
+
 #include "GUI.hpp"
 #include "GUI_App.hpp"
 #include "GUI_ObjectList.hpp"
@@ -50,9 +52,8 @@
 #include "PresetBundle.hpp"
 #include "BackgroundSlicingProcess.hpp"
 #include "ProgressStatusBar.hpp"
-#include "slic3r/Utils/ASCIIFolding.hpp"
+#include "../Utils/ASCIIFolding.hpp"
 #include "../Utils/FixModelByWin10.hpp"
-#include "SLA/SLARotfinder.hpp"
 
 #include <wx/glcanvas.h>    // Needs to be last because reasons :-/
 #include "WipeTowerDialog.hpp"
@@ -66,9 +67,10 @@ using Slic3r::Preset;
 namespace Slic3r {
 namespace GUI {
 
-wxDEFINE_EVENT(EVT_SLICING_UPDATE,    SlicingStatusEvent);
-wxDEFINE_EVENT(EVT_SLICING_COMPLETED, wxCommandEvent);
-wxDEFINE_EVENT(EVT_PROCESS_COMPLETED, wxCommandEvent);
+wxDEFINE_EVENT(EVT_SCHEDULE_BACKGROUND_PROCESS,     SimpleEvent);
+wxDEFINE_EVENT(EVT_SLICING_UPDATE,                  SlicingStatusEvent);
+wxDEFINE_EVENT(EVT_SLICING_COMPLETED,               wxCommandEvent);
+wxDEFINE_EVENT(EVT_PROCESS_COMPLETED,               wxCommandEvent);
 
 // Sidebar widgets
 
@@ -392,7 +394,7 @@ FreqChangedParams::FreqChangedParams(wxWindow* parent, const int label_width) :
                 std::vector<float> extruders = dlg.get_extruders();
                 (config.option<ConfigOptionFloats>("wiping_volumes_matrix"))->values = std::vector<double>(matrix.begin(), matrix.end());
                 (config.option<ConfigOptionFloats>("wiping_volumes_extruders"))->values = std::vector<double>(extruders.begin(), extruders.end());
-                g_on_request_update_callback.call();
+				wxPostEvent(parent, SimpleEvent(EVT_SCHEDULE_BACKGROUND_PROCESS, parent));
             }
         }));
         return sizer;
@@ -913,7 +915,9 @@ struct Plater::priv
     // GUI elements
     wxNotebook *notebook;
     Sidebar *sidebar;
+#ifndef ENABLE_IMGUI
     wxPanel *panel3d;
+#endif // not ENABLE_IMGUI
     wxGLCanvas *canvas3Dwidget;    // TODO: Use GLCanvas3D when we can
     GLCanvas3D *canvas3D;
     Preview *preview;
@@ -1039,8 +1043,12 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
         }))
     , notebook(new wxNotebook(q, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNB_BOTTOM))
     , sidebar(new Sidebar(q))
+#ifdef ENABLE_IMGUI
+    , canvas3Dwidget(GLCanvas3DManager::create_wxglcanvas(notebook))
+#else
     , panel3d(new wxPanel(notebook, wxID_ANY))
     , canvas3Dwidget(GLCanvas3DManager::create_wxglcanvas(panel3d))
+#endif // ENABLE_IMGUI
     , canvas3D(nullptr)
     , delayed_scene_refresh(false)
 #if ENABLE_NEW_MENU_LAYOUT
@@ -1068,6 +1076,9 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
     this->canvas3D = _3DScene::get_canvas(this->canvas3Dwidget);
     this->canvas3D->allow_multisample(GLCanvas3DManager::can_multisample());
 
+#ifdef ENABLE_IMGUI
+    notebook->AddPage(canvas3Dwidget, _(L("3D")));
+#else
     auto *panel3dsizer = new wxBoxSizer(wxVERTICAL);
     panel3dsizer->Add(canvas3Dwidget, 1, wxEXPAND);
     auto *panel_gizmo_widgets = new wxPanel(panel3d, wxID_ANY);
@@ -1076,9 +1087,11 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
 
     panel3d->SetSizer(panel3dsizer);
     notebook->AddPage(panel3d, _(L("3D")));
-	preview = new GUI::Preview(notebook, config, &background_process, &gcode_preview_data, [this](){ schedule_background_process(); });
 
     canvas3D->set_external_gizmo_widgets_parent(panel_gizmo_widgets);
+#endif // ENABLE_IMGUI
+
+    preview = new GUI::Preview(notebook, config, &background_process, &gcode_preview_data, [this](){ schedule_background_process(); });
 
     // XXX: If have OpenGL
     this->canvas3D->enable_picking(true);
@@ -1118,6 +1131,7 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
     sidebar->Bind(wxEVT_COMBOBOX, &priv::on_select_preset, this);
 
     sidebar->Bind(EVT_OBJ_LIST_OBJECT_SELECT, [this](wxEvent&) { priv::selection_changed(); });
+    sidebar->Bind(EVT_SCHEDULE_BACKGROUND_PROCESS, &priv::on_schedule_background_process, this);
 
     // 3DScene events:
     canvas3Dwidget->Bind(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS, &priv::on_schedule_background_process, this);
@@ -1921,7 +1935,11 @@ void Plater::priv::fix_through_netfabb(const int obj_idx)
 void Plater::priv::on_notebook_changed(wxBookCtrlEvent&)
 {
     const auto current_id = notebook->GetCurrentPage()->GetId();
+#ifdef ENABLE_IMGUI
+    if (current_id == canvas3Dwidget->GetId()) {
+#else
     if (current_id == panel3d->GetId()) {
+#endif // ENABLE_IMGUI
         if (this->canvas3D->is_reload_delayed()) {
             // Delayed loading of the 3D scene.
             if (this->printer_technology == ptSLA) {
@@ -1989,7 +2007,7 @@ void Plater::priv::on_slicing_update(SlicingStatusEvent &evt)
                 this->preview->reload_print();
             break;
         case ptSLA:
-            if (this->canvas3D->is_gizmo_dragging())
+            if (this->canvas3D->is_dragging())
                 delayed_scene_refresh = true;
             else
                 this->update_sla_scene();
@@ -2010,7 +2028,7 @@ void Plater::priv::on_slicing_completed(wxCommandEvent &)
     //    this->canvas3D->reload_scene(true);
         break;
     case ptSLA:
-        if (this->canvas3D->is_gizmo_dragging())
+        if (this->canvas3D->is_dragging())
             delayed_scene_refresh = true;
         else
             this->update_sla_scene();
@@ -2052,7 +2070,7 @@ void Plater::priv::on_process_completed(wxCommandEvent &evt)
             this->preview->reload_print();
         break;
     case ptSLA:
-        if (this->canvas3D->is_gizmo_dragging())
+        if (this->canvas3D->is_dragging())
             delayed_scene_refresh = true;
         else
             this->update_sla_scene();
@@ -2454,14 +2472,14 @@ bool Plater::is_selection_empty() const
     return p->get_selection().is_empty();
 }
 
-void Plater::cut(size_t obj_idx, size_t instance_idx, coordf_t z)
+void Plater::cut(size_t obj_idx, size_t instance_idx, coordf_t z, bool keep_upper, bool keep_lower, bool rotate_lower)
 {
     wxCHECK_RET(obj_idx < p->model.objects.size(), "obj_idx out of bounds");
     auto *object = p->model.objects[obj_idx];
 
     wxCHECK_RET(instance_idx < object->instances.size(), "instance_idx out of bounds");
 
-    const auto new_objects = object->cut(instance_idx, z);
+    const auto new_objects = object->cut(instance_idx, z, keep_upper, keep_lower, rotate_lower);
 
     remove(obj_idx);
     p->load_model_objects(new_objects);

src/slic3r/GUI/Plater.hpp

@@ -14,6 +14,7 @@ class wxButton;
 class wxBoxSizer;
 class wxGLCanvas;
 class wxScrolledWindow;
+class wxString;
 
 namespace Slic3r {
 
@@ -139,7 +140,7 @@ public:
     void set_number_of_copies(/*size_t num*/);
     bool is_selection_empty() const;
 
-    void cut(size_t obj_idx, size_t instance_idx, coordf_t z);
+    void cut(size_t obj_idx, size_t instance_idx, coordf_t z, bool keep_upper = true, bool keep_lower = true, bool rotate_lower = false);
 
     // Note: empty path means "use the default"
     void export_gcode(boost::filesystem::path output_path = boost::filesystem::path());

src/slic3r/GUI/Preferences.cpp

@@ -1,6 +1,7 @@
 #include "Preferences.hpp"
 #include "AppConfig.hpp"
 #include "OptionsGroup.hpp"
+#include "I18N.hpp"
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/Preset.cpp

@@ -1,9 +1,9 @@
-//#undef NDEBUG
 #include <cassert>
 
 #include "Preset.hpp"
 #include "AppConfig.hpp"
 #include "BitmapCache.hpp"
+#include "I18N.hpp"
 
 #include <fstream>
 #include <stdexcept>
@@ -25,9 +25,9 @@
 #include <wx/bmpcbox.h>
 #include <wx/wupdlock.h>
 
-#include "../../libslic3r/libslic3r.h"
-#include "../../libslic3r/Utils.hpp"
-#include "../../libslic3r/PlaceholderParser.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/PlaceholderParser.hpp"
 #include "Plater.hpp"
 
 using boost::property_tree::ptree;

src/slic3r/GUI/PresetBundle.cpp

@@ -1,9 +1,9 @@
-//#undef NDEBUG
 #include <cassert>
 
 #include "PresetBundle.hpp"
 #include "BitmapCache.hpp"
 #include "Plater.hpp"
+#include "I18N.hpp"
 
 #include <algorithm>
 #include <fstream>
@@ -25,9 +25,9 @@
 #include <wx/bmpcbox.h>
 #include <wx/wupdlock.h>
 
-#include "../../libslic3r/libslic3r.h"
-#include "../../libslic3r/PlaceholderParser.hpp"
-#include "../../libslic3r/Utils.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/PlaceholderParser.hpp"
+#include "libslic3r/Utils.hpp"
 
 // Store the print/filament/printer presets into a "presets" subdirectory of the Slic3rPE config dir.
 // This breaks compatibility with the upstream Slic3r if the --datadir is used to switch between the two versions.

src/slic3r/GUI/PresetHints.cpp

@@ -1,15 +1,16 @@
-//#undef NDEBUG
 #include <cassert>
 
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/libslic3r.h"
+
 #include "PresetBundle.hpp"
 #include "PresetHints.hpp"
-#include "Flow.hpp"
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <wx/intl.h> 
 
-#include "../../libslic3r/libslic3r.h"
 #include "GUI.hpp"
+#include "I18N.hpp"
 
 namespace Slic3r {
 

src/slic3r/GUI/RammingChart.cpp

@@ -3,7 +3,7 @@
 
 #include "RammingChart.hpp"
 #include "GUI.hpp"
-
+#include "I18N.hpp"
 
 wxDEFINE_EVENT(EVT_WIPE_TOWER_CHART_CHANGED, wxCommandEvent);
 

src/slic3r/GUI/SysInfoDialog.cpp

@@ -1,13 +1,11 @@
 #include "SysInfoDialog.hpp"
-// #include "AboutDialog.hpp"
+#include "I18N.hpp"
+#include "3DScene.hpp"
+#include "GUI.hpp"
 
 #include <wx/clipbrd.h>
 #include <wx/platinfo.h>
 
-// #include "../../libslic3r/Utils.hpp"
-#include "3DScene.hpp"
-#include "GUI.hpp"
-
 namespace Slic3r { 
 namespace GUI {
 

src/slic3r/GUI/Tab.cpp

@@ -2017,7 +2017,7 @@ void TabPrinter::build_extruder_pages()
 
 	for (auto extruder_idx = m_extruders_count_old; extruder_idx < m_extruders_count; ++extruder_idx) {
 		//# build page
-		char buf[MIN_BUF_LENGTH_FOR_L];
+		char buf[512];
 		sprintf(buf, _CHB(L("Extruder %d")), extruder_idx + 1);
 		auto page = add_options_page(from_u8(buf), "funnel.png", true);
 		m_pages.insert(m_pages.begin() + n_before_extruders + extruder_idx, page);

src/slic3r/GUI/UpdateDialogs.cpp

@@ -12,6 +12,7 @@
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Utils.hpp"
 #include "GUI.hpp"
+#include "I18N.hpp"
 #include "ConfigWizard.hpp"
 
 namespace Slic3r {

src/slic3r/GUI/WipeTowerDialog.cpp

@@ -2,6 +2,7 @@
 #include <sstream>
 #include "WipeTowerDialog.hpp"
 #include "GUI.hpp"
+#include "I18N.hpp"
 
 #include <wx/sizer.h>
 

src/slic3r/GUI/callback.hpp

@@ -1,32 +0,0 @@
-// I AM A PHONY PLACEHOLDER FOR THE PERL CALLBACK.
-// GET RID OF ME!
-
-#ifndef slic3r_GUI_PerlCallback_phony_hpp_
-#define slic3r_GUI_PerlCallback_phony_hpp_
-
-#include <vector>
-
-namespace Slic3r {
-
-class PerlCallback {
-public:
-    // PerlCallback(void *) {}
-    PerlCallback() {}
-    void register_callback(void *) {}
-    void deregister_callback() {}
-    void call() const {}
-    void call(int) const {}
-    void call(int, int) const {}
-    void call(const std::vector<int>&) const {}
-    void call(double) const {}
-    void call(double, double) const {}
-    void call(double, double, double) const {}
-    void call(double, double, double, double) const {}
-    void call(double, double, double, double, double) const {}
-    void call(double, double, double, double, double, double) const {}
-    void call(bool b) const {}
-};
-
-} // namespace Slic3r
-
-#endif /* slic3r_GUI_PerlCallback_phony_hpp_ */

src/slic3r/GUI/wxExtensions.cpp

@@ -1,15 +1,16 @@
 #include "wxExtensions.hpp"
 
-#include "../../libslic3r/Utils.hpp"
-#include "BitmapCache.hpp"
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/Model.hpp"
 
 #include <wx/sizer.h>
 #include <wx/statline.h>
 #include <wx/dcclient.h>
 #include <wx/numformatter.h>
+
+#include "BitmapCache.hpp"
 #include "GUI_App.hpp"
 #include "GUI_ObjectList.hpp"
-#include "Model.hpp"
 
 wxDEFINE_EVENT(wxCUSTOMEVT_TICKSCHANGED, wxEvent);
 wxDEFINE_EVENT(wxCUSTOMEVT_LAST_VOLUME_IS_DELETED, wxCommandEvent);

src/slic3r/Utils/Duet.cpp

@@ -19,6 +19,7 @@
 
 #include "libslic3r/PrintConfig.hpp"
 #include "slic3r/GUI/GUI.hpp"
+#include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/MsgDialog.hpp"
 #include "Http.hpp"
 

src/slic3r/Utils/FixModelByWin10.cpp

@@ -32,6 +32,7 @@
 #include "libslic3r/Print.hpp"
 #include "libslic3r/Format/3mf.hpp"
 #include "../GUI/GUI.hpp"
+#include "../GUI/I18N.hpp"
 #include "../GUI/PresetBundle.hpp"
 
 #include <wx/msgdlg.h>

src/slic3r/Utils/OctoPrint.cpp

@@ -8,6 +8,8 @@
 #include "libslic3r/PrintConfig.hpp"
 #include "Http.hpp"
 
+#include "slic3r/GUI/I18N.hpp"
+
 namespace fs = boost::filesystem;
 
 

src/slic3r/Utils/PresetUpdater.cpp

@@ -18,13 +18,14 @@
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Utils.hpp"
 #include "slic3r/GUI/GUI.hpp"
+#include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/PresetBundle.hpp"
 #include "slic3r/GUI/UpdateDialogs.hpp"
 #include "slic3r/GUI/ConfigWizard.hpp"
+#include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/Utils/Http.hpp"
 #include "slic3r/Config/Version.hpp"
 #include "slic3r/Config/Snapshot.hpp"
-#include "slic3r/GUI/GUI_App.hpp"
 
 namespace fs = boost::filesystem;
 using Slic3r::GUI::Config::Index;

src/slic3r/Utils/PrintHostSendDialog.cpp

@@ -10,7 +10,7 @@
 
 #include "slic3r/GUI/GUI.hpp"
 #include "slic3r/GUI/MsgDialog.hpp"
-
+#include "slic3r/GUI/I18N.hpp"
 
 namespace fs = boost::filesystem;
 

xs/CMakeLists.txt

@@ -99,11 +99,7 @@ else()
 endif()
 add_library(XS ${XS_SHARED_LIBRARY_TYPE}
     ${XS_MAIN_CPP}
-#    ${LIBDIR}/libslic3r/utils.cpp
-#    ${LIBDIR}/slic3r/GUI/wxPerlIface.cpp
     src/perlglue.cpp
-#    src/callback.cpp
-#    src/callback.hpp
     src/ppport.h
     src/xsinit.h
     xsp/my.map
@@ -119,7 +115,7 @@ if(APPLE)
 endif()
 target_link_libraries(XS libslic3r)
 
-target_include_directories(XS PRIVATE src)
+target_include_directories(XS PRIVATE src ${LIBDIR}/libslic3r)
 target_compile_definitions(XS PRIVATE -DSLIC3RXS)
 set_target_properties(XS PROPERTIES PREFIX "") # Prevent cmake from generating libXS.so instead of XS.so
 

xs/src/callback.cpp

@@ -1,175 +0,0 @@
-#include "callback.hpp"
-
-#include <xsinit.h>
-
-void PerlCallback::register_callback(void *sv)
-{ 
-    if (! SvROK((SV*)sv) || SvTYPE(SvRV((SV*)sv)) != SVt_PVCV)
-        croak("Not a Callback %_ for PerlFunction", (SV*)sv);
-    if (m_callback)
-        SvSetSV((SV*)m_callback, (SV*)sv);
-    else
-        m_callback = newSVsv((SV*)sv);
-}
-
-void PerlCallback::deregister_callback()
-{
-	if (m_callback) {
-		sv_2mortal((SV*)m_callback);
-		m_callback = nullptr;
-	}
-}
-
-void PerlCallback::call() const
-{
-    if (! m_callback)
-        return;
-    dSP;
-    ENTER;
-    SAVETMPS;
-    PUSHMARK(SP);
-    PUTBACK; 
-    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
-    FREETMPS;
-    LEAVE;
-}
-
-void PerlCallback::call(int i) const
-{
-    if (! m_callback)
-        return;
-    dSP;
-    ENTER;
-    SAVETMPS;
-    PUSHMARK(SP);
-    XPUSHs(sv_2mortal(newSViv(i)));
-    PUTBACK; 
-    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
-    FREETMPS;
-    LEAVE;
-}
-
-void PerlCallback::call(int i, int j) const
-{
-    if (! m_callback)
-        return;
-    dSP;
-    ENTER;
-    SAVETMPS;
-    PUSHMARK(SP);
-    XPUSHs(sv_2mortal(newSViv(i)));
-    XPUSHs(sv_2mortal(newSViv(j)));
-    PUTBACK; 
-    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
-    FREETMPS;
-    LEAVE;
-}
-
-void PerlCallback::call(const std::vector<int>& ints) const
-{
-    if (! m_callback)
-        return;
-    dSP;
-    ENTER;
-    SAVETMPS;
-    PUSHMARK(SP);
-    for (int i : ints)
-    {
-        XPUSHs(sv_2mortal(newSViv(i)));
-    }
-    PUTBACK;
-    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
-    FREETMPS;
-    LEAVE;
-}
-
-void PerlCallback::call(double a) const
-{
-    if (!m_callback)
-        return;
-    dSP;
-    ENTER;
-    SAVETMPS;
-    PUSHMARK(SP);
-    XPUSHs(sv_2mortal(newSVnv(a)));
-    PUTBACK;
-    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
-    FREETMPS;
-    LEAVE;
-}
-
-void PerlCallback::call(double a, double b) const
-{
-    if (!m_callback)
-        return;
-    dSP;
-    ENTER;
-    SAVETMPS;
-    PUSHMARK(SP);
-    XPUSHs(sv_2mortal(newSVnv(a)));
-    XPUSHs(sv_2mortal(newSVnv(b)));
-    PUTBACK;
-    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
-    FREETMPS;
-    LEAVE;
-}
-
-void PerlCallback::call(double a, double b, double c) const
-{
-    if (!m_callback)
-        return;
-    dSP;
-    ENTER;
-    SAVETMPS;
-    PUSHMARK(SP);
-    XPUSHs(sv_2mortal(newSVnv(a)));
-    XPUSHs(sv_2mortal(newSVnv(b)));
-    XPUSHs(sv_2mortal(newSVnv(c)));
-    PUTBACK;
-    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
-    FREETMPS;
-    LEAVE;
-}
-
-void PerlCallback::call(double a, double b, double c, double d) const
-{
-    if (!m_callback)
-        return;
-    dSP;
-    ENTER;
-    SAVETMPS;
-    PUSHMARK(SP);
-    XPUSHs(sv_2mortal(newSVnv(a)));
-    XPUSHs(sv_2mortal(newSVnv(b)));
-    XPUSHs(sv_2mortal(newSVnv(c)));
-    XPUSHs(sv_2mortal(newSVnv(d)));
-    PUTBACK;
-    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
-    FREETMPS;
-    LEAVE;
-}
-
-void PerlCallback::call(double a, double b, double c, double d, double e, double f) const
-{
-    if (!m_callback)
-        return;
-    dSP;
-    ENTER;
-    SAVETMPS;
-    PUSHMARK(SP);
-    XPUSHs(sv_2mortal(newSVnv(a)));
-    XPUSHs(sv_2mortal(newSVnv(b)));
-    XPUSHs(sv_2mortal(newSVnv(c)));
-    XPUSHs(sv_2mortal(newSVnv(d)));
-    XPUSHs(sv_2mortal(newSVnv(e)));
-    XPUSHs(sv_2mortal(newSVnv(f)));
-    PUTBACK;
-    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
-    FREETMPS;
-    LEAVE;
-}
-
-void PerlCallback::call(bool b) const
-{
-    call(b ? 1 : 0);
-}

xs/src/callback.hpp

@@ -1,33 +0,0 @@
-#ifndef slic3r_PerlCallback_hpp_
-#define slic3r_PerlCallback_hpp_
-
-#include <locale>
-
-#include "libslic3r.h"
-
-namespace Slic3r {
-
-class PerlCallback {
-public:
-    PerlCallback(void *sv) : m_callback(nullptr) { this->register_callback(sv); }
-    PerlCallback() : m_callback(nullptr) {}
-    ~PerlCallback() { this->deregister_callback(); }
-    void register_callback(void *sv);
-    void deregister_callback();
-    void call() const;
-    void call(int i) const;
-    void call(int i, int j) const;
-    void call(const std::vector<int>& ints) const;
-    void call(double a) const;
-    void call(double a, double b) const;
-    void call(double a, double b, double c) const;
-    void call(double a, double b, double c, double d) const;
-    void call(double a, double b, double c, double d, double e, double f) const;
-    void call(bool b) const;
-private:
-    void *m_callback;
-};
-
-} // namespace Slic3r
-
-#endif /* slic3r_PerlCallback_hpp_ */