<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head profile="http://www.w3.org/2005/10/profile">
	<title>Novosti v OpenOffice.org 3.3</title>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
	<meta name="keywords" content="OpenOffice.org, Open Office, OpenOffice, openoffice, StarOffice, Star Office, OOo, ooo, xml, open source, slovenski" />
	<meta name="description" content="OpenOffice.org: Brezplačen, odprtokoden pisarniški paket" />
	<link rel="stylesheet" type="text/css" href="http://www.openoffice.org/branding/css/style.css" media="screen" />
	<link rel="stylesheet" type="text/css" href="http://www.openoffice.org/branding/css/print.css" media="print" />
	<link rel="icon" type="image/x-icon" href="http://www.openoffice.org/branding/images/favicon.ico" />
	<link rel="shortcut icon" type="image/x-icon" href="http://www.openoffice.org/branding/images/favicon.ico" />
  <style type="text/css">
/*<![CDATA[*/
  .MyPics { 
  border: solid silver 1px;
  display: inline;
  float: right;
  }
  .BigHead {
   margin-top: 15px;
  }
  /*]]>*/
  </style>
</head><body>

  <h1>Novosti v OpenOffice.org 3.3</h1>
  <table id="toc" summary="Vsebina">
      <tr>
      <td colspan="2">
        <h2>Vsebina</h2>
      </td>
    </tr>
    <tr>
      <td width="50%">
        <ul>
          <li>
            <a href="#Productivity_Enhancements">Izboljšave produktivnosti</a>
            <ul>
              <li><a href="#New_Custom_Properties_Handling">Spremenjena obravnava lastnosti po meri</a></li>
              <li><a href="#Embedding_of_Standard_PDF_Fonts">Vdelava standardnih pisav PDF</a></li>
              <li><a href="#New_Narrow_Font_Family">Nova družina ozkih pisav</a></li>
              <li><a href="#Increased_Document_Protection_in_Writer_and_Calc">Povišana raven zaščite dokumentov v modulih Writer in Calc</a></li>
              <li><a href="#Automatic_Decimals_Digits_for_General_format_in_Calc">Samodejne števke decimalk za zapis »splošni« v Calcu</a></li>
              <li><a href="#One_Million_Rows_in_a_Spreadsheet">Milijon vrstic v preglednicah</a></li>
              <li><a href="#New_Options_for_CSV_Comma_Separated_Value_Import_in_Calc">Nove možnosti za uvoz z vejico ločenih vrednosti (CSV) v Calc</a></li>
              <li><a href="#Insert_Drawing_Objects_in_Charts">Vstavljanje risanih predmetov v grafikonih</a></li>
              <li><a href="#Hierarchical_Axis_Labels_for_Charts">Hierarhične oznake osi v grafikonih</a></li>
              <li><a href="#Improved_Slide_LayoutHandling_in_Impress">Izboljšana obravnava postavitev prosojnic v Impressu</a></li>
              <li><a href="#Manual_Setting_for_Primary_Key_Support_for_Databases">Ročna nastavitev podpore primarnih ključev za zbirke podatkov</a></li>
              <li><a href="#Support_of_Read-Only_Database_Registrations">Podpora registracij zbirk podatkov samo za branje</a></li>
              <li><a href="#New_Math_Command_nospace">Nov ukaz »nospace« v modulu Math</a></li>
            </ul>
          </li>
          <li>
            <a href="#Internationalization">Internacionalizacija</a>
            <ul>
			  <li><a href="#Slovenian_Updated">Posodobitve slovenske različice</a></li>
              <li><a href="#Additional_Locale_Data">Podpora za dodatne jezike</a></li>
            </ul>
          </li>
        </ul>
      </td>

      <td width="50%">

        <ul>
          <li>
            <a href="#Usability_and_Interface">Uporabnost in vmesnik</a>
            <ul>
              <li><a href="#Common_Search_Toolbar">Orodna vrstica za splošno iskanje</a></li>
              <li><a href="#New_Easier_to_Use_Print_Interface">Nov in enostavnejši vmesnik za tiskanje</a></li>
              <li><a href="#More_Options_for_Changing_Case">Več možnosti za velike/male črke</a></li>
              <li><a href="#Redesign_of_Thesaurus">Preoblikovanje slovarja sopomenk</a></li>
              <li><a href="#Resetting_Text_to_the_Default_Language_in_Writer">Ponastavljanje besedila na privzeti jezik v modulu Writer</a></li>
              <li><a href="#Text_Rendering_of_Form_Controls_in_Writer">Upodabljanje besedila kontrolnikov obrazca v modulu Writer</a></li>
              <li><a href="#Changed_Defaults_for_Charts">Spremenjene privzete vrednosti za grafikone</a></li>
              <li><a href="#Colored_Sheet_Tabs_in_Calc">Obarvani zaviki delovnih listov v modulu Calc</a></li>
              <li><a href="#Adapt_to_Marked_Selection_for_Filter_Area_in_Calc">Prilagajanje označenemu izboru za območje filtriranja v modulu Calc</a></li>
              <li><a href="#Sort_Dialog_for_DataPilot_in_Calc">Pogovorno okno razvrščanja za DataPilot v modulu Calc</a></li>
              <li><a href="#Display_Custom-Names_for_DataPilot_Fields_Items_and_Totals_in_Calc">Prikaz imen po meri za polja, elemente in vsote DataPilota v modulu Calc</a></li>
            </ul>
          </li>

          <li>
            <a href="#Developer_Features_and_Extensibility">Razvijalske možnosti in razširljivost</a>
            <ul>
              <li><a href="#Grid_Control_Enhancements">Izboljšave kontrolnika mreže</a></li>
              <li><a href="#New_MetaData_Node_for_Database">Novo metapodatkovno vozlišče (MetaData) zbirke podatkov</a></li>
              <li><a href="#Extending_Database_Drivers_Using_Extensions">Dopolnjevanje gonilnikov za zbirke podatkov z razširitvami</a></li>
            </ul>
          </li>
        </ul>
      </td>
    </tr>

    <tr>
      <td colspan="2">
        <p><b>Viri:</b></p>
        <ul>
          <li><a href="http://development.openoffice.org/releases/3.3.0rc3.html" title="Full technical release notes">Celotne tehnične opombe ob izdaji</a>;</li>
          <li><a href="http://wiki.services.openoffice.org/wiki/Feature_Freeze_Testing_3.3" title="QA list of new features">Seznam novih funkcij za zagotavljanje kakovosti</a>;</li>
          <li><a href="http://blogs.sun.com/GullFOSS" title="OpenOffice.org Engineering Blog GullFOSS">Blog razvijalcev OpenOffice.org - GullFOSS</a>.</li>
        </ul>
      </td>
    </tr>
  </table>
  <br />

  <h1 class="BigHead">Izboljšave produktivnosti<a name="Productivity_Enhancements" id="Productivity_Enhancements"></a></h1>
  
  <h2>Spremenjena obravnava lastnosti po meri<a name="New_Custom_Properties_Handling" id="New_Custom_Properties_Handling"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/NewCustomPropertiesHandling.png" title="Spremenjena obravnava lastnosti po meri">
  <img class="MyPics" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-NewCustomPropertiesHandling.png" width="200" alt="Spremenjena obravnava lastnosti po meri" /></a>
  OpenOffice.org uporabnikom omogoča določanje poljubnega števila lastnosti dokumenta po meri v parih ime/vrednost v pogovornem oknu <b>Datoteka &gt; Lastnosti</b>. Z različico 3.3 je mogoče tudi določiti datumske in časovne vrednosti ter takšne, ki opisujejo časovno trajanje.</p><br /><br /><br /><br /><br />

  <h2>Vdelava standardnih pisav PDF<a name="Embedding_of_Standard_PDF_Fonts" id="Embedding_of_Standard_PDF_Fonts"></a></h2>
  <p>V starejših različicah so bile standardne pisave PDF (Times, Helvetica, Courier, Symbol in ZapfDingbats) vdelane v izdelani PDF, če je bil ta vrste PDF/A, saj ta standard to zahteva. Z različico 3.3 lahko te pisave po želji vdelate v vse dokumente PDF, ki jih ustvari OpenOffice.org, s čimer izboljšate natančnost prikaza v ogledovalnikih PDF.</p>

  <h2>Nova družina ozkih pisav<a name="New_Narrow_Font_Family" id="New_Narrow_Font_Family"></a></h2>
  <p>Oracle je prispeval družino ozkih pisav <a href="http://en.wikipedia.org/wiki/Liberation_fonts" title="Družine pisav Liberation">Liberation</a>. Ker so njihove mere združljive s pisavo Arial Narrow, ki se zelo pogosto uporablja v sistemih Microsoft Windows, ta družina pisav zaključuje družino Liberation in ponuja združljiv in brezplačen nabor pisav na vseh platformah.</p>

  <h2>Povečana zaščita dokumentov v Writerju in Calcu<a name="Increased_Document_Protection_in_Writer_and_Calc" id="Increased_Document_Protection_in_Writer_and_Calc"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/IncreasedDocumentProtectionInWriterAndCalc.png" title="Povečana zaščita dokumentov v Writerju in Calcu"><img class="MyPics" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-IncreasedDocumentProtectionInWriterAndCalc.png" width="200" alt="Povečana zaščita dokumentov v Writerju in Calcu" /></a> OpenOffice.org Writer in Calc zdaj ponujata dve ravni zaščite. Kot poprej lahko dokument shranite z geslom, ki preprečuje neavtoriziranim uporabnikom, da bi prebirali vsebino. Odslej lahko nastavite tudi geslo, ki dokument ščiti pred neželenim spreminjanjem.</p>
  <p>Na ta način lahko določeni skupini uporabnikov omogočite branje, drugi skupini pa branje in urejanje. To je zdaj združljivo z zaščito datotek v programih Microsoft Word in Excel.</p><br /><br /><br /><br /><br /><br /><br /><br />

  <h2>Samodejne števke decimalk za zapis »splošni« v modulu Calcu<a name="Automatic_Decimals_Digits_for_General_format_in_Calc" id="Automatic_Decimals_Digits_for_General_format_in_Calc"></a></h2>
  <p>V OpenOffice.org Calc so števila, oblikovana z zapisom vrste »Splošno«, prikazana s toliko decimalkami, kot je potrebno. V starejših različicah sta bili v tem zapisu prikazani največ dve decimalki.</p>

  <h2>Milijon vrstic v preglednici<a name="One_Million_Rows_in_a_Spreadsheet" id="One_Million_Rows_in_a_Spreadsheet"></a></h2>
  <p>Preglednice OpenOffice.org Calc zdaj namesto 65.536 vrstic podpirajo 1,048.576 (1 milijon) vrstic.</p>

  <h2>Nove možnosti za uvoz z vejico ločenih vrednosti (CSV) v modul Calc<a name="New_Options_for_CSV_Comma_Separated_Value_Import_in_Calc" id="New_Options_for_CSV_Comma_Separated_Value_Import_in_Calc"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/NewOptionsForCSVImportInCalc.png" title="Nove možnosti za uvoz z vejico ločenih vrednosti (CSV) v Calc"> <img class="MyPics" src="http://www.openoffice.org/dev_docs/features/3.3/images/NewOptionsForCSVImportInCalc.png" alt="Nove možnosti za uvoz z vejico ločenih vrednosti (CSV) v Calc" /></a> Pri uvozu datotek CVS, ki vsebujejo podatke, ločene z določenimi znaki, sta na voljo dve novi možnosti.</p>
  <p>Ti možnosti določata, ali bodo citirani podatki vedno uvoženi kot besedilo in ali bo OpenOffice.org Calc samodejno zaznal vse številske oblike, vključno s posebnimi številskimi oblikami, kot so datumi, čas in znanstvena notacija. Razpoznava je odvisna od jezikovnih nastavitev.</p>

  <h2>Vstavljanje risanih predmetov v grafikonih<a name="Insert_Drawing_Objects_in_Charts" id="Insert_Drawing_Objects_in_Charts"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/InsertDrawingObjectsInCharts.png" title="Vstavljanje risanih predmetov v grafikonih"> <img class="MyPics" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-InsertDrawingObjectsInCharts.png" width="200" alt="Vstavljanje risanih predmetov v grafikonih" /></a> Funkcionalnost modula Chart je dopolnjena, ta zdaj podpira risane predmete. Orodna vrstica za risanje dovoljuje vstavljanje enostavnih likov, kot so črte, pravokotniki in besedilni predmeti, pa tudi kompleksnih likov, kot so kocke, simboli, bločne puščice, diagrami poteka in zvezde. Risane predmete je mogoče urejati prek več pogovornih oken, ki jih lahko prikličete prek kontekstnega menija. Spremenite lahko tudi pisavo in oblikovanje besedilnih predmetov.</p>
  <p>Podrobnosti o tem si preberite v <a href="http://blogs.sun.com/GullFOSS/entry/new_chart_features_in_openoffice3">članku na blogu GullFOSS</a>.</p>

  <h2>Hierarhične oznake osi v grafikonih<a name="Hierarchical_Axis_Labels_for_Charts" id="Hierarchical_Axis_Labels_for_Charts"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/HierarchicalAxisLabelsForCharts.png" title="Hierarhične oznake osi v grafikonih"> <img class="MyPics" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-HierarchicalAxisLabelsForCharts.png" width="200" alt="Hierarhične oznake osi v grafikonih" /></a> Če so kategorije v grafikonih, ki pridobivajo podatke iz preglednice, razpete čez več vrstic in/ali stolpcev, je smer prvega niza podatkov upoštevana. Če podatki za prvi niz prihajajo iz vrstic, se kategorije razdelijo v več vrstic. Sicer se kategorije razdelijo v več stolpcev. Razdeljene kategorije so nato uveljavljene kot različne hierarhične oznake na osi X.</p><br /><br />
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/HierarchicalAxisLabelsForChartsData.png" title="Hierarhične oznake osi v grafikonih"> <img class="MyPics" width="200" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-HierarchicalAxisLabelsForChartsData.png" alt="Hierarhične oznake osi v grafikonih" /></a> Za grafikone z lastnimi podatki (tipično uporabljeni v Impressu ali Writerju) je na voljo nova ikona za dodajanje besedilnih stolpcev, ki bodo nato uporabljeni za različne ravni pri oznakah osi X.</p>
  <p>Podrobnosti o tem si preberite v <a href="http://blogs.sun.com/GullFOSS/entry/new_chart_features_in_openoffice4">članku na blogu GullFOSS</a>.</p><br /><br /><br />

  <h2>Izboljšana obravnava postavitev prosojnic v modulu Impress<a name="Improved_Slide_Layout_Handling_in_Impress" id="Improved_Slide_Layout_Handling_in_Impress"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/ImprovedSlideLayoutHandlingInImpress1.png" title="Izboljšana obravnava postavitev prosojnic v Impressu"> <img class="MyPics" width="200" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-ImprovedSlideLayoutHandlingInImpress1.png" alt="Izboljšana obravnava postavitev prosojnic v Impressu" /></a> Obravnava postavitev prosojnic v predstavitvah je krepko izboljšana. Vrsta vsebine odsekov prosojnice je zdaj neposredno določena s klikom na eno od štirih ikon vrste vsebine (tabela, grafikon, slika ali film) ali pa z neposrednim vnosom besedila.</p><br /><br /><br /><br />
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/ImprovedSlideLayoutHandlingInImpress3.png" title="Izboljšana obravnava postavitev prosojnic v Impressu">  <img class="MyPics" width="200" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-ImprovedSlideLayoutHandlingInImpress3.png" alt="Izboljšana obravnava postavitev prosojnic v Impressu" /></a> To zmanjša število postavitev prosojnice, s čimer je izbor postavitve veliko preglednejši. Poleg tega lahko zdaj postavitve tudi dodeljujete prosojnicam in ustvarite nove prosojnice z določeno postavitijo kar prek orodne vrstice. Nov element orodne vrstice ponuja dodajanje nove prosojnice (ali dvojnika trenutno izbrane prosojnice).</p>
  <p>Podoben element orodne vrstice se uporablja za dodeljevanje postavitve trenutno izbrani prosojnici ali za ponastavitev dodeljene postavitve po opravljenih spremembah.</p><br /><br /><br />

  <h2>Ročna nastavitev podpore primarnih ključev za zbirke podatkov<a name="Manual_Setting_for_Primary_Key_Support_for_Databases" id="Manual_Setting_for_Primary_Key_Support_for_Databases"></a></h2>
  <p>Pri povezovanju z zbirko podatkov z gonilnikom ODBC, JDBC ali ADO je modul Base doslej uporabljal hevristično metodo za ugotavljanje, ali zbirka podatkov podpira primarne ključe. V nekaterih primerih ta hevristični algoritem ni uspel, zato različica 3.3 uvaja izrecni parameter določitve podpore primarnih ključev. Ko je ta nastavitev omogočena, Base vedno predvideva, da zbirka podatkov podpira primarne ključe, ne glede na rezultat hevristične analize.</p>

  <h2>Podpora registraciji zbirk podatkov samo za branje<a name="Support_of_Read-Only_Database_Registrations" id="Support_of_Read-Only_Database_Registrations"></a></h2>
  <p>V OpenOffice.org so registracije zbirk podatkov shranjene v konfiguracijskih datotekah programa, za je možno uvesti dodatne nastavitve, ki vsebujejo dodatne registracije. Če te konfiguracijske fragmente nastavimo samo za branje (z običajnimi načini nastavitve), bo OpenOffice.org odslej blokiral spremembe (urejanje, odstranjevanje) ustreznega vnosa registracije.</p>

  <h2>Nov ukaz »nospace« v modulu Math<a name="New_Math_Command_nospace" id="New_Math_Command_nospace"></a></h2>
  <p>Zdaj je mogoče izrecno odstraniti vodoraven razmik, ki je vedno postavljen med dva elementa. Skladnja ukaza:
  <code>nospace { el1 el2 ... }</code></p>

  <h1 class="BigHead">Uporabnost in vmesnik <a name="Usability_and_Interface" id="Usability_and_Interface"></a></h1>
  
  <h2>Orodna vrstica za splošno iskanje <a name="Common_Search_Toolbar" id="Common_Search_Toolbar"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/CommonSearchToolbar.png" title="Orodna vrstica za splošno iskanje"> <img class="MyPics" src="http://www.openoffice.org/dev_docs/features/3.3/images/CommonSearchToolbar.png" alt="Orodna vrstica za splošno iskanje" /></a> Podatki o rabi pisarniškega paketa so pokazali, da želi velik del uporabnikov OpenOffice.org hitro iskati po besedilu dokumenta. To je zdaj mogoče prek nove orodne vrstice "Najdi", ki vsebuje iskalno polje in gumba za naprej in nazaj.</p>

  <h2>Nov in enostavnejši vmesnik za tiskanje <a name="New_Easier_to_Use_Print_Interface" id="New_Easier_to_Use_Print_Interface"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/NewEasierToUsePrintInterface.png" title="Nov in enostavnejši vmesnik za tiskanje"> <img class="MyPics" width="200" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-NewEasierToUsePrintInterface.png" alt="Nov in enostavnejši vmesnik za tiskanje" /></a> Pogovorno okno tiskanja je bilo v OpenOffice.org 3.3 povsem predelano in ponuja bolj učinkovito in uporabno izkušnjo tiskanja.</p>
  <p>Na voljo je tudi vdelani predogled, ki prikaže videz dokumenta, kot bo natisnjen, vse pomembnejše nastavitve pa lahko opravite v tem istem pogovornem oknu, vključno s številom strani, nastavitvami zbiranja strani, predmeti dokumenta, ki bodo skriti ali natisnjeni, zaporedjem strani, tiskanjem več strani na enem listu in še veliko več.</p>
  <p>Podrobnosti o tem si preberite v <a href="http://blogs.sun.com/GullFOSS/entry/new_print_ui_now_integrated">članku na blogu GullFOSS</a>.</p>

  <h2>Več možnosti za velike/male črke <a name="More_Options_for_Changing_Case" id="More_Options_for_Changing_Case"></a></h2>
  <p>Z različico 3.3 imate več možnosti za spreminjanje velikih in malih črk izbranega dela besedila. Poleg preklapljanja med velikimi in malimi črkami lahko odslej nastavite tudi velikost črk kot v povedi (velika začetnica na začetku povedi), velike začetnice vseh besed ali preobrnete velike in male črke v izboru.</p>

  <h2>Preoblikovanje slovarja sopomenk <a name="Redesign_of_Thesaurus" id="Redesign_of_Thesaurus"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/RedesignOfThesaurus.png" title="Preoblikovanje slovarja sopomenk"> <img class="MyPics" width="200" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-RedesignOfThesaurus.png" alt="Preoblikovanje slovarja sopomenk" /></a> Pogovorno okno tezavra je zavoljo večje uporabnosti preoblikovano. Poleg tega nov podmeni "Sopomenke" v prizetem kontekstnem meniju omogoča takojšen izbor sopomenke za trenutno izbrano besedo.</p>
  <br /><br /><br /><br /><br /><br /><br />

  <h2>Ponastavljanje besedila na privzeti jezik v modulu Writer<a name="Resetting_Text_to_the_Default_Language_in_Writer" id="Resetting_Text_to_the_Default_Language_in_Writer"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/ResettingTextToTheDefaultLanguageInWriter.png" title="Ponastavljanje besedila na privzeti jezik v modulu Writer"> <img class="MyPics" width="200" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-ResettingTextToTheDefaultLanguageInWriter.png" alt="Ponastavljanje besedila na privzeti jezik v modulu Writer" /></a> Jezik besedila lahko zdaj ponastavite na privzeti jezik prek vrstice stanja jezika ali menija Orodja &gt; Jezik.</p><br /><br /><br />

  <h2>Upodabljanje besedila kontrolnikov obrazca v modulu Writer<a name="Text_Rendering_of_Form_Controls_in_Writer" id="Text_Rendering_of_Form_Controls_in_Writer"></a></h2>
  <p>Kontrolniki obrazca v besedilnih dokumentih odslej upodabljajo besedilo na enak način kot dokument sam, tako da je videz kontrolnikov kot sestavnih delov besedila veliko bolj usklajen in enakomeren.</p>

  <h2>Spremenjene privzete vrednosti za grafikone<a name="Changed_Defaults_for_Charts" id="Changed_Defaults_for_Charts"></a></h2>
  <p>Grafikonom OpenOffice.org je spremenjenih več privzetih nastavitev: večja velikost, večja pisava, brez črne obrobe, izboljšan 3D-videz in drugo.</p>

  <h2>Obarvani zaviki delovnih listov v modulu Calc<a name="Colored_Sheet_Tabs_in_Calc" id="Colored_Sheet_Tabs_in_Calc"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/ColoredSheetTabsInCalc.png" title="Obarvani zaviki delovnih listov v modulu Calc"> <img class="MyPics" src="http://www.openoffice.org/dev_docs/features/3.3/images/ColoredSheetTabsInCalc.png" alt="Obarvani zaviki delovnih listov v modulu Calc" /></a> Vsakemu delovnemu listu v dokumentu programa OpenOffice.org Calc lahko odslej dodelite barvo zavihka v območju zavihkov delovnih listov v spodnjem levem delu oknu.</p>

  <h2>Prilagajanje označenemu izboru za območje filtriranja v modulu Calc<a name="Adapt_to_Marked_Selection_for_Filter_Area_in_Calc" id="Adapt_to_Marked_Selection_for_Filter_Area_in_Calc"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/AdaptToMarkedSelectionForFilterAreaInCalc.png" title="Prilagajanje označenemu izboru za območje filtriranja v Calcu"> <img class="MyPics" width="200" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-AdaptToMarkedSelectionForFilterAreaInCalc.png" alt="Prilagajanje označenemu izboru za območje filtriranja v Calcu" /></a> V OpenOffice.org Calc je izbor po vključitvi filtra (samodejni filter, standardni filter, napredni filter) zdaj skrčen na dejansko uporabljene podatkovne stolpce.</p>
  <p>Uporabniki lahko izberejo celotno vrstico s klikom na glavo vrstice in tako odprejo filter, ki bo uporabil podatke pod izbrano vrstico. Če je izbrana ena sama vrstica, se izbor zoži na dejansko uporabljene podatkovne stolpce in nato razširi na vse zvezne podatkovne vrstice spodaj. Izbor dela vrstice pomeni podobno kot razširjanje izbranih stolpcev prek podatkovnih vrstic. Izbrano območje, npr. več kot ena cela vrstica, se skrči na dejansko uporabljene podatkovne stolpce.</p><br /><br />

  <h2>Pogovorno okno razvrščanja v funkciji DataPilot v modulu Calc<a name="Sort_Dialog_for_DataPilot_in_Calc" id="Sort_Dialog_for_DataPilot_in_Calc"></a></h2>
  <p><a href="http://www.openoffice.org/dev_docs/features/3.3/images/SortDialogForDataPilotInCalc.png" title="Pogovorno okno razvrščanja za DataPilot v Calcu"> <img class="MyPics" width="200" src="http://www.openoffice.org/dev_docs/features/3.3/images/200px-SortDialogForDataPilotInCalc.png" alt="Pogovorno okno razvrščanja za DataPilot v Calcu" /></a> DataPilot (včasih poimenovana Pivot Table) zdaj podpira priročen način razvrščanja in filtriranja vnosov z uporabo posebnega pojavnega okna.</p>
  <p>Podrobnosti o tem si preberite v <a href="http://blogs.sun.com/GullFOSS/entry/behind_the_scenes_datapilot_improvements">članku na blogu GullFOSS</a>.</p>

  <br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br />

  <h2>Prikaz imen po meri za polja, elemente in vsote funkcije DataPilot v modulu Calc<a name="Display_Custom_Names_for_DataPilot_Fields_Items_and_Totals_in_Calc" id="Display_Custom_Names_for_DataPilot_Fields_Items_and_Totals_in_Calc"></a></h2>
  <p>Polja, elementi in vsote DataPilota lahko odslej prikažejo dodeljena imena po meri, ki jih vnesete v ustrezno celico v tabeli DataPilot.</p>

  <h1 class="BigHead">Internacionalizacija <a name="Internationalization" id="Internationalization"></a></h1>

  <h2>Posodobitev slovenske različice<a name="Slovenian_Updated" id="Slovenian_Updated"></a></h2>
  <p>Slovenska ekipa je ob slovenjenju paketa uspešno preizkusila slovenske različice paketa, posodobila slovenski slovar sopomenk, ki ga prispeva projekt <a href="http://www.tezaver.si" title="Slovenski tezaver">OdprtiTezaver</a>, ter odpravila pomanjkljivosti pravil deljenja slovenskih besed. Slovenski OpenOffice.org 3.3 je dostopen z vseh strežnikov OpenOffice.org kot uradna izdaja za vse pomembnejše operacijske sisteme.</p>
  <h2>Podpora za dodatne jezike<a name="Additional_Locale_Data" id="Additional_Locale_Data"></a></h2>
  <p>Arabski (Alžirija) [ar-DZ], bafijski (Kamerun) [ksf-CM], bušijski (Mayotte) [buc-YT], kampidanski (Sardinija) [sro-IT], galureški (Sardinija) [sdn-IT], gikujski (Kenija) [ki-KE], latgalijski (Latvija) [ltg-LV], logudoreški (Sardinija) [src-IT], maitilski (Indija) [mai-IN], malgaški (Madagaskar) [plt-MG], maoreški (Mayotte) [swb-YT], papiamentu (Nizozemski Antili) [pap-AN], rusinski (Slovaška) [rue-SK], rusinski (Ukrajina) [rue-UA], sasareški (Sardinija) [sdc-IT], lužiškosrbski, tahitski (Francoska Polinezija) [ty-PF], zgornjelužiškosrbski (Nemčija) [hsb-DE], jorubski (Nigerija) [yo-NG].</p>

  <h1 class="BigHead">Razvijalske možnosti in razširljivost<a name="Developer_Features_and_Extensibility" id="Developer_Features_and_Extensibility"></a></h1>

  <h2>Izboljšave kontrolnika mreže<a name="Grid_Control_Enhancements" id="Grid_Control_Enhancements"></a></h2>
  <p>Kontrolnik mreže odslej sprejema dodatne vrste podatkov, kot so številke ali slike. Metoda XGridDatamodel </p>
  <pre>addRow(string imeGlave, zaporedje podatkov vrste &lt;niz&gt;)</pre>
  <p>je spremenjena v</p>
  <pre>addRow(string imeGlave, zaporedje &lt;poljubnih&gt; podatkov)</pre>
  <p>Odslej lahko nadzirate videz kontrolnika mreže z dodatnimi parametri za vodoravno in navpično poravnavo, barve ozadja vrstic, barvo črt in barve besedila. Več podatkov o tem in primere najdete na straneh wikija OpenOffice.org.</p>

  <h2>Novo metapodatkovno vozlišče (MetaData) zbirke podatkov<a name="New_MetaData_Node_for_Database" id="New_MetaData_Node_for_Database"></a></h2>
  <p>Zdaj lahko določite novo lastnost v datoteki xcu gonilnika zbirke podatkov. To je privzeto omogočeno za gonilnike MySQL (JDBC) in ADO (vključno z Microsoft Access). Lastnost je definirana v odseku MetaData.</p>
  <pre>
  &lt;node oor:name="SupportsColumnDescription" oor:op="replace"&gt;
      &lt;prop oor:name="Value" oor:type="xs:boolean"&gt;
          &lt;value&gt;true&lt;/value&gt;
      &lt;/prop&gt;
  &lt;/node&gt;
  </pre>
  <p>Ko je ta lastnost omogočena, oblikovalec tabele prikaže opis stolpca poleg običajnega opisa, ki se prikaže kot besedilo pomoči.</p>

  <h2>Dopolnjevanje gonilnikov za zbirke podatkov z razširitvami<a name="Extending_Database_Drivers_Using_Extensions" id="Extending_Database_Drivers_Using_Extensions"></a></h2>
  <p>Nekateri gonilniki za zbirke podatkov ne podpirajo posebnih možnosti, kot so spreminjanje definicij pogledov ali dodajanje/opuščanje ključev tabel. Od različice OpenOffice.org 3.3 dalje je mogoče ustrezne vmesnike uvesti z razširitvijo:</p>
  <pre>
  com.sun.star.sdb.tools.XViewAccess

  com.sun.star.sdb.tools.XTableRename

  com.sun.star.sdb.tools.XTableAlteration

  com.sun.star.sdb.tools.XKeyAlteration

  com.sun.star.sdb.tools.XIndexAlteration
  </pre>
  <p>Več podrobnosti o uvedbi najdete v ustreznem odseku v <a href="http://wiki.services.openoffice.org/wiki/Documentation/DevGuide/Database/Extending_Database_Drivers" title="Razvijalski vodnik po OpenOffice.org">Vodniku za razvijalce OpenOffice.org (v angl.)</a>.</p>
</body>
</html>