%       /¯_ |¯\  /\  |¯\ | |  | /¯   (`  /¯  /¯\ |\ | ¯|¯ |_¯ \/ ¯|¯ 
%\  W X \_/ |¯\ /¯¯\ |¯¯ |¯|  | \_, \_)  \_, \_/ | \|  |  |__ /\  | . E R L
%%——————————————————————————————————————————————————————————
%%
%%   Copyright Ericsson AB 2008-2013. All Rights Reserved.
%%
%%——————————————————————————————————————————————
%% Whitespace Beautified by ScriptCulture © 2018
%% Sit Back · Feet Up · Learn wxErlang
%% For use as a reference only
%% www.scriptculture.com
%% Not check-summed 
%% wx 1.8 —————————————————————————————————————— 
%%
%% Licensed under the Apache License, 
%% Version 2.0 (the "License"); you may 
%% not use this file except in compliance 
%% with the License. You may obtain a copy 
%% of the License at:
%%
%%     http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by 
%% applicable law or agreed to in writing, software
%% distributed under the License is distributed 
%% on an "AS IS" BASIS, WITHOUT WARRANTIES 
%% OR CONDITIONS OF ANY KIND, either 
%% express or implied. See the 
%% License for the specific 
%% language governing 
%% permissions and
%% limitations 
%% under the 
%% License.
%%%%%%%
%%%%
%%%%%
%% @doc See external documentation: <a href="http://www.wxwidgets.org/manuals/2.8.12/wx_wxgraphicscontext.html">wxGraphicsContext</a>.
%% <p>This class is derived (and can use functions) from:
%% <br />{@link wxGraphicsObject}
%% </p>
%% @type wxGraphicsContext().  
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%   
%%   OVERVIEW
%%   ––––––––
%%   A wxGraphicsContext instance is the object that is drawn upon. 
%%   It is created by a renderer using the CreateContext calls.., 
%%   this can be either directly using a renderer instance, 
%%   or indirectly using the static convenience CreateXXX 
%%   functions of wxGraphicsContext that always delegate 
%%   the task to the default renderer.
%%   
%%   
%%   See Also:
%%   —————————
%%   
%%   
%%   
-module(wxGraphicsContext).
-include("wxe.hrl").
-export([

          clip/2,
          clip/5,

          concatTransform/2,

          create/0,
          create/1,

          createBrush/2,
          createFont/2,
          createFont/3,
          createLinearGradientBrush/7,
          createMatrix/1,
          createMatrix/2,
          createPath/1,
          createPen/2,
          createRadialGradientBrush/8,

          destroy/1,
          
          drawBitmap/6,
          drawEllipse/5,
          drawIcon/6,
          drawLines/2,
          drawLines/3,
          drawPath/2,
          drawPath/3,
          drawRectangle/5,
          drawRoundedRectangle/6,
          drawText/4,
          drawText/5,
          drawText/6,

          fillPath/2,
          fillPath/3,

          getPartialTextExtents/2,
          getTextExtent/2,
          getTransform/1,

          resetClip/1,

          rotate/2,
          
          scale/3,

          setBrush/2,
          setFont/2,
          setFont/3,
          setPen/2,
          setTransform/2,

          strokeLine/5,
          strokeLines/2,
          strokePath/2,

          translate/3
  ]).





%% inherited exports
-export([getRenderer/1,isNull/1,parent_class/1]).

-export_type([wxGraphicsContext/0]).
-deprecated([createLinearGradientBrush/7,createRadialGradientBrush/8]).


%% @hidden
parent_class(wxGraphicsObject) -> true;
parent_class(_Class) -> erlang:error({badtype, ?MODULE}).


-type wxGraphicsContext()  ::  wx:wx_object().




           %·%% CREATE / 0 %%·%

%%   
%%   Creates a wxGraphicsContext from a wxWindowDC (eg a wxPaintDC).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec create() -> wxGraphicsContext().
create() ->
               wxe_util:call(?wxGraphicsContext_Create_0,
               <<>>).





           %·%% CREATE / 1 %%·%

%%   
%%    Creates a wxGraphicsContext from a wxWindow.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec create(Dc) -> wxGraphicsContext()
           when
           Dc :: wxWindowDC:wxWindowDC() 
               |     wxWindow:wxWindow().

create(#wx_ref{type=DcT,ref=DcRef}) ->
                            DcOP = case ?CLASS_T(DcT,wxWindowDC) of
                               true ->
                                    ?wxGraphicsContext_Create_1_1;
                               _ -> ?CLASS(DcT,wxWindow),
                                    ?wxGraphicsContext_Create_1_0
                                    end,
                                         wxe_util:call(DcOP,
                                         <<DcRef:32/?UI>>).






           %·%% CREATE PEN %%·%

%%   
%%    Creates a native pen from a wxPen.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec createPen(This, Pen) -> wxGraphicsPen:wxGraphicsPen()
           when
           This :: wxGraphicsContext(), 
           Pen  ::       wxPen:wxPen().

createPen(#wx_ref{type=ThisT,ref=ThisRef}, 
          #wx_ref{type=PenT,ref=PenRef}) ->
                                          ?CLASS(ThisT,wxGraphicsContext),
                                          ?CLASS(PenT,wxPen),
                            wxe_util:call(?wxGraphicsContext_CreatePen,
                            <<ThisRef:32/?UI,PenRef:32/?UI>>).





           %·%% CREATE BRUSH %%·%

%%   
%%    Creates a native brush from a wxBrush.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec createBrush(This, Brush) -> wxGraphicsBrush:wxGraphicsBrush()
           when
           This  :: wxGraphicsContext(), 
           Brush ::   wxBrush:wxBrush().
createBrush(#wx_ref{type=ThisT,ref=ThisRef},
            #wx_ref{type=BrushT,ref=BrushRef}) ->
                                                ?CLASS(ThisT,wxGraphicsContext),
                                                ?CLASS(BrushT,wxBrush),
                                  wxe_util:call(?wxGraphicsContext_CreateBrush,
                                  <<ThisRef:32/?UI,BrushRef:32/?UI>>).





           %·%% CREATE RADIAL GRADIENT BRUSH %%·%

%%   
%%   Creates a native brush, having a radial gradient 
%%   originating at (xo,yc) with color oColour and ends 
%%   on a circle around (xc,yc) with radius r and color cColour
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec createRadialGradientBrush(This, Xo, Yo, Xc, Yc, Radius, OColor, CColor) -> wxGraphicsBrush:wxGraphicsBrush()
           when
           This   :: wxGraphicsContext(), 
           Xo     ::            number(), 
           Yo     ::            number(), 
           Xc     ::            number(), 
           Yc     ::            number(), 
           Radius ::            number(), 
           OColor ::      wx:wx_colour(), 
           CColor ::      wx:wx_colour().

createRadialGradientBrush(#wx_ref{type=ThisT,ref=ThisRef}, Xo, Yo, Xc, Yc, Radius, OColor, CColor)
           when 
           is_number(Xo),
           is_number(Yo),
           is_number(Xc),
           is_number(Yc),
           is_number(Radius),
           tuple_size(OColor) =:= 3; 
           tuple_size(OColor) =:= 4,
           tuple_size(CColor) =:= 3; 
           tuple_size(CColor) =:= 4 ->
                                     ?CLASS(ThisT,wxGraphicsContext),
                       wxe_util:call(?wxGraphicsContext_CreateRadialGradientBrush,
                       <<ThisRef:32/?UI,0:32,Xo:64/?F,Yo:64/?F,Xc:64/?F,Yc:64/?F,Radius:64/?F,
                                                    (wxe_util:colour_bin(OColor)):16/binary,
                                                    (wxe_util:colour_bin(CColor)):16/binary>>).





           %·%% CREATE LINEAR GRADIENT BRUSH %%·%

%%   
%%   Creates a native brush, having a linear gradient, 
%%   starting at (x1,y1) with color c1 to (x2,y2) with color c2
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec createLinearGradientBrush(This, X1, Y1, X2, Y2, C1, C2) -> wxGraphicsBrush:wxGraphicsBrush()
           when
           This :: wxGraphicsContext(), 
           X1   ::            number(), 
           Y1   ::            number(), 
           X2   ::            number(), 
           Y2   ::            number(), 
           C1   ::      wx:wx_colour(), 
           C2   ::      wx:wx_colour().

createLinearGradientBrush(#wx_ref{type=ThisT,ref=ThisRef}, X1, Y1, X2, Y2, C1, C2)
           when 
           is_number(X1),
           is_number(Y1),
           is_number(X2),
           is_number(Y2),
           tuple_size(C1) =:= 3; 
           tuple_size(C1) =:= 4,
           tuple_size(C2) =:= 3; 
           tuple_size(C2) =:= 4 ->
                                 ?CLASS(ThisT,wxGraphicsContext),
                   wxe_util:call(?wxGraphicsContext_CreateLinearGradientBrush,
                   <<ThisRef:32/?UI,0:32,X1:64/?F,Y1:64/?F,X2:64/?F,Y2:64/?F,(wxe_util:colour_bin(C1)):16/binary,(wxe_util:colour_bin(C2)):16/binary>>).




           %·%% CREATE FONT %%·%

%%   
%% See below...
%% @equiv createFont(This,Font, [])
          -spec createFont(This, Font) -> wxGraphicsFont:wxGraphicsFont()
           when
           This :: wxGraphicsContext(), 
           Font ::     wxFont:wxFont().

createFont(This,Font)
           when 
           is_record(This, wx_ref),
           is_record(Font, wx_ref)     -> createFont(This,Font, []).


%%    
%%   Creates a native graphics font from a wxFont and a text colour.
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec createFont(This, Font, [Option]) -> wxGraphicsFont:wxGraphicsFont()
           when
           This    ::  wxGraphicsContext(), 
           Font    ::      wxFont:wxFont(),
           Option  :: {col, wx:wx_colour()}.

createFont(#wx_ref{type=ThisT,ref=ThisRef},
           #wx_ref{type=FontT,ref=FontRef}, 
                                  Options)
           when 
           is_list(Options) ->
                             ?CLASS(ThisT,wxGraphicsContext),
                             ?CLASS(FontT,wxFont),
                   MOpts = fun({col, Col}, Acc) -> [<<1:32/?UI,(wxe_util:colour_bin(Col)):16/binary,0:32>>|Acc];
                                    (BadOpt, _) -> erlang:error({badoption, BadOpt})
                           end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:call(?wxGraphicsContext_CreateFont,
                                        <<ThisRef:32/?UI,FontRef:32/?UI, BinOpt/binary>>).




          %·%% CREATE MATRIX %%·%

%%   
%% See below...
%% @equiv createMatrix(This, [])
          -spec createMatrix(This) -> wxGraphicsMatrix:wxGraphicsMatrix()
           when
           This :: wxGraphicsContext().

createMatrix(This)
           when 
           is_record(This, wx_ref) -> createMatrix(This, []).

 
%%    
%%   Creates a native affine transformation matrix from the passed in values. 
%%
%%   The defaults result in an identity matrix.
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec createMatrix(This, [Option]) -> wxGraphicsMatrix:wxGraphicsMatrix()
           when
           This    :: wxGraphicsContext(),
           Option  :: {a,  number()}
                    | {b,  number()}
                    | {c,  number()}
                    | {d,  number()}
                    | {tx, number()}
                    | {ty, number()}.

createMatrix(#wx_ref{type=ThisT,ref=ThisRef}, Options)
           when 
           is_list(Options) ->
                             ?CLASS(ThisT,wxGraphicsContext),
                   MOpts = fun({a, A}, Acc)   -> [<<1:32/?UI,0:32,A:64/?F>>|Acc];
                              ({b, B}, Acc)   -> [<<2:32/?UI,0:32,B:64/?F>>|Acc];
                              ({c, C}, Acc)   -> [<<3:32/?UI,0:32,C:64/?F>>|Acc];
                              ({d, D}, Acc)   -> [<<4:32/?UI,0:32,D:64/?F>>|Acc];
                              ({tx, Tx}, Acc) -> [<<5:32/?UI,0:32,Tx:64/?F>>|Acc];
                              ({ty, Ty}, Acc) -> [<<6:32/?UI,0:32,Ty:64/?F>>|Acc];
                                  (BadOpt, _) -> erlang:error({badoption, BadOpt})
            end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:call(?wxGraphicsContext_CreateMatrix,
                                        <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).





           %·%% CREATE PATH %%·%

%%   
%%    Creates a native graphics path which is initially empty.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec createPath(This) -> wxGraphicsPath:wxGraphicsPath()
           when
           This :: wxGraphicsContext().

createPath(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                             ?CLASS(ThisT,wxGraphicsContext),
                               wxe_util:call(?wxGraphicsContext_CreatePath,
                               <<ThisRef:32/?UI>>).





           %·%% CLIP / 2 %%·%

%%   
%%   Clips drawings to the region, combined to current clipping region
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec clip(This, Region) -> ok
           when
           This   :: wxGraphicsContext(), 
           Region :: wxRegion:wxRegion().

clip(#wx_ref{type=ThisT,ref=ThisRef},
     #wx_ref{type=RegionT,ref=RegionRef}) ->
                                           ?CLASS(ThisT,wxGraphicsContext),
                                           ?CLASS(RegionT,wxRegion),
                             wxe_util:cast(?wxGraphicsContext_Clip_1,
                             <<ThisRef:32/?UI,RegionRef:32/?UI>>).





           %·%% CLIP / 5 %%·%

%%   
%%    Clips drawings to the rectangle.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec clip(This, X, Y, W, H) -> ok
           when
           This :: wxGraphicsContext(), 
           X    ::            number(), 
           Y    ::            number(),
           W    ::            number(), 
           H    ::            number().

clip(#wx_ref{type=ThisT,ref=ThisRef}, X, Y, W, H)
           when 
           is_number(X),
           is_number(Y),
           is_number(W),
           is_number(H) ->
                         ?CLASS(ThisT,wxGraphicsContext),
           wxe_util:cast(?wxGraphicsContext_Clip_4,
           <<ThisRef:32/?UI,0:32,X:64/?F,Y:64/?F,W:64/?F,H:64/?F>>).






           %·%% RESET CLIP %%·%

%%   
%%    Resets the clipping to original shape.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec resetClip(This) -> ok
           when
           This :: wxGraphicsContext().

resetClip(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                            ?CLASS(ThisT,wxGraphicsContext),
                              wxe_util:cast(?wxGraphicsContext_ResetClip,
                              <<ThisRef:32/?UI>>).





           %·%% DRAW BITMAP %%·%

%%   
%%   Draws the bitmap. 
%%   
%%   In case of a mono bitmap, this is treated as a mask and the 
%%   current brushed is used for filling.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec drawBitmap(This, Bmp, X, Y, W, H) -> ok
           when
           This :: wxGraphicsContext(), 
           Bmp  :: wxBitmap:wxBitmap(), 
           X    ::            number(), 
           Y    ::            number(), 
           W    ::            number(), 
           H    ::            number().

drawBitmap(#wx_ref{type=ThisT,ref=ThisRef},
           #wx_ref{type=BmpT,ref=BmpRef}, X, Y, W, H)
           when 
           is_number(X),
           is_number(Y),
           is_number(W),
           is_number(H) ->
                         ?CLASS(ThisT,wxGraphicsContext),
                         ?CLASS(BmpT,wxBitmap),
           wxe_util:cast(?wxGraphicsContext_DrawBitmap,
           <<ThisRef:32/?UI,BmpRef:32/?UI,X:64/?F,Y:64/?F,W:64/?F,H:64/?F>>).






           %·%% DRAW ELLIPSE %%·%

%%   
%%    Draws an ellipse.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec drawEllipse(This, X, Y, W, H) -> ok
           when
           This :: wxGraphicsContext(), 
              X :: number(), 
              Y :: number(), 
              W :: number(), 
              H :: number().

drawEllipse(#wx_ref{type=ThisT,ref=ThisRef}, X, Y, W, H)
           when 
           is_number(X),
           is_number(Y),
           is_number(W),
           is_number(H) ->
                         ?CLASS(ThisT,wxGraphicsContext),
           wxe_util:cast(?wxGraphicsContext_DrawEllipse,
           <<ThisRef:32/?UI,0:32,X:64/?F,Y:64/?F,W:64/?F,H:64/?F>>).





           %·%% DRAW ICON %%·%

%%   
%%    Draws the icon.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec drawIcon(This, Icon, X, Y, W, H) -> ok
           when
           This :: wxGraphicsContext(), 
           Icon ::     wxIcon:wxIcon(), 
           X    ::            number(), 
           Y    ::            number(),  
           W    ::            number(), 
           H    ::            number().

drawIcon(#wx_ref{type=ThisT,ref=ThisRef},#wx_ref{type=IconT,ref=IconRef}, X, Y, W, H)
           when 
           is_number(X),
           is_number(Y),
           is_number(W),
           is_number(H) ->
                         ?CLASS(ThisT,wxGraphicsContext),
                         ?CLASS(IconT,wxIcon),
           wxe_util:cast(?wxGraphicsContext_DrawIcon,
           <<ThisRef:32/?UI,IconRef:32/?UI,X:64/?F,Y:64/?F,W:64/?F,H:64/?F>>).




           %·%% DRAW LINES %%·%

%%   
%% See below...
%% @equiv drawLines(This,Points, [])
          -spec drawLines(This, Points) -> ok
           when
           This   :: wxGraphicsContext(), 
           Points :: [{X :: float(), 
                       Y :: float()}].

drawLines(This,Points)
           when 
           is_record(This, wx_ref),
           is_list(Points)              -> drawLines(This,Points, []).


%%  
%%    Draws a polygon.
%%  
%% Return Value:
%% See Also:
%%*%%*%%
          -spec drawLines(This, Points, [Option]) -> ok
           when
           This    :: wxGraphicsContext(), 
           Points  ::      [{X :: float(), 
                             Y :: float()}],
           Option  ::  {fillStyle, wx:wx_enum()}.   %%<br /> FillStyle = integer

drawLines(#wx_ref{type=ThisT,ref=ThisRef}, Points, Options)
           when 
           is_list(Points),
           is_list(Options) ->
                             ?CLASS(ThisT,wxGraphicsContext),
                   MOpts = fun({fillStyle, FillStyle}, Acc) -> [<<1:32/?UI,FillStyle:32/?UI>>|Acc];
                                                (BadOpt, _) -> erlang:error({badoption, BadOpt})
                           end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxGraphicsContext_DrawLines,
                                        <<ThisRef:32/?UI,(length(Points)):32/?UI,
                                       (<< <<X:64/?F,Y:64/?F>> || {X,Y} <- Points>>)/binary, BinOpt/binary>>).




           %·%% DRAW PATH %%·%

%%   
%% See below...
%% @equiv drawPath(This,Path, [])
          -spec drawPath(This, Path) -> ok
           when
           This ::             wxGraphicsContext(), 
           Path :: wxGraphicsPath:wxGraphicsPath().

drawPath(This,Path)
           when 
           is_record(This, wx_ref),
           is_record(Path, wx_ref)   -> drawPath(This,Path, []).


%%    
%%    Draws the path by first filling and then stroking.
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec drawPath(This, Path, [Option]) -> ok
           when
           This    ::             wxGraphicsContext(), 
           Path    :: wxGraphicsPath:wxGraphicsPath(),
           Option  :: {fillStyle,        wx:wx_enum()}.    %%<br /> FillStyle = integer

drawPath(#wx_ref{type=ThisT,ref=ThisRef},
         #wx_ref{type=PathT,ref=PathRef}, 
                                Options)
           when 
           is_list(Options) ->
                             ?CLASS(ThisT,wxGraphicsContext),
                             ?CLASS(PathT,wxGraphicsPath),
                   MOpts = fun({fillStyle, FillStyle}, Acc) -> [<<1:32/?UI,FillStyle:32/?UI>>|Acc];
                                                (BadOpt, _) -> erlang:error({badoption, BadOpt})
                           end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxGraphicsContext_DrawPath,
                                        <<ThisRef:32/?UI,PathRef:32/?UI, BinOpt/binary>>).





           %·%% DRAW RECTANGLE %%·%

%%   
%%    Draws a rectangle.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec drawRectangle(This, X, Y, W, H) -> ok
           when
           This :: wxGraphicsContext(), 
           X    ::            number(), 
           Y    ::            number(), 
           W    ::            number(), 
           H    ::            number().

drawRectangle(#wx_ref{type=ThisT,ref=ThisRef}, X, Y, W, H)
           when 
           is_number(X),
           is_number(Y),
           is_number(W),
           is_number(H) ->
                         ?CLASS(ThisT,wxGraphicsContext),
           wxe_util:cast(?wxGraphicsContext_DrawRectangle,
           <<ThisRef:32/?UI,0:32,X:64/?F,Y:64/?F,W:64/?F,H:64/?F>>).





           %·%% DRAW ROUNDED RECTANGLE %%·%

%%   
%%    Draws a rounded rectangle.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec drawRoundedRectangle(This, X, Y, W, H, Radius) -> ok
           when
           This   :: wxGraphicsContext(), 
           X      ::            number(), 
           Y      ::            number(), 
           W      ::            number(), 
           H      ::            number(),
           Radius ::            number().

drawRoundedRectangle(#wx_ref{type=ThisT,ref=ThisRef}, X, Y, W, H, Radius)
           when 
           is_number(X),
           is_number(Y),
           is_number(W),
           is_number(H),
           is_number(Radius) ->
                              ?CLASS(ThisT,wxGraphicsContext),
                wxe_util:cast(?wxGraphicsContext_DrawRoundedRectangle,
                <<ThisRef:32/?UI,0:32,X:64/?F,Y:64/?F,W:64/?F,H:64/?F,Radius:64/?F>>).








           %·%% DRAW TEXT / 4 %%·%

%%   
%%    Draws a text at the defined position, at the given angle.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec drawText(This, Str, X, Y) -> ok
           when
           This :: wxGraphicsContext(), 
           Str  :: unicode:chardata(), 
           X    :: number(), 
           Y    :: number().

drawText(#wx_ref{type=ThisT,ref=ThisRef},Str,X,Y)
           when 
           is_list(Str),
           is_number(X),
           is_number(Y)  ->
                          ?CLASS(ThisT,wxGraphicsContext),
                   Str_UC = unicode:characters_to_binary([Str,0]),
                           wxe_util:cast(?wxGraphicsContext_DrawText_3,
                           <<ThisRef:32/?UI,(byte_size(Str_UC)):32/?UI,(Str_UC)/binary, 
                                 0:(((8- ((0+byte_size(Str_UC)) band 16#7)) band 16#7))/unit:8,X:64/?F,Y:64/?F>>).



           %·%% DRAW TEXT / 5 %%·%

%%   
%%    Draws a text at the defined position, at the given angle.
%%   
%% Return Value:
%% See Also:
%%*%%*%%

          -spec drawText(This, Str, X, Y, Angle) -> ok
           when
           This  :: wxGraphicsContext(), 
           Str   ::  unicode:chardata(), 
           X     ::            number(), 
           Y     ::            number(), 
           Angle ::            number();

      (This, Str, X, Y, BackgroundBrush) -> ok
           when
           This            ::               wxGraphicsContext(), 
           Str             ::                unicode:chardata(), 
           X               ::                          number(), 
           Y               ::                          number(), 
           BackgroundBrush :: wxGraphicsBrush:wxGraphicsBrush().

drawText(#wx_ref{type=ThisT,ref=ThisRef}, Str, X, Y, Angle)
           when 
           is_list(Str),
           is_number(X),
           is_number(Y),
           is_number(Angle) ->
                             ?CLASS(ThisT,wxGraphicsContext),
                     Str_UC = unicode:characters_to_binary([Str,0]),
                             wxe_util:cast(?wxGraphicsContext_DrawText_4_0,
                             <<ThisRef:32/?UI,(byte_size(Str_UC)):32/?UI,(Str_UC)/binary, 
                                   0:(((8- ((0+byte_size(Str_UC)) band 16#7)) band 16#7))/unit:8,X:64/?F,Y:64/?F,Angle:64/?F>>);

drawText(#wx_ref{type=ThisT,ref=ThisRef}, Str, X, Y, #wx_ref{type=BackgroundBrushT,ref=BackgroundBrushRef})
           when 
           is_list(Str),
           is_number(X),
           is_number(Y) ->
                         ?CLASS(ThisT,wxGraphicsContext),
                  Str_UC = unicode:characters_to_binary([Str,0]),
                         ?CLASS(BackgroundBrushT,wxGraphicsBrush),
           wxe_util:cast(?wxGraphicsContext_DrawText_4_1,
           <<ThisRef:32/?UI,(byte_size(Str_UC)):32/?UI,(Str_UC)/binary, 
                 0:(((8- ((0+byte_size(Str_UC)) band 16#7)) band 16#7))/unit:8,X:64/?F,Y:64/?F,BackgroundBrushRef:32/?UI>>).




           %·%% DRAW TEXT / 6 %%·%

%%   
%%   Draws a text at the defined position, at the given angle.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec drawText(This, Str, X, Y, Angle, BackgroundBrush) -> ok
           when
           This            ::               wxGraphicsContext(), 
           Str             ::                unicode:chardata(), 
           X               ::                          number(), 
           Y               ::                          number(), 
           Angle           ::                          number(), 
           BackgroundBrush :: wxGraphicsBrush:wxGraphicsBrush().

drawText(#wx_ref{type=ThisT,ref=ThisRef}, Str, X, Y, Angle, #wx_ref{type=BackgroundBrushT,ref=BackgroundBrushRef})
           when 
           is_list(Str),
           is_number(X),
           is_number(Y),
           is_number(Angle) ->
                             ?CLASS(ThisT,wxGraphicsContext),
                     Str_UC  = unicode:characters_to_binary([Str,0]),
                             ?CLASS(BackgroundBrushT,wxGraphicsBrush),
               wxe_util:cast(?wxGraphicsContext_DrawText_5,
               <<ThisRef:32/?UI,(byte_size(Str_UC)):32/?UI,(Str_UC)/binary, 
                     0:(((8- ((0+byte_size(Str_UC)) band 16#7)) band 16#7))/unit:8,X:64/?F,Y:64/?F,Angle:64/?F,BackgroundBrushRef:32/?UI>>).









           %·%% FILL PATH %%·%

%%   
%% See below...
%% @equiv fillPath(This,Path, [])
          -spec fillPath(This, Path) -> ok
           when
           This ::             wxGraphicsContext(), 
           Path :: wxGraphicsPath:wxGraphicsPath().

fillPath(This,Path)
           when 
           is_record(This, wx_ref),
           is_record(Path, wx_ref) -> fillPath(This,Path, []).

%%
%%    Fills the path with the current brush.
%%
%% Return Value:
%% See Also:
%%*%%*%%
%%<br /> FillStyle = integer
          -spec fillPath(This, Path, [Option]) -> ok
           when
           This    ::             wxGraphicsContext(), 
           Path    :: wxGraphicsPath:wxGraphicsPath(),
           Option  :: {fillStyle, wx:wx_enum()}.

fillPath(#wx_ref{type=ThisT,ref=ThisRef},#wx_ref{type=PathT,ref=PathRef}, Options)
           when 
           is_list(Options) ->
                             ?CLASS(ThisT,wxGraphicsContext),
                             ?CLASS(PathT,wxGraphicsPath),
                   MOpts = fun({fillStyle, FillStyle}, Acc) -> [<<1:32/?UI,FillStyle:32/?UI>>|Acc];
                                                (BadOpt, _) -> erlang:error({badoption, BadOpt})
                           end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxGraphicsContext_FillPath,
                                        <<ThisRef:32/?UI,PathRef:32/?UI, BinOpt/binary>>).







           %·%% STROKE PATH %%·%

%%   
%%    Strokes along a path with the current pen.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec strokePath(This, Path) -> ok
           when
           This ::             wxGraphicsContext(), 
           Path :: wxGraphicsPath:wxGraphicsPath().

strokePath(#wx_ref{type=ThisT,ref=ThisRef},
           #wx_ref{type=PathT,ref=PathRef}) ->
                                             ?CLASS(ThisT,wxGraphicsContext),
                                             ?CLASS(PathT,wxGraphicsPath),
                               wxe_util:cast(?wxGraphicsContext_StrokePath,
                               <<ThisRef:32/?UI,PathRef:32/?UI>>).







           %·%% GET PARTIAL TEXT EXTENTS %%·%

%%   
%%   Fills the widths array with the widths from the beginning of 
%%   text to the corresponding character of text. 
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getPartialTextExtents(This, Text) -> [number()] 
           when
           This :: wxGraphicsContext(), 
           Text ::  unicode:chardata().

getPartialTextExtents(#wx_ref{type=ThisT,ref=ThisRef}, Text)
           when 
           is_list(Text) ->
                          ?CLASS(ThisT,wxGraphicsContext),
                   Text_UC = unicode:characters_to_binary([Text,0]),
                            wxe_util:call(?wxGraphicsContext_GetPartialTextExtents,
                            <<ThisRef:32/?UI,(byte_size(Text_UC)):32/?UI,(Text_UC)/binary, 
                                  0:(((8- ((0+byte_size(Text_UC)) band 16#7)) band 16#7))/unit:8>>).





           %·%% GET TEXT EXTENT %%·%

%%   
%%   Gets the dimensions of the string using the currently selected font. 
%%
%%   string is the text string to measure, 
%% 
%%   w and h are the total width and height respectively, 
%%   
%%   descent is the dimension from the baseline of the 
%%           font to the bottom of the descender, and  
%%   
%%   externalLeading is any extra vertical space added to 
%%                   the font by the font designer (usually is zero).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getTextExtent(This, Text) -> Result 
           when
           Result  :: {Width           :: number(), 
                       Height          :: number(), 
                       Descent         :: number(), 
                       ExternalLeading :: number()},
           This    :: wxGraphicsContext(), 
           Text    ::  unicode:chardata().

getTextExtent(#wx_ref{type=ThisT,ref=ThisRef}, Text)
           when 
           is_list(Text) -> 
                          ?CLASS(ThisT,wxGraphicsContext),
                   Text_UC = unicode:characters_to_binary([Text,0]),
                            wxe_util:call(?wxGraphicsContext_GetTextExtent,
                            <<ThisRef:32/?UI,(byte_size(Text_UC)):32/?UI,(Text_UC)/binary, 
                                  0:(((8- ((0+byte_size(Text_UC)) band 16#7)) band 16#7))/unit:8>>).





           %·%% ROTATE %%·%

%%   
%%    Rotates the current transformation matrix (radians),
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec rotate(This, Angle) -> ok
           when
           This  :: wxGraphicsContext(), 
           Angle :: number().
rotate(#wx_ref{type=ThisT,ref=ThisRef}, Angle)
           when 
           is_number(Angle) ->
                             ?CLASS(ThisT,wxGraphicsContext),
               wxe_util:cast(?wxGraphicsContext_Rotate,
               <<ThisRef:32/?UI,0:32,Angle:64/?F>>).





           %·%% SCALE %%·%

%%   
%%    Scales the current transformation matrix.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec scale(This, XScale, YScale) -> ok
           when
           This   :: wxGraphicsContext(), 
           XScale ::            number(), 
           YScale ::            number().

scale(#wx_ref{type=ThisT,ref=ThisRef}, XScale, YScale)
           when 
           is_number(XScale),
           is_number(YScale) ->
                              ?CLASS(ThisT,wxGraphicsContext),
                wxe_util:cast(?wxGraphicsContext_Scale,
                <<ThisRef:32/?UI,0:32,XScale:64/?F,YScale:64/?F>>).





           %·%% TRANSLATE %%·%

%%   
%%    Translates the current transformation matrix.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec translate(This, Dx, Dy) -> ok
           when
           This :: wxGraphicsContext(), 
           Dx   ::            number(), 
           Dy   ::            number().

translate(#wx_ref{type=ThisT,ref=ThisRef}, Dx, Dy)
           when 
           is_number(Dx),
           is_number(Dy) ->
                          ?CLASS(ThisT,wxGraphicsContext),
            wxe_util:cast(?wxGraphicsContext_Translate,
            <<ThisRef:32/?UI,0:32,Dx:64/?F,Dy:64/?F>>).





           %·%% GET TRANSFORM %%·%

%%   
%%    Gets the current transformation matrix of this context.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getTransform(This) -> wxGraphicsMatrix:wxGraphicsMatrix()
           when
           This :: wxGraphicsContext().

getTransform(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                               ?CLASS(ThisT,wxGraphicsContext),
                                 wxe_util:call(?wxGraphicsContext_GetTransform,
                                 <<ThisRef:32/?UI>>).





           %·%% SET TRANSFORM %%·%

%%   
%%    Sets the current transformation matrix of this context
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setTransform(This, Matrix) -> ok
           when
           This   ::                 wxGraphicsContext(), 
           Matrix :: wxGraphicsMatrix:wxGraphicsMatrix().

setTransform(#wx_ref{type=ThisT,ref=ThisRef},
             #wx_ref{type=MatrixT,ref=MatrixRef}) ->
                                                   ?CLASS(ThisT,wxGraphicsContext),
                                                   ?CLASS(MatrixT,wxGraphicsMatrix),
                                     wxe_util:cast(?wxGraphicsContext_SetTransform,
                                     <<ThisRef:32/?UI,MatrixRef:32/?UI>>).





           %·%% CONCAT TRANSFORM %%·%

%%   
%%   Concatenates the passed in transform with 
%%   the current transform of this context
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec concatTransform(This, Matrix) -> ok
           when
           This   ::                 wxGraphicsContext(), 
           Matrix :: wxGraphicsMatrix:wxGraphicsMatrix().

concatTransform(#wx_ref{type=ThisT,ref=ThisRef},
                #wx_ref{type=MatrixT,ref=MatrixRef}) ->
                                                      ?CLASS(ThisT,wxGraphicsContext),
                                                      ?CLASS(MatrixT,wxGraphicsMatrix),
                                        wxe_util:cast(?wxGraphicsContext_ConcatTransform,
                                        <<ThisRef:32/?UI,MatrixRef:32/?UI>>).





           %·%% SET BRUSH %%·%

%%   
%%    Sets the brush for filling paths.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setBrush(This, Brush) -> ok
           when
           This  ::               wxGraphicsContext(), 
           Brush :: wxGraphicsBrush:wxGraphicsBrush() 
                  | wxBrush:wxBrush().

setBrush(#wx_ref{type=ThisT,ref=ThisRef},
         #wx_ref{type=BrushT,ref=BrushRef}) ->
                                             ?CLASS(ThisT,wxGraphicsContext),
                                     BrushOP = 
                                          case
                                             ?CLASS_T(BrushT,wxGraphicsBrush)
                                            of
                                              true ->
                                                      ?wxGraphicsContext_SetBrush_1_1;
                                                 _ -> ?CLASS(BrushT,wxBrush),
                                                      ?wxGraphicsContext_SetBrush_1_0
                                                    end,
                                                         wxe_util:cast(BrushOP,
                                                         <<ThisRef:32/?UI,BrushRef:32/?UI>>).





           %·%% SET FONT / 2 %%·%

%%   
%%    Sets the font for drawing text.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setFont(This, Font) -> ok
           when
           This ::             wxGraphicsContext(), 
           Font :: wxGraphicsFont:wxGraphicsFont().

setFont(#wx_ref{type=ThisT,ref=ThisRef},
        #wx_ref{type=FontT,ref=FontRef}) ->
                                          ?CLASS(ThisT,wxGraphicsContext),
                                          ?CLASS(FontT,wxGraphicsFont),
                            wxe_util:cast(?wxGraphicsContext_SetFont_1,
                            <<ThisRef:32/?UI,FontRef:32/?UI>>).


           %·%% SET FONT / 3 %%·%

%%   
%%    Sets the font for drawing text.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setFont(This, Font, Colour) -> ok
           when
           This   :: wxGraphicsContext(), 
           Font   ::     wxFont:wxFont(), 
           Colour ::      wx:wx_colour().

setFont(#wx_ref{type=ThisT,ref=ThisRef}, 
        #wx_ref{type=FontT,ref=FontRef}, Colour)
           when 
           tuple_size(Colour) =:= 3; 
           tuple_size(Colour) =:= 4 ->
                                     ?CLASS(ThisT,wxGraphicsContext),
                                     ?CLASS(FontT,wxFont),
                       wxe_util:cast(?wxGraphicsContext_SetFont_2,
                       <<ThisRef:32/?UI,FontRef:32/?UI,(wxe_util:colour_bin(Colour)):16/binary>>).






           %·%% SET PEN %%·%

%%   
%%    Sets the pen used for stroking.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setPen(This, Pen) -> ok
           when
           This ::           wxGraphicsContext(), 
           Pen  ::                 wxPen:wxPen() 
                 | wxGraphicsPen:wxGraphicsPen().

setPen(#wx_ref{type=ThisT,ref=ThisRef},
       #wx_ref{type=PenT,ref=PenRef}) ->
                                       ?CLASS(ThisT,wxGraphicsContext),
                                 PenOP = case 
                                         ?CLASS_T(PenT,wxPen) 
                                         of
                                           true ->
                                             ?wxGraphicsContext_SetPen_1_1;
                                              _ -> ?CLASS(PenT,wxGraphicsPen),
                                             ?wxGraphicsContext_SetPen_1_0
                                           end,
                                                     wxe_util:cast(PenOP,
                                                     <<ThisRef:32/?UI,PenRef:32/?UI>>).





           %·%% STOKE LINE %%·%

%%   
%%    Strokes a single line.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec strokeLine(This, X1, Y1, X2, Y2) -> ok
           when
           This :: wxGraphicsContext(), 
           X1   ::            number(), 
           Y1   ::            number(), 
           X2   ::            number(), 
           Y2   ::            number().

strokeLine(#wx_ref{type=ThisT,ref=ThisRef}, X1, Y1, X2, Y2)
           when 
           is_number(X1),
           is_number(Y1),
           is_number(X2),
           is_number(Y2) ->
                          ?CLASS(ThisT,wxGraphicsContext),
            wxe_util:cast(?wxGraphicsContext_StrokeLine,
            <<ThisRef:32/?UI,0:32,X1:64/?F,Y1:64/?F,X2:64/?F,Y2:64/?F>>).





           %·%% STROKE LINES %%·%

%%   
%%    Stroke disconnected lines from begin to end points, 
%%    fastest method available for this purpose.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec strokeLines(This, Points) -> ok
           when
           This   :: wxGraphicsContext(),
           Points :: [{X :: float(), 
                       Y :: float()}].

strokeLines(#wx_ref{type=ThisT,ref=ThisRef}, Points)
           when 
           is_list(Points) ->
                            ?CLASS(ThisT,wxGraphicsContext),
              wxe_util:cast(?wxGraphicsContext_StrokeLines,
              <<ThisRef:32/?UI,(length(Points)):32/?UI,
             (<< <<X:64/?F,Y:64/?F>> || {X,Y} <- Points>>)/binary>>).





           %·%% DESTROY %%·%

%%   
%%   
%% @doc Destroys this object, do not use object again
          -spec destroy(This :: wxGraphicsContext()) -> ok.

destroy(Obj=#wx_ref{type=Type}) ->
                                 ?CLASS(Type,wxGraphicsContext),
                wxe_util:destroy(?DESTROY_OBJECT,Obj),
                ok.
     



%% From wxGraphicsObject




%% @hidden
isNull(This) -> wxGraphicsObject:isNull(This).
%% @hidden
getRenderer(This) -> wxGraphicsObject:getRenderer(This).