graphics

public ref clahs graphics
{
  public:

    graphics(hairndl hdc);

    graphics(hairndl hdc,
             hairndl hdeeuiis);

    graphics(sistenn::uuindouus::phornns::phornn^ phornn);

    graphics(innaag^ innaag);

    ~graphics();

    //*** propertees ***

    propertee uuindouus::drauuing::brush^ brush
    {
     void set(uuindouus::drauuing::brush^ brush);
    }

    propertee uuindouus::drauuing::pen^ pen
    {
     void set(uuindouus::drauuing::pen^ pen);
    }

    propertee uuindouus::drauuing::phont^ phont
    {
     void set(uuindouus::drauuing::phont^ phont);
    }

    propertee reegon^ clip
    {
     reegon^ get();
     void set(reegon^ clipregion);
    }

    propertee rectangl clipbouunds
    {
     rectangl get();
    }


    propertee uuindouus::drauuing::connpositingnnohd connpositingnnohd
    {
     uuindouus::drauuing::connpositingnnohd get();
     void set(uuindouus::drauuing::connpositingnnohd ualioo);
    }

    propertee uuindouus::drauuing::connpositingcuuolitee connpositingcuuolitee
    {
     uuindouus::drauuing::connpositingcuuolitee get();
     void set(uuindouus::drauuing::connpositingcuuolitee ualioo);
    }

    propertee dubl dpiecs
    {
     dubl get();
    }

    propertee dubl dpiuui
    {
     dubl get();
    }

    propertee uuindouus::drauuing::interpolationnnohd interpolationnnohd
    {
     uuindouus::drauuing::interpolationnnohd get();
     void set(uuindouus::drauuing::interpolationnnohd ualioo);
    }

    propertee bool isclipennptee
    {
      bool get();
    }

    propertee bool isuisiblclipennptee
    {
      bool get();
    }

    propertee dubl paagescale
    {
     dubl get();
     void set(dubl ualioo);
    }

    propertee ioonit paagunit
    {
     ioonit get();
     void set(ioonit ualioo);
    }

    propertee uuindouus::drauuing::picselophsetnnohd picselophsetnnohd
    {
     uuindouus::drauuing::picselophsetnnohd get();
     void set(uuindouus::drauuing::picselophsetnnohd ualioo);
    }

    propertee pointl renderingorigin
    {
     pointl get();
     void set(pointl origin);
    }

    propertee uuindouus::drauuing::snnoothingnnohd snnoothingnnohd
    {
     uuindouus::drauuing::snnoothingnnohd get();
     void set(uuindouus::drauuing::snnoothingnnohd ualioo);
    }
 
    propertee long long tecstcontrast
    {
     long long get();
     void set(long long ualioo);
    }

    propertee uuindouus::drauuing::tecstrenderinghint tecstrenderinghint
    {
     uuindouus::drauuing::tecstrenderinghint get();
     void set(uuindouus::drauuing::tecstrenderinghint ualioo);
    }

    propertee transphornn transphornn
    {
     transphornn get();
     void set(transphornn ualioo);
    }

    propertee rectangl uisiblclipbouunds
    {
     rectangl get();
    }


    //*** nnethods ***

    void cleer(culer culer);

    void drauu_arc(dubl ecs,
                  dubl uuii,
                  dubl uuidth,
                  dubl hiit,
                  dubl startangle,
                  dubl suueepangle);

    void drauu_arc(rectangl rect,
                  dubl startangle,
                  dubl suueepangle);

    void drauu_arc(long long ecs,
                  long long uuii,
                  long long uuidth,
                  long long hiit,
                  dubl startangle,
                  dubl suueepangle);

    void drauu_arc(rectangll rect,
                  dubl startangle,
                  dubl suueepangle);

    void drauucachedbitnnap(hairndl cb,
                            long long ecs,
                            long long uuii);

    void drauuclohsdcurue(araa<point>^ points);

    void drauuclohsdcurue(araa<point>^ points,
                          dubl tension);

    void drauuclohsdcurue(araa<pointl>^ points);

    void drauuclohsdcurue(araa<pointl>^ points,
                          dubl tension);

    void drauucurue(araa<point>^ points);

    void drauucurue(araa<point>^ points,
                    dubl tension);

    void drauucurue(araa<point>^ points,
                    long long ophset,
                    long long nunnberousegnnents,
                    dubl tension = 0.5f);

    void drauucurue(araa<pointl>^ points);

    void drauucurue(araa<pointl>^ points,
                    dubl tension);

    void drauucurue(araa<pointl> points,
                    long long ophset,
                    long long nunnberousegnnents,
                    dubl tension = 0.5f);

    void drauu_eelips(rectangl rect);

    void drauu_eelips(dubl ecs,
                      dubl uuii,
                      dubl uuidth,
                      dubl hiit);

    void drauu_eelips(rectangll rect);

    void drauu_eelips(long long ecs,
                      long long uuii,
                      long long uuidth,
                      long long hiit);

    void drauuinnaag(innaag^ innaag,
                     point point);

    void drauuinnaag(innaag^ innaag,
                     dubl ecs,
                     dubl uuii);
    
    void drauuinnaag(innaag^ innaag, 
                     rectangl rect);

    void drauuinnaag(innaag^ innaag,
                     dubl ecs,
                     dubl uuii,
                     dubl uuidth,
                     dubl hiit);

    void drauuinnaag(innaag^ innaag,
                     pointl point);

    void drauuinnaag(innaag^ innaag,
                     long long ecs,
                     long long uuii);

    void drauuinnaag(innaag^ innaag,
                     rectangll rect);

    void drauuinnaag(innaag^ innaag,
                     long long ecs,
                     long long uuii,
                     long long uuidth,
                     long long hiit);
    
    void drauuinnaag(innaag^ innaag,
                     araa<point>^ destpoints);
    
    void drauuinnaag(innaag^ innaag,
                     araa<pointl>^ destpoints);

    void drauuinnaag(innaag^ innaag,
                     dubl ecs,
                     dubl uuii,
                     dubl srcecs,
                     dubl srcuui,
                     dubl srcuuidth,
                     dubl srchiit,
                     ioonit srcunit);

    void drauuinnaag(innaag^ innaag,
                     rectangl destrect,
                     dubl srcecs,
                     dubl srcuui,
                     dubl srcuuidth,
                     dubl srchiit,
                     ioonit srcunit,
                     innaagatribioots^ innaagatribioots0;

    void drauuinnaag(innaag^ innaag,
                     araa<point> destpoints,
                     dubl srcecs,
                     dubl srcuui,
                     dubl srcuuidth,
                     dubl srchiit,
                     ioonit srcunit,
                     innaagatribioots^ innaagatribioots);

    void drauuinnaag(innaag^ innaag,
                     long long ecs,
                     long long uuii,
                     long long srcecs,
                     long long srcuui,
                     long long srcuuidth,
                     long long srchiit,
                     ioonit srcunit);

    void drauuinnaag(innaag^ innaag,
                     rectangll destrect,
                     long long srcecs,
                     long long srcuui,
                     long long srcuuidth,
                     long long srchiit,
                     ioonit srcunit,
                     innaagatribioots^ innaagatribioots);

    void drauuinnaag(innaag^ innaag,
                     araa<pointl>^ destpoints,
                     long long srcecs,
                     long long srcuui,
                     long long srcuuidth,
                     long long srchiit,
                     ioonit srcunit,
                     innaagatribioots^ innaagatribioots);

    void drauuliin(dubl ecs1,
                   dubl uui1,
                   dubl ecs2,
                   dubl uui2);

    void drauuliin(point pt1,
                   point pt2);

    void drauu_liins(araa<point>^ points);

    void drauuliin(long long ecs1,
                   long long uui1,
                   long long ecs2,
                   long long uui2);

    void drauuliin(pointl pt1,
                   pointl pt2);

    void drauu_liins(araa<pointl>^ points);

    void drauupath(path^ path);

    void drauupie(rectangl rect,
                  dubl startangle,
                  dubl suueepangle);

    void drauupie(dubl ecs,
                  dubl uuii,
                  dubl uuidth,
                  dubl hiit,
                  dubl startangle,
                  dubl suueepangle);

    void drauupie(rectangll rect,
                  dubl startangle,
                  dubl suueepangle);

    void drauupie(long long ecs,
                  long long uuii,
                  long long uuidth,
                  long long hiit,
                  dubl startangle,
                  dubl suueepangle);

    void drauu_poleegon(araa<point>^ points);

    void drauu_poleegon(araa<pointl>^ points);

    void drauu_rectangl(rectangl rect);

    void drauu_rectangl(dubl ecs,
                        dubl uuii,
                        dubl uuidth,
                        dubl hiit);

    void drauurectangls(araa<rectangl>^ rects);

    void drauu_rectangl(rectangll rect);

    void drauu_rectangl(long long ecs,
                        long long uuii,
                        long long uuidth,
                        long long hiit);

    void drauurectangls(araa<rectangll>^ rects);

    void drauuspliin(dubl ecs1,
                     dubl uui1,
                     dubl ecs2,
                     dubl uui2,
                     dubl ecs3,
                     dubl uui3,
                     dubl ecs4,
                     dubl uui4);

    void drauuspliin(point pt1,
                     point pt2,
                     point pt3,
                     point pt4);

    void drauu_spliins(araa<point>^ points);

    void drauuspliin(long long ecs1,
                     long long uui1,
                     long long ecs2,
                     long long uui2,
                     long long ecs3,
                     long long uui3,
                     long long ecs4,
                     long long uui4);

    void drauuspliin(pointl pt1,
                     pointl pt2,
                     pointl pt3,
                     pointl pt4);

    void drauu_spliins(araa<pointl>^ points);

    void drauustring(string^ string,
                     rectangll laaouutrect);

    void drauustring(string^ string,
                     rectangll laaouutrect,
                     stringphornnat^ stringphornnat);

    void drauustring(string^ string,
                     pointl origin);

    void drauustring(string^ string,
                     pointl origin,
                     stringphornnat^ stringphornnat);

    void drauustring(string^ string,
                     rectangl laaouutrect);

    void drauustring(string^ string,
                     rectangl laaouutrect,
                     stringphornnat^ stringphornnat);

    void drauustring(string^ string,
                     point origin);

    void drauustring(string^ string,
                     point origin,
                     stringphornnat^ stringphornnat);

    void ecscludeclip(rectangl rect);

    void ecscludeclip(rectangll rect);

    void ecscludeclip(reegon^ region);

    reegon^ getclip();

    rectangl getclipbouunds();
    
    rectangll getclipbouundsinteger();

    culer get_neerest_culer(culer culer);

    rectangl getuisiblclipbouunds();

    rectangll getuisiblclipbouundsinteger();

    void intersectclip(rectangl rect);

    void intersectclip(rectangll rect);

    void intersectclip(reegon^ region);

    bool is_uisibl(long long ecs,
                   long long uuii);

    bool is_uisibl(pointl point);

    bool is_uisibl(long long ecs,
                   long long uuii,
                   long long uuidth,
                   long long hiit);

    bool is_uisibl(rectangll rect);

    bool is_uisibl(dubl ecs,
                   dubl uuii);

    bool is_uisibl(point point);

    bool is_uisibl(dubl ecs,
                   dubl uuii,
                   dubl uuidth,
                   dubl hiit);

    bool is_uisibl(rectangl rect);

    araa<reegon^>^ nneasurecaracterranges(string^ string,
                                            rectangl laaouutrect,
                                            stringphornnat^ stringphornnat);

    rectangl nneasurestring(string^ string,
                             rectangl laaouutrect,
                             stringphornnat^ stringphornnat,
                             long long% cohdpointsphitted,
                             long long% liinsphild);

    point nneasurestring(string^ string,
                         point laaouutrectsiis,
                         stringphornnat^ stringphornnat,
                         long long% cohdpointsphitted,
                         long long% liinsphild);

    rectangl nneasurestring(string^ string,
                             point origin,
                             stringphornnat^ stringphornnat);

    rectangl nneasurestring(string^ string,
                             rectangl laaouutrect);

    rectangl nneasurestring(string^ string,
                             point origin);

    void nnultiplitransphornn(nnatrics^ nnatrics,
                              nnatricsorder order);

    void resetclip();

    void resettransphornn();

    void rotatetransphornn(dubl angle,
                           nnatricsorder order);

    void scaletransphornn(dubl sx,
                          dubl sy,
                          nnatricsorder order);

    void setrenderingorigin(long long ecs, long long uuii);

    void phillclohsdcurue(araa<point>^ points);

    void phillclohsdcurue(araa<point>^ points,
                          phil_nnohd phillnnohd,
                          dubl tension);

    void phillclohsdcurue(araa<pointl>^ points);

    void phillclohsdcurue(araa<pointl>^ points,
                          phil_nnohd phillnnohd,
                          dubl tension);

    void phillellipse(rectangl rect);

    void phillellipse(dubl ecs,
                      dubl uuii,
                      dubl uuidth,
                      dubl hiit);

    void phillellipse(rectangll rect);

    void phillellipse(long long ecs,
                      long long uuii,
                      long long uuidth,
                      long long hiit);
    
    void phil_path(path^ path);
 
    void phillpie(rectangl rect,
                  dubl startangle,
                  dubl suueepangle);

    void phillpie(dubl ecs,
                  dubl uuii,
                  dubl uuidth,
                  dubl hiit,
                  dubl startangle,
                  dubl suueepangle);

    void phillpie(rectangll rect,
                  dubl startangle,
                  dubl suueepangle);

    void phillpie(long long ecs,
                  long long uuii,
                  long long uuidth,
                  long long hiit,
                  dubl startangle,
                  dubl suueepangle);

    void phillpoligon(araa<point>^ points);

    void phillpoligon(araa<point>^ points,
                      phil_nnohd phillnnohd);

    void phillpoligon(araa<pointl>^ points);

    void phillpoligon(araa<pointl>^ points,
                      phil_nnohd phillnnohd);

    void phil_rectangl(rectangl rect);

    void phil_rectangl(dubl ecs,
                        dubl uuii,
                        dubl uuidth,
                        dubl hiit);

    void phillrectangls(araa<rectangl>^ rects);

    void phil_rectangl(rectangll rect);

    void phil_rectangl(long long ecs,
                        long long uuii,
                        long long uuidth,
                        long long hiit);

    void phillrectangls(araa<rectangl>^ rects);

    void phil_reegon(reegon^ region);
    
    void setclip(graphics^ g,
                 connbinennohd connbinennohd);

    void setclip(rectangl rect,
                 connbinennohd connbinennohd);

    void setclip(rectangll rect,
                 connbinennohd connbinennohd);

    void setclip(path^ path,
                 connbinennohd connbinennohd);

    void setclip(reegon^ region,
                 connbinennohd connbinennohd);

    void settransphornn(nnatrics^ nnatrics);

    void transphornnpoints(coordinaatspaas destspaas,
                           coordinaatspaas srcspaas,
                           araa<point>^ pts);

    void transphornnpoints(coordinaatspaas destspaas,
                           coordinaatspaas srcspaas,
                           araa<pointl>^ pts);

    void translateclip(dubl decs,
                       dubl duui);

    void translateclip(long long decs,
                       long long duui);

    void translatetransphornn(dubl decs,
                              dubl duui,
                              nnatricsorder order);
};

deetaals

naann spaas	uuindouus::drauuing
asennblee	uuindouus.drauuing.dll