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



module dfl.label;

private import dfl.base, dfl.control, dfl.internal.winapi, dfl.application,
        dfl.event, dfl.drawing, dfl.internal.dlib;



class Label: Control { // docmain
   this() {
      resizeRedraw = true; // Word wrap and center correctly.

      tfmt = new TextFormat(TextFormatFlags.WORD_BREAK | TextFormatFlags.LINE_LIMIT);
   }



   @property void borderStyle(BorderStyle bs) { // setter
      final switch(bs) {
         case BorderStyle.FIXED_3D:
            _style(_style() & ~WS_BORDER);
            _exStyle(_exStyle() | WS_EX_CLIENTEDGE);
            break;

         case BorderStyle.FIXED_SINGLE:
            _exStyle(_exStyle() & ~WS_EX_CLIENTEDGE);
            _style(_style() | WS_BORDER);
            break;

         case BorderStyle.NONE:
            _style(_style() & ~WS_BORDER);
            _exStyle(_exStyle() & ~WS_EX_CLIENTEDGE);
            break;
      }

      if(isHandleCreated) {
         redrawEntire();
      }
   }

   /// ditto
   @property BorderStyle borderStyle() { // getter
      if(_exStyle() & WS_EX_CLIENTEDGE) {
         return BorderStyle.FIXED_3D;
      } else if(_style() & WS_BORDER) {
         return BorderStyle.FIXED_SINGLE;
      }
      return BorderStyle.NONE;
   }



   final @property void useMnemonic(bool byes) { // setter
      if(byes) {
         tfmt.formatFlags = tfmt.formatFlags & ~TextFormatFlags.NO_PREFIX;
         _style(_style() & ~SS_NOPREFIX);
      } else {
         tfmt.formatFlags = tfmt.formatFlags | TextFormatFlags.NO_PREFIX;
         _style(_style() | SS_NOPREFIX);
      }

      if(isHandleCreated) {
         invalidate();
      }
   }

   /// ditto
   final @property bool useMnemonic() { // getter
      return (tfmt.formatFlags & TextFormatFlags.NO_PREFIX) == 0;
   }



   @property Size preferredSize() { // getter
      Size result;
      Graphics g;
      g = isHandleCreated ? createGraphics() : Graphics.getScreen();
      result = g.measureText(text, font, tfmt);
      g.dispose();
      return result;
   }


   private void doAutoSize(Dstring text) {
      //if(isHandleCreated)
      {
         clientSize = preferredSize;
      }
   }


   override @property void text(Dstring newText) { // setter
      super.text = newText;

      if(autosz) {
         doAutoSize(newText);
      }

      invalidate(false);
   }

   alias Control.text text; // Overload.



   @property void autoSize(bool byes) { // setter
      if(byes != autosz) {
         autosz = byes;

         if(byes) {
            doAutoSize(text);
         }
      }
   }

   /// ditto
   @property bool autoSize() { // getter
      return autosz;
   }



   @property void textAlign(ContentAlignment calign) { // setter
      final switch(calign) {
         case ContentAlignment.TOP_LEFT:
            tfmt.alignment = TextAlignment.TOP | TextAlignment.LEFT;
            break;

         case ContentAlignment.BOTTOM_CENTER:
            tfmt.alignment = TextAlignment.BOTTOM | TextAlignment.CENTER;
            break;

         case ContentAlignment.BOTTOM_LEFT:
            tfmt.alignment = TextAlignment.BOTTOM | TextAlignment.LEFT;
            break;

         case ContentAlignment.BOTTOM_RIGHT:
            tfmt.alignment = TextAlignment.BOTTOM | TextAlignment.RIGHT;
            break;

         case ContentAlignment.MIDDLE_CENTER:
            tfmt.alignment = TextAlignment.MIDDLE | TextAlignment.CENTER;
            break;

         case ContentAlignment.MIDDLE_LEFT:
            tfmt.alignment = TextAlignment.MIDDLE | TextAlignment.LEFT;
            break;

         case ContentAlignment.MIDDLE_RIGHT:
            tfmt.alignment = TextAlignment.MIDDLE | TextAlignment.RIGHT;
            break;

         case ContentAlignment.TOP_CENTER:
            tfmt.alignment = TextAlignment.TOP | TextAlignment.CENTER;
            break;

         case ContentAlignment.TOP_RIGHT:
            tfmt.alignment = TextAlignment.TOP | TextAlignment.RIGHT;
            break;
      }

      invalidate(); // ?
   }

   /// ditto
   @property ContentAlignment textAlign() { // getter
      TextAlignment ta;
      ta = tfmt.alignment;

      if(ta & TextAlignment.BOTTOM) {
         if(ta & TextAlignment.RIGHT) {
            return ContentAlignment.BOTTOM_RIGHT;
         } else if(ta & TextAlignment.CENTER) {
            return ContentAlignment.BOTTOM_CENTER;
         } else { // Left.
            return ContentAlignment.BOTTOM_LEFT;
         }
      } else if(ta & TextAlignment.MIDDLE) {
         if(ta & TextAlignment.RIGHT) {
            return ContentAlignment.MIDDLE_RIGHT;
         } else if(ta & TextAlignment.CENTER) {
            return ContentAlignment.MIDDLE_CENTER;
         } else { // Left.
            return ContentAlignment.MIDDLE_LEFT;
         }
      } else { // Top.
         if(ta & TextAlignment.RIGHT) {
            return ContentAlignment.TOP_RIGHT;
         } else if(ta & TextAlignment.CENTER) {
            return ContentAlignment.TOP_CENTER;
         } else { // Left.
            return ContentAlignment.TOP_LEFT;
         }
      }
   }


   protected override @property Size defaultSize() { // getter
      return Size(100, 23);
   }


   protected override void onPaint(PaintEventArgs ea) {
      int x, y, w, h;
      Dstring text;

      text = this.text;

      if(tfmt.alignment & TextAlignment.MIDDLE) {
         // Graphics.drawText() does not support middle alignment
         // if the text is multiline, so need to do extra work.
         Size sz;
         sz = ea.graphics.measureText(text, font, tfmt);
         x = 0;
         //if(sz.height >= this.clientSize.height)
         // y = 0;
         //else
         y = (this.clientSize.height - sz.height) / 2;
         w = clientSize.width;
         h = sz.height;
      } else if(tfmt.alignment & TextAlignment.BOTTOM) {
         // Graphics.drawText() does not support bottom alignment
         // if the text is multiline, so need to do extra work.
         Size sz;
         sz = ea.graphics.measureText(text, font, tfmt);
         x = 0;
         //if(sz.height >= this.clientSize.height)
         // y = 0;
         //else
         y = this.clientSize.height - sz.height;
         w = clientSize.width;
         h = sz.height;
      } else {
         x = 0;
         y = 0;
         w = clientSize.width;
         h = clientSize.height;
      }

      Color c;
      //c = foreColor;
      c = foreColor.solidColor(backColor);

      if(enabled) {
         ea.graphics.drawText(text, font, c, Rect(x, y, w, h), tfmt);
      } else {
         version(LABEL_GRAYSTRING) {
            // GrayString() is pretty ugly.
            GrayStringA(ea.graphics.handle, null, &_disabledOutputProc,
                        cast(LPARAM)cast(void*)this, -1, x, y, w, h);
         }
         else {
            ea.graphics.drawTextDisabled(text, font, c, backColor, Rect(x, y, w, h), tfmt);
         }
      }

      super.onPaint(ea);
   }


   /+
   protected override void onHandleCreated(EventArgs ea) {
      super.onHandleCreated(ea);

      /+
      if(autosz) {
         doAutoSize(text);
      }
      +/
   }
   +/


   protected override void onEnabledChanged(EventArgs ea) {
      invalidate(false);

      super.onEnabledChanged(ea);
   }


   protected override void onFontChanged(EventArgs ea) {
      if(autosz) {
         doAutoSize(text);
      }

      invalidate(false);

      super.onFontChanged(ea);
   }


   protected override void wndProc(ref Message m) {
      switch(m.msg) {
         case WM_GETDLGCODE:
            super.wndProc(m);
            //if(useMnemonic)
            m.result |= DLGC_STATIC;
            break;

         default:
            super.wndProc(m);
      }
   }


   protected override bool processMnemonic(dchar charCode) {
      if(visible && enabled) {
         if(isMnemonic(charCode, text)) {
            select(true, true);
            return true;
         }
      }
      return false;
   }


 private:
   TextFormat _tfmt;
   bool autosz = false;


   final @property void tfmt(TextFormat tf) { // setter
      _tfmt = tf;
   }


   final @property TextFormat tfmt() { // getter
      /+
      // This causes it to invert.
      if(rightToLeft) {
         _tfmt.formatFlags = _tfmt.formatFlags | TextFormatFlags.DIRECTION_RIGHT_TO_LEFT;
      } else {
         _tfmt.formatFlags = _tfmt.formatFlags & ~TextFormatFlags.DIRECTION_RIGHT_TO_LEFT;
      }
      +/

      return _tfmt;
   }
}


version(LABEL_GRAYSTRING) {
   private extern(Windows) BOOL _disabledOutputProc(HDC hdc, LPARAM lpData, int cchData) {
      BOOL result = TRUE;
      try {
         scope Graphics g = new Graphics(hdc, false);
         Label l;
         with(l = cast(Label)cast(void*)lpData) {
            g.drawText(text, font, foreColor,
                       Rect(0, 0, clientSize.width, clientSize.height), tfmt);
         }
      } catch(DThrowable e) {
         Application.onThreadException(e);
         result = FALSE;
      }
      return result;
   }
}