DragDropDemo: updated to latest modules + 3.6.0 compatibility

Author: ivan-mogilko

demos/DragDropDemo/DragDrop.asc

@@ -8,10 +8,9 @@ struct DragDropSettings
 
   eKeyCode HookKey;         // default hook key
   MouseButton HookMBtn;     // default hook mouse button
+  bool AutoTrackHookKey;    // track hook key press and release
   int  DragMinDistance;     // minimal number of pixels to start drag
   int  DragMinTime;         // minimal time to start drag
-  
-  bool AutoTrackHookKey;    // track hook key press and release
   DragDropUnhookAction DefaultUnhookAction; // what to do by default when the hook key is up
 };
 
@@ -267,26 +266,26 @@ static void DragDrop::HookKeyDown(int user_key, MouseButton mbut)
 
 //===========================================================================
 //
-// DragDrop::SetDragObject()
+// DragDrop::DragKeyUp()
 //
 //===========================================================================
-static void DragDrop::HookObject(int user_mode, int obj_x, int obj_y, int tag, String stag)
+static void DragDrop::HookKeyUp()
 {
-  if (DDState.IsWantingObject())
-    DDState.SetDragObject(user_mode, obj_x, obj_y, tag, stag);
+  if (DDState.IsDragging())
+    DDState.StartDropping();
+  else
+    DDState.Reset();
 }
 
 //===========================================================================
 //
-// DragDrop::DragKeyUp()
+// DragDrop::SetDragObject()
 //
 //===========================================================================
-static void DragDrop::HookKeyUp()
+static void DragDrop::HookObject(int user_mode, int obj_x, int obj_y, int tag, String stag)
 {
-  if (DDState.IsDragging())
-    DDState.StartDropping();
-  else
-    DDState.Reset();
+  if (DDState.IsWantingObject())
+    DDState.SetDragObject(user_mode, obj_x, obj_y, tag, stag);
 }
 
 //===========================================================================

demos/DragDropDemo/DragDrop.ash

@@ -24,7 +24,7 @@
 #ifndef __MOUSE_DRAGDROP_MODULE__
 #define __MOUSE_DRAGDROP_MODULE__
 
-#define MOUSE_DRAGDROP_VERSION_00_01_01_00
+#define MOUSE_DRAGDROP_VERSION_00_01_02_00
 
 // Comment this line out to completely disable DragDrop during compilation
 #define ENABLE_MOUSE_DRAGDROP
@@ -60,13 +60,12 @@ struct DragDrop
   import static attribute eKeyCode    DefaultHookKey;
   /// Get/set default hook mouse button
   import static attribute MouseButton DefaultHookMouseButton;
+  /// Get/set if the module should automatically track hook key press and release
+  import static attribute bool        AutoTrackHookKey;
   /// Get/set minimal number of pixels the mouse should move before it is considered to be dragging
   import static attribute int         DragMinDistance;
-  /// Get/set minimal time (in milliseconds) the mouse should move before it is considered to be dragging
+  /// Get/set minimal time (in milliseconds) the hook key should be pressed down before it is considered to be dragging
   import static attribute int         DragMinTime;
-  
-  /// Get/set if the module should automatically track hook key press and release
-  import static attribute bool        AutoTrackHookKey;
   /// Get/set the default action that should be done to dragged object when the hook key is released;
   /// this action may be overriden by user by explicitly calling Drop() or Revert()
   import static attribute DragDropUnhookAction DefaultUnhookAction;
@@ -140,10 +139,10 @@ struct DragDrop
 
   /// Notify hook key push down; this does not have to be real keycode
   import static void  HookKeyDown(int user_key = 0, MouseButton mbtn = 0);
-  /// Assign a draggable object for the module when it expects to find one under the mouse cursor
-  import static void  HookObject(int user_mode, int obj_x, int obj_y, int tag = 0, String stag = 0);
   /// Notify hook key release
   import static void  HookKeyUp();
+  /// Assign a draggable object for the module when it expects to find one under the mouse cursor
+  import static void  HookObject(int user_mode, int obj_x, int obj_y, int tag = 0, String stag = 0);
 
   /// Drop the object now
   import static void  Drop();

demos/DragDropDemo/DragDropCommon.asc

@@ -8,9 +8,10 @@ struct DragDropSettings
   bool PixelPerfect;        // pixel-perfect hit mode for AGS objects
   bool TestClickable;       // test Clickable property for AGS objects
   DragDropCommonMove Move;  // whether object is dragged itself, or overlay with object's image on it
-  int  GhostTransparency;   // transparency value of the overlay
-  bool GhostAlpha;          // keep alpha channel when creating translucent overlays
   GUI* GhostGUI;            // GUI to use for dragged object representation
+  int  GhostZOrder;         // ZOrder to use for ghost representation
+  int  GhostTransparency;   // transparency value of the ghost representation
+  bool GhostAlpha;          // keep alpha channel when creating translucent overlays
 };
 
 DragDropSettings DDSet;
@@ -53,9 +54,10 @@ void Reset(this DragDropSettings*)
   this.PixelPerfect = false;
   this.TestClickable = false;
   this.Move = eDDCmnMoveSelf;
+  this.GhostGUI = null;
+  this.GhostZOrder = 1000; // max GUI zorder in 3.2.1, according to the manual
   this.GhostTransparency = 33;
   this.GhostAlpha = true;
-  this.GhostGUI = null;
 }
 
 //===========================================================================
@@ -65,9 +67,11 @@ void Reset(this DragDropSettings*)
 //
 //===========================================================================
 int CreateRepresentation(this DragDropState*, DragDropCommonMove move, int x, int y, int offx, int offy,
-                         int slot, int trans, bool has_alpha)
+                         int slot, int trans, int zorder, bool has_alpha)
 {
   this.GhostGraphic = slot;
+#ifndef SCRIPT_API_v360
+  // NOTE: pre-3.6.0 did not support Overlay.Transparency
   if (move != eDDCmnMoveGhostGUI &&
       trans != 100 && trans != 0)
   {
@@ -78,11 +82,16 @@ int CreateRepresentation(this DragDropState*, DragDropCommonMove move, int x, in
     this.GhostDspr = spr;
     slot = spr.Graphic;
   }
+#endif
   this.OverlayOffX = offx;
   this.OverlayOffY = offy;
   if (move == eDDCmnMoveGhostOverlay)
   {
     this.GhostOverlay = Overlay.CreateGraphical(x + offx, y + offy, slot, true);
+#ifdef SCRIPT_API_v360
+    this.GhostOverlay.Transparency = trans;
+    this.GhostOverlay.ZOrder = zorder;
+#endif
   }
   else
   {
@@ -93,7 +102,7 @@ int CreateRepresentation(this DragDropState*, DragDropCommonMove move, int x, in
     this.GhostGUI.Y = y + offy;
     this.GhostGUI.Width = Game.SpriteWidth[slot];
     this.GhostGUI.Height = Game.SpriteHeight[slot];
-    this.GhostGUI.ZOrder = 1000; // max zorder, according to the manual
+    this.GhostGUI.ZOrder = zorder;
     this.GhostGUI.Visible = true;
   }
   this.Move = move;
@@ -168,7 +177,7 @@ static bool DragDropCommon::TryHookCharacter()
     if (vf != null)
       sprite = vf.Graphic;
     DDState.CreateRepresentation(DDSet.Move, c.x, c.y, 0, -Game.SpriteHeight[sprite], sprite,
-                                 DDSet.GhostTransparency, DDSet.GhostAlpha);
+                                 DDSet.GhostTransparency, DDSet.GhostZOrder, DDSet.GhostAlpha);
   }
   return true;
 }
@@ -190,6 +199,7 @@ static bool DragDropCommon::TryHookGUI()
     return false;
   DDState._GUI = g;
   DragDrop.HookObject(eDragDropGUI, g.X, g.Y);
+  // NOTE: GUIs may be only dragged on their own
   return true;
 }
 
@@ -211,6 +221,7 @@ static bool DragDropCommon::TryHookGUIControl()
     return false;
   DDState._GUIControl = gc;
   DragDrop.HookObject(eDragDropGUIControl, gc.X, gc.Y);
+  // NOTE: GUI Controls may be only dragged on their own
   return true;
 }
 
@@ -247,7 +258,7 @@ static bool DragDropCommon::TryHookRoomObject()
       sprite = o.Graphic;
     }
     DDState.CreateRepresentation(DDSet.Move, o.X, o.Y, 0, -Game.SpriteHeight[sprite], sprite,
-                                 DDSet.GhostTransparency, DDSet.GhostAlpha);
+                                 DDSet.GhostTransparency, DDSet.GhostZOrder, DDSet.GhostAlpha);
   }
   return true;
 }
@@ -271,9 +282,10 @@ static bool DragDropCommon::TryHookInventoryItem()
   int i_x = DragDrop.DragStartX - (DragDrop.DragStartX - wnd.OwningGUI.X - wnd.X) % wnd.ItemWidth;
   int i_y = DragDrop.DragStartY - (DragDrop.DragStartY - wnd.OwningGUI.Y - wnd.Y) % wnd.ItemHeight;
   DragDrop.HookObject(eDragDropInvItem, i_x, i_y);
+  // NOTE: Inventory Items may be only dragged using representation
   int sprite = i.Graphic;
   DDState.CreateRepresentation(DDSet.Move, i_x, i_y, 0, 0, sprite,
-                                 DDSet.GhostTransparency, DDSet.GhostAlpha);
+                                 DDSet.GhostTransparency, DDSet.GhostZOrder, DDSet.GhostAlpha);
   return true;
 }
 
@@ -390,47 +402,62 @@ void set_DragMove(this DragDropCommon*, DragDropCommonMove value)
 
 //===========================================================================
 //
-// DragDropCommon::GhostTransparency property
+// DragDropCommon::GhostGUI property
 //
 //===========================================================================
-int get_GhostTransparency(this DragDropCommon*)
+GUI* get_GhostGUI(this DragDropCommon*)
 {
-  return DDSet.GhostTransparency;
+  return DDSet.GhostGUI;
 }
 
-void set_GhostTransparency(this DragDropCommon*, int value)
+void set_GhostGUI(this DragDropCommon*, GUI* value)
 {
-  DDSet.GhostTransparency = value;
+  DDSet.GhostGUI = value;
 }
 
 //===========================================================================
 //
-// DragDropCommon::GhostAlpha property
+// DragDropCommon::GhostZOrder property
 //
 //===========================================================================
-bool get_GhostAlpha(this DragDropCommon*)
+int get_GhostZOrder(this DragDropCommon*)
 {
-  return DDSet.GhostAlpha;
+  return DDSet.GhostZOrder;
 }
 
-void set_GhostAlpha(this DragDropCommon*, bool value)
+void set_GhostZOrder(this DragDropCommon*, int value)
 {
-  DDSet.GhostAlpha = value;
+  DDSet.GhostZOrder = value;
 }
 
 //===========================================================================
 //
-// DragDropCommon::GhostGUI property
+// DragDropCommon::GhostTransparency property
 //
 //===========================================================================
-GUI* get_GhostGUI(this DragDropCommon*)
+int get_GhostTransparency(this DragDropCommon*)
 {
-  return DDSet.GhostGUI;
+  return DDSet.GhostTransparency;
 }
 
-void set_GhostGUI(this DragDropCommon*, GUI* value)
+void set_GhostTransparency(this DragDropCommon*, int value)
 {
-  DDSet.GhostGUI = value;
+  DDSet.GhostTransparency = value;
+}
+
+//===========================================================================
+//
+// DragDropCommon::GhostAlpha property
+//
+//===========================================================================
+bool get_GhostAlpha(this DragDropCommon*)
+{
+  return DDSet.GhostAlpha;
+}
+
+void set_GhostAlpha(this DragDropCommon*, bool value)
+{
+  DDSet.GhostAlpha = value;
 }
 
 //===========================================================================
@@ -571,6 +598,16 @@ int get_ObjectHeight(this DragDropCommon*)
   return 0;
 }
 
+//===========================================================================
+//
+// DragDropCommon::GhostOverlay property
+//
+//===========================================================================
+Overlay* get_GhostOverlay(this DragDropCommon*)
+{
+  return DDState.GhostOverlay;
+}
+
 //===========================================================================
 //
 // DragDropCommon::UsedGhostGraphic property

demos/DragDropDemo/DragDropCommon.ash

@@ -28,7 +28,7 @@
 #error DragDropCommon requires DragDrop module
 #endif
 
-#define MOUSE_DRAGDROPCOMMON_VERSION_00_01_01_00
+#define MOUSE_DRAGDROPCOMMON_VERSION_00_01_02_00
 
 // Comment this line out to completely disable DragDropCommon during compilation
 #define ENABLE_MOUSE_DRAGDROPCOMMON
@@ -48,12 +48,15 @@ enum DragDropCommonMode
 // DragDropCommonMove enumeration determines the way hooked object is being dragged around
 enum DragDropCommonMove
 {
-  // drag actual object itself (position updates real-time)
+  // drag actual object itself (position updates real-time);
+  // this works for everything except inventory items (because they do not have
+  // actual position on screen on their own)
   eDDCmnMoveSelf,
   // drag overlay with object's image, while object stays in place until drag ends;
-  // this currently works only for characters and room objects!
+  // this works for everything except GUI and controls
   eDDCmnMoveGhostOverlay, 
-  // drag GUI with object's image; this is currently only way to drag inventory items
+  // drag GUI with object's image;
+  // this works for everything except GUI and controls
   eDDCmnMoveGhostGUI
 };
 
@@ -66,28 +69,31 @@ struct DragDropCommon
   // Functions and properties meant to configure the drag'n'drop behavior.
   //
   ///////////////////////////////////////////////////////////////////////////
-  
+
   /// Get/set whether particular drag'n'drop mode is enabled
   import static attribute bool  ModeEnabled[];
   /// Disable drag'n'drop for all the modes
   import static void            DisableAllModes();
-  
+
   /// Get/set whether click on AGS object should be tested using pixel-perfect detection
   /// (alternatively only hit inside bounding rectangle is tested)
   import static attribute bool  PixelPerfect;
   /// Get/set whether only Clickable AGS objects should be draggable
   import static attribute bool  TestClickable;
-  
+
   /// Get/set the way object's drag around is represented
   import static attribute DragDropCommonMove DragMove;
-  /// Get/set transparency of a representation used when DragStyle is NOT eDragDropMoveSelf
-  import static attribute int   GhostTransparency;
-  /// Get/set whether representation should keep sprite's alpha channel
-  import static attribute bool  GhostAlpha;
   /// Get/set the GUI used to represent dragged object
   import static attribute GUI*  GhostGUI;
-  
-  
+  /// Get/set the wanted z-order of a ghost representation (GUI or Overlay);
+  /// please note that Overlays can have ZOrder only since AGS 3.6.0.
+  import static attribute int   GhostZOrder;
+  /// Get/set whether representation should keep sprite's alpha channel
+  import static attribute bool  GhostAlpha;
+  /// Get/set transparency of a representation used when DragStyle is NOT eDragDropMoveSelf
+  import static attribute int   GhostTransparency;
+
+
   ///////////////////////////////////////////////////////////////////////////
   //
   // State control
@@ -96,7 +102,7 @@ struct DragDropCommon
   // and control its state.
   //
   ///////////////////////////////////////////////////////////////////////////
-  
+
   /// Gets current dragged character
   readonly import static attribute Character*   _Character;
   /// Gets current dragged GUI
@@ -111,9 +117,11 @@ struct DragDropCommon
   readonly import static attribute int          ObjectWidth;
   /// Gets current dragged object's or its representation height
   readonly import static attribute int          ObjectHeight;
+  /// Gets current Overlay representing the dragged object (only if drag style is eDDCmnMoveGhostOverlay)
+  readonly import static attribute Overlay*     GhostOverlay;
   /// Gets current dragged overlay's graphic (only if drag style is NOT eDragDropMoveSelf)
   readonly import static attribute int          UsedGhostGraphic;
-  
+
   /// Start dragging a character under cursor
   import static bool  TryHookCharacter();
   /// Start dragging a GUI under cursor