Instantiating objects with many attributes

In addition to LRE's answer I would suggest you consider the idea that your class needs that many constructor arguments because it's trying to do too many things.

As @LRE answer (+1) mentioned his PHP-fu is weak and since his points are correct and valid i just want to provide some more php code to illustrate :

class OpenIdProviderOptions {

    private $path;
    private $name = "default_name";
    private $param1;
    private $optionalParam2 = "foo";

    public function __construct($path, $param1) {
         /* you might take a $options array there for bc */
         /* Also if you have 2-3 REQUIRED parameters and the rest is optional
            i like putting all the required stuff in the constructor so you don't
            have to do any "is that value set" checking here.

            If you have 20 REQUIRED values you might split those into some objects
            or something ;) 
         */
    }

    public function getPath() {
        return $this->path;
    }

    /* etc */


}

class OpenIdProvider {

    private $settings;

    public function __construct(OpenIdProviderOptions $options) {
        $this->settings = $options;
    }

    public function foo {
        $path = $this->settings->getPath();
    }
}

$settings = new OpenIdProviderOptions("myopenid.example.com", "i need this");
$settings->setFoo("bar");
$settings->setBar("fubar");

$myProvider = new OpenIdProvider($settings);

I think it better to be all your parameter in one array and you must make good command for using this at other time It has some benefit and its that u can develop and add more option for this class. like this

class OpenIdProvider
{
    public $_width = 0;
    public $_highliting = '';
    public $_Xposition = 0;
    public $_Yposition = 0;
        ...
        ...

    /**
     * Main constractor to set array of parameters.
     * param array $parameters
     * description  _Xposition , _width , _Yposition ...
     */
    function __constrauct($parameters)
    {
        if(is_array($parameters))
            foreach($parameters as $needle=>$parameter)
                $this->{'_'.$needle} = $parameter;
    }
}
$options = array('path'=>$imgPath . $name . $ext,
                'highliting'=> 'openid_highlight', 
                 'width'=>108, 
                 'height'=>68, 
                 '...'=>6, 
                 '...'=>$info[0], 
                 '...'=>$info[1],
                 '...'=>$name);
$openIdObj = new OpenIdProvider($options);

PHP arrays are powerful. Similar to highelf I would use an array.

However, I would do a number of things differently to highelf.

1. Don't create public properties from the array you receive (especially using unknown array keys).
2. Check the values that you receive.

As edorian said, there is no type hinting, but you can enforce the required parameters manually. The advantages of this approach are:

1. Its easy to remember the number of parameters (1).
2. The order of the parameters is no longer important. (No need to worry about keeping a consistent order of parameters, although alphabetically works well.)
3. The calling code is more readable as the parameters are named.
4. It is very hard to accidentally set the width to the height even though the type is the same. (This is easily overlooked by type hinting).

So here is what I would do:

class OpenIdProvider
{
   protected $path;
   protected $setup;

   public function __construct(Array $setup)
   {
      // Ensure the setup array has keys ready for checking the parameters.
      // I decided to default some parameters (height, highlighting, something).
      $this->setup = array_merge(
         array('height'       => 68,
               'highlighting' => 'openid_highlight',
               'info'         => NULL,
               'name'         => NULL,
               'path'         => NULL, 
               'something'    => 6, 
               'width'        => NULL),
         $setup);

      // The following checks may look lengthy, but it avoids the creation of
      // the OpenIdProviderOptions class that seems to do very little. Also,
      // these would appear in that class to check the constructor values it
      // received properly.
      if (!is_array($this->setup['info']))
      {
         throw new InvalidArgumentException(
            __METHOD__ . ' requires info as array');
      }

      if (!is_string($this->setup['name']))
      {
         throw new InvalidArgumentException(
            __METHOD__ . ' requires name as string');
      }

      if (!is_string($this->setup['path']))
      {
         throw new InvalidArgumentException(
            __METHOD__ . ' requires path as string');
      }

      if (!is_int($this->setup['width']))
      {
         throw new InvalidArgumentException(
            __METHOD__ . ' requires width as int');
      }

      // If you use a setup parameter a lot you might want to refer to it from
      // this, rather than having to go via setup.
      $this->path =& $this->setup['path'];
   }

   public function internalFunction()
   {
      // Use the parameters like so.
      echo $this->setup['width'];
      echo $this->path;
   }
}

// The call is very easy.
$op = new OpenIdProvider(
   array('info'  => $info,
         'name'  => $name,
         'path'  => $imgPath . $name . $ext,
         'width' => 108));