Quantcast
Channel: DHTMLX Blog
Viewing all 228 articles
Browse latest View live

Support of dhtmlxSuite 3.6 and Old Browsers Can Be Stopped [Poll]

$
0
0

We want to inform you that we are planning to stop supporting the old versions of our dhtmlxSuite library. It concerns the versions 3.6 and lower, and IE6, IE7.

Here are the reasons of this decision:

  • 90% of appeared problems in 3.6 are already fixed in 4.x.
  • Technologies are developing fast, so we’re unable to provide proper support of 3.6 for new browsers, new devices, etc.
  • Necessity to support old browsers (IE6, IE7) thwarts the progress. Our components may obtain more cool and modern features but they hardly can be supported with old IE browsers.



DHTMLX Suite

We highly recommend those who still use old versions to update their library to the latest version. You may use our detailed migration guide. Moreover, if you have difficulties with migrating of your old skins to the new ones, then you can use new features in our Online Skin Builder that will help you to solve the possible problems with changes in skins starting from the version 4.0.

Now we’d like to hear your opinion about this. You’re welcome to take part in the poll here. If you don’t want to update, please share your reasons for it in the comment section below or write us on sales[at]dhtmlx.com.


Updated PHP Connector and Laravel Support Added

$
0
0

Good news for those who use or is planning to use DHTMLX with PHP back-end. PHP Connector is updated to let you use it with the latest versions of popular PHP frameworks (Codelgniter, Yii and CakePHP). What is more, we’ve added the integration with Laravel framework.

PHP+DHTMLX

Major changes


  • dhtmlxConnector for PHP is adapted to a new logic and new API of Codelgniter, Yii and CakePHP frameworks;
  • connectors can be installed through Composer, no need for manual file copying anymore;
  • models are used for controller’s configuration (Yii, CakePHP, Laravel);
  • dhtmlxGantt is added to each tutorial that shows how to use dhtmlxConnector with php frameworks;



See the updated tutorials of using dhtmlxConnector with Codelgniter, Yii and CakePHP.

Laravel framework integration



We’ve added the tutorial that will show you how to use the dhtmlxConnector library with the Laravel PHP framework. Following the steps of the new tutorial you’ll get a grid, a scheduler and a gantt populated with data from a database and able to save changes back to the server.

Start using connector with Laravel

You may download dhtmlxConnector from its page here, or install it through Composer and always have the latest version.

Gantt, Scheduler and Suite Documentation is Available in PDF

DHTMLX Suite Roadmap: Plans, Wishes, Your Participation

$
0
0

We decided to start a very good practice – we share our plans of dhtmlxSuite development in order you could be aware of what to expect. Moreover, we’d like you to take a part in this planning. In this post you’ll get know the near future of our library and learn how to influence on it.

dhtmlxSuite-Roadmap

Moving forward

Our principle #1 – never underestimate the rate of technologies development. We are always trying to move with the time: our controls support modern browsers and new devices; they correspond to the nowadays web development techniques and design. So the priority #1 is to guarantee the steady work of Suite UI controls.

Suite 5.0

The next version of dhtmlxSuite is going to be a major update. We’re planning to roll out 5.0 with a set of important and helpful updates. Here are some of them:

– DHTMLX Framework

dhtmlxSuite library has already proven itself as powerful library for building web applications. And now we set another goal – we want to tell you how to achieve the highest results by yourself, how to create really professional and fast applications with DHTMLX, how to work with DHTMLX in general. For this purpose we’ll share a set of “How-To’s” that will contain best practices and correct work with our controls.

apps-with-dhtmlx

– Visual Designer

We know that it’s time to update our Visual Designer to provide you the ability of interface prototyping in more fast and convenient way. New designer will be fully updated, get form builder tool and drag-and-drop functionality. It concerns both online and desktop versions.

– New Tree Control

In addition to the existing dhtmlxTree component we are preparing to release a new one. New Tree will be much faster, and will include the basic set of features at the beginning.

Feature requests

We’d also like to present you a public roadmap where you may check all our plans for future versions. Here is a Trello board with Suite roadmap. You may see that we’ve highlighted the updates that are planned to be a part of dhtmlxSuite 5.0. “Plans” label means that we’re going to release this feature anyway though we have no concrete dates. “Wishes” label means your feature requests that we grab from our forum, emails, support or other sources.

new-features

How to influence on it?

Vote for the features, demos, tutorials that you’d like to see in our library. If we see that some of the plans/wishes collect many votes, we’ll try to implement it in near release. The most demanded features surely will appear in dhtmlxSuite.

You have probably noticed that some of the plans are not connected with Suite update, so they can be released at any time. Moreover, the board contains dhtmlxVault roadmap as it often used together with dhtmlxSuite.

Thanks

Thank you all for your suggestions and for your requests to make this roadmap as well. With your active participation and feedbacks, dhtmlxSuite library develops and will improve. We hope that the transparency of our plans will make our relationships stronger!

How To Improve DHTMLX Libraries? 3 Simple Ways

$
0
0

As a follow-up to our news about DHTMLX Suite roadmap, we’d like to tell you how your suggestions can appear in new versions or on our public roadmap. It concerns not only dhtmlxSuite, but dhtmlxGantt, dhtmlxScheduler, dhtmlxVault and other components. So, do you have something to suggest?

new-features

If yes, here are the ways to do this:

    • Feature requests form. Just fill out 2-3 fields with detailed description of required functionality. No need to register or leave your name.
    • Leave your comments on forum. We created a special topic for this purpose. You may leave you suggestions about dhtmlxSuite here or create a separate topic here to request the functionality of any DHTMLX product.
  • Thank you for your help in improving DHTMLX products! Even our recent voting showed Today button in Calendar should appear as soon as possible :) Stay tuned!

    Exploring Different Views of dhtmlxScheduler

    $
    0
    0

    Our dhtmlxScheduler provides you with the different types of data visualization. Besides the popular options, such as different time scales like day or week, our scheduler gives you some additional possibilities. For example, you can combine your schedule with the map that can be pretty helpful in case you want to plan your business trip or vacations.

    If you’re working with ASP.NET, you may look at DHTMLX Scheduler.NET, a Scheduler control that works both in ASP.NET MVC and Web Forms. It has the similar range of views that are described below.

    calendar_basic_views

    Usually, there are only three required steps that allow you to use the view you want:

    1. Include the required files to your project
    2. Add the proper tab to your page, so you can switch to the view you want
    3. Configure the view

    To understand how the views work, let’s start with the default ones.

    Default Views: Day, Week, and Month

    This Getting Started Guide can help you build the basic scheduler.

    As we mentioned before, you should add the proper files firstly:

    <link rel="stylesheet" href="./codebase/dhtmlxscheduler.css">
    <script src="./codebase/dhtmlxscheduler.js"></script>

    And here’s a bunch of DIV containers you should use to make your application work:

    <div id="scheduler_here" class="dhx_cal_container" style='width:100%; height:100%;'>
        <div class="dhx_cal_navline">
            <div class="dhx_cal_prev_button">&nbsp;</div>
            <div class="dhx_cal_next_button">&nbsp;</div>
            <div class="dhx_cal_today_button"></div>
            <div class="dhx_cal_date"></div>
            <div class="dhx_cal_tab" name="day_tab" style="right:204px;"></div>
            <div class="dhx_cal_tab" name="week_tab" style="right:140px;"></div>
            <div class="dhx_cal_tab" name="month_tab" style="right:76px;"></div>
        </div>
        <div class="dhx_cal_header"></div>
        <div class="dhx_cal_data"></div>      
    </div>

    This code creates Next and Previous navigation buttons, shows you the current period, etc.

    Particularly, we’re interested in these three DIV’s:

    <div class="dhx_cal_tab" name="day_tab" style="right:204px;"></div>
    <div class="dhx_cal_tab" name="week_tab" style="right:140px;"></div>
    <div class="dhx_cal_tab" name="month_tab" style="right:76px;"></div>

    We’ve created three tabs that can be used to switch between the Day, Week, and Month views.

    During the initialization you can set the default options: an HTML container your calendar will be initialized in, the initial date of the scheduler, and the name of the initial view:

    scheduler.init('scheduler_here', new Date(), 'month');

    Here’s how the typical basic scheduler looks like:

    Basic view in Scheduler

    As you can see, there are some previously created events rendered.

    You can use tabs to switch between the available views. Here’s the Week view:

    Week view

    And here’s how the Day View looks like:

    Day View

    You can double-click an empty cell to create a new event or drag the existing event through the calendar grid to change the date.

    Learn more: Day View, Week View, Month View.

    Extending the Period. The Year View

    If one month is not long enough to plan your schedule, there’s always a possibility to use the Year View.

    First of all, you should include the required JavaScript file:

    <script src="./codebase/ext/dhtmlxscheduler_year_view.js" ></script>

    Then, add the proper tab to your page:

    <div class="dhx_cal_tab" name="year_tab" style="right:280px;"></div>

    And finally, set the label for the tab:

    scheduler.locale.labels.year_tab ="Year";

    That’s it. Now you can use the Year View:

    Year View

    The tooltip you can see at the screenshot above allows you to edit the event. Just click the “Details” icon and the edit window will appear on the screen.

    Learn more: Year View Documentation Page.

    All at Once. Agenda, Week Agenda, and Grid

    Now, let’s talk about the views that allow you to see all available events in the form of different types of lists.

    The Agenda view displays a list of all upcoming events. To enable this view you should add the proper JavaScript to your project:

    <script src="./codebase/ext/dhtmlxscheduler_agenda_view.js" ></script>

    The next step is to add the tab to your page:

    <div class="dhx_cal_tab" name="agenda_tab" style="right:280px;"></div>

    As a result, you’ll get a list that contains all your tasks:

    Agenda

    You can double-click on an empty self of this list to create a new event or click the “Details” button to edit the existing ones.

    Learn more: Agenda View Documentation Page

    The Week Agenda view is a combination of two views: Week and Agenda. This view shows you a list of upcoming events within a week.

    Here’s the required JavaScript file:

    <script src="./codebase/ext/dhtmlxscheduler_week_agenda.js" ></script>

    And here’s the code that adds the proper tab:

    <div class="dhx_cal_tab" name="week_agenda_tab" style="right:280px;"></div>

    The result is shown below:

    Week Agenda

    As you can see, this view shows you the whole week at once. You can double-click the empty cell to create a new event. Double-clicking the existing event will open the edit window. Another handy feature is events highlighting. You can click the event to select it. After you select the long term event, all related records will be highlighted.

    Here’s how it looks like:

    Highlighted agenda

    Learn more: Week Agenda View Documentation Page

    The Grid View looks similar to the Agenda view. But in this case, you can choose the data you want to display.

    Imagine that you wish to add some comments to your calendar. Here’s how the possible array of events will look like:

    var events = [
        {id:1, text:"Meeting", start_date:"2015-10-13 14:00",
         end_date:"2015-10-13 17:00", comment:"Project release issues"},
        {id:3, text:"Interview", start_date:"2015-10-24 09:00",
         end_date:"2015-10-24 10:00", comment:"Remember to smile!"},
        {/* some more events */}
    ];

    Let’s add the Grid view to our application. First of all, the required file:

    <script src="./codebase/ext/dhtmlxscheduler_grid_view.js"></script>

    Now you should add the Grid tab:

    <div class="dhx_cal_tab" name="grid_tab" style="right:300px;"></div>

    Configure the date format and change the tab label if you want to:

    scheduler.config.xml_date = "%Y-%m-%d %H:%i";
    scheduler.locale.labels.grid_tab = "My Grid";

    Now, the most important part. We must configure the grid. You should call the createGridView method to do so:

    scheduler.createGridView({
       name:"grid",
       fields:[    /* defines columns of the grid */
             {id:"id", label:"ID", sort:"int"},
             {id:"date", label:"Date", sort:"date"},
             {id:"text", label:"Event", sort:"str"},
             {id:"comment", label:"Comment", sort:"str"}
       ],
    });

    Here’s an explanation of what we’ve done. This code will create new grid with name grid that will contain a bunch of columns that the fields property contains. In this case, we have used the id property to choose what data we you want to display. It can be the ID of the event, its beginning date, or even a comment that you’ve added. The second property in our example is label. It defines the label for the column. The last property, sort, specifies the type of content that will be displayed in this column. It specifies the way of sorting. Possible values are ind, date, and str.

    The result is shown below:

    Grid view

    Besides this minimal amount of properties, many others can help you configure your application the way you want. You can set the with of a column, choose the date range, use custom sorting functions, etc.

    Learn more: Grid View Documentation Page

    Timeline View and Units View

    These views allow you to visualize events horizontally with separate timelines arranged from left to right (Timeline View) or vertically

    Let’s start from the Timeline View.

    Add the proper JavaScript file:

    <script src="./codebase/ext/dhtmlxscheduler_timeline.js"></script>

    Then add the tab to your page:

    <div class="dhx_cal_tab" name="timeline_tab" style="right:280px;"></div>

    and set its label:

    scheduler.locale.labels.timeline_tab ="Timeline";

    Now you can call the createTimelineView method to configure the view

    scheduler.createTimelineView({
         name:"timeline",
         x_unit:"minute",//measuring unit of the X-Axis.
         x_date:"%H:%i", //date format of the X-Axis
         x_step:30,      //X-Axis step in 'x_unit's
         x_size:24,      //X-Axis length specified as the total number of 'x_step's
         x_start:16,     //X-Axis offset in 'x_unit's
         x_length:48,    //number of 'x_step's that will be scrolled at a time
         y_unit:         //sections of the view (titles of Y-Axis)
            [{key:1, label:"Section A"},
             {key:2, label:"Section B"},
             {key:3, label:"Section C"},
             {key:4, label:"Section D"}],
         y_property:"section_id", //mapped data property
         render:"bar"             //view mode
    });

    It’s big enough but have no fear. Check the comments. To help you better understand what’s going on here’s little explanation. Besides the X-Axis configuration, you should also define the x-unit property that defines how many areas your calendar will consist of. In this example above we’ve created four areas with labels Section A, Section B, etc. The render property defines the view mode. There are Bar, Cell, Tree, and Days options available. The y_property property will help you attach an event to a proper timeline area. For example, if you want to add an event to Section A you should add the following property: y_property: “1”.

    Timeline View

    Learn more: Timeline View Documentation Page

    The Units View looks pretty much the same. The main difference, in this case, is that you can configure the X-Axis.

    By tradition, add the JavaScript file:

    <script src="./codebase/ext/dhtmlxscheduler_units.js"></script>

    and add the tab to your page:

    <div class="dhx_cal_tab" name="unit_tab" style="right:280px;"></div>

    You can use this code to set the label fir the tab:

    scheduler.locale.labels.unit_tab = "Unit"

    To configure how the X-Axis will look like, you should use the createUnitsView method:

    scheduler.createUnitsView({
        name:"unit",
        property:"unit_id", //the mapped data property
        list:[              //defines the units of the view
            {key:1, label:"Section A"},
            {key:2, label:"Section B"},
            {key:3, label:"Section C"}  
        ]
    });

    This code will create a new view with name units. property defines the property name that can be used to define which unit will contain the proper event. The list array contains the key property that you should use to attach the event to the unit, and the label property that defines unit’s label.

    That’s all you need to do for the basic configuration. The final step is to change the way you define your event. All you need to do is to add new property that will define which unit this event belongs. For example:

    var events = [
        {id:1, text:"Meeting",   start_date:"2015-10-13 14:00",
         end_date:"2015-10-13 17:00", unit_id: "1"},
        {id:2, text:"Interview", start_date:"2015-10-24 09:00",
         end_date:"2015-10-24 10:00", unit_id:"2"},
        { /* more events */ }
        ];

    In this case, unit_id: “1” means that the first event will be placed within the unit with the key: 1 property.

    Here’s how this view looks like:

    Unit View

    Besides this very basic functionality, Units View allows you to assign events to several units, or, for example, display units for multiple days. Better check the documentation page to learn how you can configure it.

    Learn more: Units View Documentation Page

    Map View

    If you travel a lot, this view will be pretty helpful, since it provides you with possibility to combine the event description wit the marker on the map. This view uses Google Maps, so this time besides the Map View JavaScript file, we should include the required Google Maps file:

    <script src="http://maps.google.com/maps/api/js?sensor=false"></script>
    <script src="./codebase/ext/dhtmlxscheduler_map_view.js"></script>

    Don’t forget to add the Map view tab to your page:

    <div class="dhx_cal_tab" name="map_tab" style="right:280px;"></div>

    And remember that it’s alway possible to rename it:

    scheduler.locale.labels.map_tab = "My Map";

    The next step is Lightbox configuration. Lightbox is an edit form used to alter the event’s details. Here’s how it looks like by default:

    Lightbox

    As you can see, there’s no possibility to specify the location. Let’s fix it:

    scheduler.config.lightbox.sections=[    
       {name:"description", height:50,map_to:"text", type:"textarea", focus:true},
       /* adding new textarea */
       {name:"location", height:43, map_to:"event_location", type:"textarea"},
       {name:"time", height:72, type:"time", map_to:"auto"}    
    ];

    Done. Now you able to add the location information to your events.

    Here’s how the Map view works:

    Map View

    There are two areas: a list of upcoming events and Google Map that shows the event’s location. To create a new event, you can double click on an empty cell of the list or the desired location on the map:

    Lightbox in Map View

    After you create the event, it will appear on the list, and a new marker will be added to the map. You can click on the ‘details’ icon on the left side of the event’s description to edit or delete it. To overview the event, click the marker:

    Marker in Map View

    Learn more: Map View Documentation Page

    dhtmlxScheduler is a JavaScript Schedule Calendar that gives you the ability to develop Google-like event calendar in your application. Using dhtmlxScheduler, you may build agenda, appointment, week calendars, and more others. Get learn about our JavaScript scheduler control in its documentation and start using it now.

    dhtmlxSuite 4.5.1 and dhtmlxVault 2.4.1 – Hot Fixes Released

    $
    0
    0

    Thanks to our client’s reports, we were managed to determine and fix some important issues in dhtmlxForm and dhtmlxVault components. So, you are welcome to update your Suite (or just Form) packages to the version 4.5.1 and Vault to the version 2.4.1.

    Hotfix-vault-suite

    This Hot Fix includes fixing of XSS vulnerability in swf that was found in dhtmlxVault and dhtmlxForm.

    Moreover, dhtmlxVault got other fixes, in particular:

    • delayed UI refresh on upload is fixed
    • setSizes fixed when vault attached to a cell in web skin
    • integration with sidebar demo added
    • demos cosmetic fix

    You may download the Standard Edition of dhtmlxSuite, dhtmlxForm and dhtmlxVault.

    PRO users need just to re-download the packages of dhtmlxSuite 4.5, dhtmlxForm 4.5 and dhtmlxVault 2.4 using the same link.

    We’d like to thank our clients for this important report one more time. We highly appreciate your participation in our libraries’ life.

    dhtmlxGantt 4.0 is Rolling Out: Meet New Fast Gantt

    $
    0
    0

    Let’s finally begin a fresh chapter of dhtmlxGantt history – we release the version 4.0, a major and quite important update of the library. It brings you smart rendering feature, undo-redo functionality, and more. Below you’ll find more details. Dive in!

    dhtmlxGantt 4.0

    Smart Rendering

    100, 1000, 10000 and more tasks are not a problem anymore. The rendering of tasks became much and much faster due to the mode that allows not to load all tasks at once but render them as far as they appear on the screen.

    Moreover, even if your project with gantt doesn’t contain thousand of tasks, the rendering time will be increased since 4.0 due to optimization of loading and rendering in general.

    Smart rendering in Gantt

    Undo/Redo Extensions

    Since dhtmlxGantt 4.0, all the actions made to gantt can be undone and redone. You may now make changes to your gantt without worry of how to return everything back.

    API changes

    Besides new features, the update brings quite big changes and cleanup of the component API. The aim of these changes is to make the component structure clearer and more coherent. In particular, the changes concern the following:

    – Most used helpers, such as dhtmlxMessage, dhtmlxDataProcessor and dhtmlxAjax has been added to gantt namespace.

    – Legacy code has been removed from the component, as a result it no longer pollutes the global namespace with unnecessary variables and functions.

    All of this brings two main benefits:

    1) Gantt documentation becomes more complete and covers all aspects of work with dhtmlxGantt.
    2) The component doesn’t have any API or CSS conflicts with dhtmlxSuite or dhtmlxScheduler libraries.

    Migration to dhtmlxGantt 4.0

    dhtmlxGantt 4.0 contains fallbacks for older API and is backward compatible with the code written for the previous versions.

    This means that most likely you won’t need to modify any of your existing code in order to update component, although we advise to make some changes for compatibility with the next major update (5.0). You may find the migration guide here.

    If you have any problems with migrations, feel free to open a ticket, submit your questions on forum or send us an email to support[at]dhtmlx.com.

    Full what’s new list with detailed description is available in our documentation. You can download Standard Edition of dhtmlxGantt here. PRO users will get the newsletter with the updated version soon.

    We are looking forward to hear your feedback!


    dhtmlxSuite 4.6: Big Christmas Bug Fixes and Promised Today Button

    $
    0
    0

    “It is not considered respectable to spend the New Year with debts” DHTMLX dev team thought and fixed all known bugs that were found in 4.5. So, meet dhtmlxSuite 4.6 that works better and more stable.

    dhtmlxSuite 4.6

    Today and Clear Buttons in dhtmlxCalendar


    But it won’t be 4.6 without new feature. And based on your votes in our roadmap we realized that we definitely must add Today and Clear Buttons to dhtmlxCalendar.

    Today-Clear Buttons in dhxCalendar

    Multiple fixes and improvements


    Like was already said, this update comes with lots of bug fixes and improvements. Due to your reports, we were managed to find all these fixes. Full list of them can be found here.

    Download the Standard Edition here.

    What’s next


    Meanwhile, DHTMLX Team is working hard on new major update – dhtmlxSuite 5.0. Check out our roadmap and take a part in voting for the new functionality.

    DHTMLX Little-Known Features: Custom Column Type in Grid

    $
    0
    0

    In this article, we would like to continue to share with you small tips and tricks that allow you use DHTMLX components more efficiently and enjoy every single minute you spend with our library.

    This time, we’ll talk about dhtmlxGrid. It’s a full-featured JavaScript grid control that provides advanced functionality, powerful data binding, and fast performance with large data sets. This component gives you a possibility to specify the content type for a column. There is a plenty of available column types from a simple editable text field to date picker. But what if provided functionality is not enough for you? Well, it’s always possible to use custom column type. Let’s look at some examples.

    Grid custom columns

    First of all, let’s talk about the basic initialization. You can check this documentation page for the details, but for now, this initialization sequence is what we need:

    myGrid = new dhtmlXGridObject('gridbox');
    myGrid.setImagePath("./codebase/imgs/");
    myGrid.setHeader("Sales, Book Title, Author, Price");
    myGrid.setInitWidths("70,230,230, *");
    myGrid.setColAlign("right,left,left,right");
    myGrid.setColTypes("dyn,ed,ed,price");
    myGrid.setColSorting("int,str,str,int");
    myGrid.init();
    myGrid.load("./data.json","json");

    What we’re particularly interested in is this line of code:

    myGrid.setColTypes("dyn,ed,ed,price");

    This is where you define what column types you want to use. In this case we’ve created one dyn column that applies different coloring and marking based on the value, two simple column with editable cells that can be created using the ed parameter, and a price column that treats data as price.

    The result is shown below:

    Grid custom columns

    As you can see, the dollar sign is used by default in the Price column. In case, you already have an array of data you want to use and such behavior is not what you expected, you can create your own column type.

    Let’s start from read-only cells. For example, we want use euros as a currency. Here’s the code:

    function eXcell_myPrice(cell){ //the eXcell name is defined here
        if (cell){                // the default pattern, just copy it
            this.cell = cell;
            this.grid = this.cell.parentNode.grid;
        }
        /* read-only cell doesn't have edit method */
        this.edit = function(){}  
        /* the cell is read-only, so it's always disabled */
        this.isDisabled = function(){ return true; }
        this.setValue=function(val){
            /* actual data processing */
            this.setCValue("<span>&#8364; </span><span>"+val+"</span>",val);                                      
        }
    }
    /* nests all other methods from the base class */
    eXcell_myPrice.prototype = new eXcell;

    The most important parts in this code are the name of the new type and data processing formula. To use this newly created cell type you can change this line:

    myGrid.setColTypes("dyn,ed,ed,myPrice");

    Here’s the result:

    Grid custom columns

    If you want to add a possibility to edit the cells, you should do the following:

    • add to your new cell an option to use methods of the “ed” type;
    • define the getValue() method that returns the current cell value; it may be used by standard API, and it’s necessary for a normal edit operation;
    • define the edit() method that is called when the grid is switched to the edit state (not declared explicitly, nested from the ‘ed’ type);
    • define the detach() method that is called when the grid is switched back to the normal state (not declared explicitly, nested from the ‘ed’ type);

    So, here’s the minimal amount of code required to add the editing feature:

    function eXcell_myPrice(cell){ //the eXcell name is defined here
        if (cell){                // the default pattern
            this.cell = cell;
            this.grid = this.cell.parentNode.grid;
            eXcell_ed.call(this); //uses methods of the "ed" type
        }
        this.setValue=function(val){
            /* actual data processing */
            this.setCValue("<span>&#8364; </span><span>"+val+"</span>",val);                                      
        }
        this.getValue=function(){
            /* getting the value */
            return this.cell.childNodes[1].innerHTML;
        }
    }
    /* nests all other methods from the base class */
    eXcell_myPrice.prototype = new eXcell;

    Now, newly created cell type is editable:

    Grid custom columns

    Both edit() and detach() methods are not declared explicitly in this case. But you can always define them by yourself if you want to enable some extra functionality. To learn more about the custom cell types, check this documentation page.

    5 Main News Events Happened in 2015 [Infographic]

    $
    0
    0

    2016 is getting closer, many new updates and news will be released for you, but now we’d like to sum up the outgoing year. Here is our 2015 in infographic:

    Main events of dhtmlx in 2015

    1) dhtmlxSuite updated 5 times! These updates brought us three new components – Sidebar, Carousel and List. Besides, lots of new features were added and many improvements were made.

    2) dhtmlxGantt has grown to the version 4.0! The control greatly extended its functionality – tasks grouping, auto-scheduling, multi-selection, fullscreen mode, smart rendering and many other new features made our gantt chart more powerful.

    3) 7 new tutorials and tools! They are developed to help you to use our components with other technologies and frameworks including MeteorJS, Firebase, Ruby on Rails, Laravel, and Yii 2.

    4) 2 new macro components! dhtmlxDataSelector and dhtmlxFileSelector were developed to simplify the process of work with your database and file system.

    5) We shared 2 public roadmaps! Two trello boards with our plans and your wishes of future functionality of dhtmlxGantt and dhtmlxSuite are available for voting and your active participation in libraries’ lives.

    See you in 2016! ;)

    Five Main News Events Happened in 2015 [Infographic]

    $
    0
    0

    2016 is getting closer, many new updates and news will be released for you, but now we’d like to sum up the outgoing year. Here is our 2015 in infographic:

    Main events of dhtmlx in 2015

    1) dhtmlxSuite updated 5 times! These updates brought us three new components – Sidebar, Carousel and List. Besides, lots of new features were added and many improvements were made.

    2) dhtmlxGantt has grown to the version 4.0! The control greatly extended its functionality – tasks grouping, auto-scheduling, multi-selection, fullscreen mode, smart rendering and many other new features made our gantt chart more powerful.

    3) 7 new tutorials and tools! They are developed to help you to use our components with other technologies and frameworks including MeteorJS, Firebase, Ruby on Rails, Laravel, and Yii 2.

    4) 2 new macro components! dhtmlxDataSelector and dhtmlxFileSelector were developed to simplify the process of work with your database and file system.

    5) We shared 2 public roadmaps! Two trello boards with our plans and your wishes of future functionality of dhtmlxGantt and dhtmlxSuite are available for voting and your active participation in libraries’ lives.

    See you in 2016! ;)

    Things You Should Know About Building Web Application in 2016

    $
    0
    0

    Sometimes being a pioneer in your sphere of activity is a key to success. On the other hand, your strategy could be based on a clear and profound understanding of previous experience and strict adherence to the current trends and tendencies. Sounds reasonable, too.

    web app development trends 2016

    Despite the chosen recipe, it’s always helpful to summarize what trends were on the rise during the year. Such knowledge can help you predict tomorrow’s fashion in the world of web development and be on the crest of the wave. That’s why we collect some of the most significant trends that you should keep in mind if you plan to build web applications in 2016. It’s not a “Web Development 101” article. More like a list of things that we noticed during the year as web developers. We hope it will be helpful to you.

    UI and UX

    It seems like a course to minimalism that we can observe in web design nowadays is a serious thing. Leave nothing but the essential elements on your page is how this rule looks like in a nutshell. Such approach reduces the loading time that is great in case of mobile applications. Since user interface doesn’t overload with tons of elements it’s easier to develop clean and responsive application that is, once again, a plus in case of mobile users.

    We could say that flat design is an embodiment of the minimalist approach. And even if there were any doubts about the fact that flat design is on the rise, after the release of the latest versions of iOS and Android, it received the attention it deserved. It looks fresh and clean both on mobile devices and big screens. Based on this we also think about new skin for dhtmlxSuite to provide the library fresh and modern look.

    Since minimalist and neat looking web applications hold more and more prominence, it’s natural that bright colors become the primary means of expression. It’s a good decision to personalize your app through the combination of bright colors. Look around you and you’ll see this is not just a web thing. For example, fashion and interior design follow the same trend. So, if people want to see rainbows of bright colors, why not to use the same approach in the web? But you should always keep in mind that knowing of limits is the must. There’s no need turn your web page into the palette of acid colors.

    Single page apps are the kings of the web. “Less click. More scroll” This is how one of the most important rules of web design looks like. Probably the main reason behind the fact that single page solutions are so popular is a sustainable reluctance of a mobile user to click again and again to get deeper into a site. As well as the fact that the parallax scrolling looks just awesome.

    Animation can draw the eye or engage a user during the loading process. The animated menu that appears on the screen confirms the action’s success. Moreover, it shows the user where on the menu they can view the window later.

    Mobile Web

    It’s not a secret that the overall number of mobile devices in web grows from year to year. You can check this article on Mobile Marketing Statistics 2015 to get some info about the current state of things. And here are some tips that could help you be at ease in case you decide to build a mobile version of your app.

    Think about the advanced responsiveness. There is a large amount of mobile devices of different shapes and sizes. Your job is to be completely sure that your application will look as it was initially designed on every single one of them. Buttons should be big enough to tap them comfortably, navigation should be easy to access, and information should be presented in accessible and easy-to-digest format. We start working hard on responsiveness of DHTMLX library and will continue improving it.

    web app development trends 2016

    Reduce the size of your CSS and JavaScript files. If you use CSS frameworks like Bootstrap, you should remember that they can be pretty large and contain unused code that increases the loading time. To avoid this problem you can uses special tools that remove the code you don’t use. Take a look at uncss for example. But remember that uncss can’t pick up dynamic styles. We can say the same thing about your JavaScript code. It’s a good practice to use variable names that make sense to a human. Such approach simplifies the code maintenance. But variable names don’t affect the way your application works. So, why don’t use short equivalents instead of full-length variable names? You can use uglify, the tool that makes your JavaScript code unreasonable for a human mind, but usually much smaller.

    When using dhtmlxSuite, we advice you to use libCompiler to reduve the size of you .js/.css files. It will be helpful in case if you don’t use all the components of the library but only some of them.

    Other Useful Tips

    Let’s continue with some general advice you should keep in mind during the development process.

    Let’s start with the security. When a user signs up, send him an e-mail with a link that can be used to confirm its e-mail address. In case the user changes the e-mail address, repeat this operation. When you work with passwords, you should salt and hash them first. Despite the known problems with certificates, there’s nothing better than good old SSL. You should use it along with HSTS. Don’t check server credentials (e.g., database passwords, API keys, etc.) into source control.

    NoSQL databases are something you should pay attention to. It’s a technology that developers use more widely during the last couple of years. It was developed to match the scale at which data is being produced and accessed. New storage and processing methods require a faster response and better performance and power. Probably, we won’t see the full switch to noSQL databases the next year, but you definitely should learn more about this technology.

    Don’t forget about the Internet of Things. Designers and developers need to take the challenge of designing and developing for cars, robots and LCD’s.

    That’s all for today. We hope that this article provides you with some useful info. One more thing before saying good bye. You should always remember that your primary intention is to create something that based primarily on the upon the needs of your users. There’s no need to stay trendy despite the end-user opinion.

    The post Things You Should Know About Building Web Application in 2016 appeared first on DHTMLX Blog.

    Using dhtmlxGantt with Laravel Framework [Tutorial]

    $
    0
    0

    Our developers always try to provide you with the possibility to use our components in different ways. In this article, we’ll talk about dhtmlxGantt. We’ll learn how to use this component with the Laravel framework. Laravel is a free, open-source PHP web application framework. Laravel was created for the development of web applications following the model–view–controller (MVC) architectural pattern.

    laravel+gantt-img

    It will be a step-by-step guide intended both for developers who have already been familiar with Laravel and those of you who only starts working with it.

    Installing Laravel

    We’ll use Composer to install Laravel. It’s a dependency manager for PHP that allows you add required packages to your projects in a fast and easy way. Usually, you can find it in your Linux repository. In another case, you can download installation files from its home page.

    To learn how you can install Laravel, you can follow this installation guide. Here’s one of the available opportunities. First of all, we need to create a folder for our project and download the Laravel packages. Run in your terminal:

    composer create-project  laravel/laravel --prefer-dist dhtmlxGantt

    This code will create the dhtmlxGantt folder and load the Laravel files along with its dependencies into it.

    Now we need to add dhtmlxConnector to our project. It’s a helper server-side library that enables access to external data sources and backend systems. To do so, enter the working directory and add the required package using Composer:

    cd dhtmlxGantt
    composer require dhtmlx/connector-php

    One more thing before getting started. Download the dhtmlxGantt package and unpack its content within the public/dhtmlxGantt directory.

    That’s it. Preparations are finished, and we can continue creating the Gantt chart.

    Create a Data Source

    As an example, let’s use a previously created database. Here’s the direct link to a zip archive that contains the project that you can use as an example of how different DHTMLX components can work with Laravel. Inside you can find an SQL dump file named dhtmlx_samples.sql. Let’s use it to create a local database copy. In case of MySQL you should run the client:

    mysql -u root -p

    Now you can create a new database and import the data from the dump file:

    CREATE DATABASE gantt;
    USE gantt;
     \. /path/to/file/dhtmlx_samples.sql

    Done. The database is created. Our next step is to create a the Gantt chart itself.

    Create the Gantt Chart

    As it was said before, Laravel follows the MVC architectural pattern. Since MVC means Model-View-Controller, the process of creation will consist of three main stages.

    Create a Model

    To access the data we need to specify the appropriate model class. You should create two files within the app directory of your project.

    The first one is GanttTask.php:

    <?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;

    class GanttTask extends Model
    {
        protected $table = "gantt_tasks";
        public $primaryKey = "id";
        public $timestamps = false;
    }

    And here’s the second one, GanttLink.php:

    <?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;

    class GanttLink extends Model
    {
        protected $table = "gantt_links";
        public $primaryKey = "id";
        public $timestamps = false;
    }

    Create the View Object

    Create a new file with name gantt.php within the resources/views directory of your project. Then and add the following code:

    <!DOCTYPE html>
    <head>
        <meta http-equiv="Content-type" content="text/html; charset=utf-8">
        <script src="dhtmlxGantt/codebase/dhtmlxgantt.js"></script>
        <link rel="stylesheet" href="dhtmlxGantt/codebase/dhtmlxgantt.css">
    </head>

    <body>
        <div id="gantt_here" style='width:100%; height:250px;'></div>
        <script type="text/javascript">
            /* chart configuration and initialization */
            gantt.config.xml_date = "%Y-%m-%d %H:%i:%s";
            gantt.config.step = 1;
            gantt.config.scale_unit= "day";
            gantt.init("gantt_here", new Date(2010,7,1), new Date(2010,8,1));
            /* refers to the 'data' action that we will create in the next substep */
            gantt.load("./gantt_data", "xml");
            /* refers to the 'data' action as well */
            var dp = new gantt.dataProcessor("./gantt_data");
            dp.init(gantt);
        </script>
    </body>

    Create the Controller

    Now, let’s configure the Controller object. Before we go any further, let’s take a look at how GanttConnector works. Here’s an example:

    $connector = new GanttConnector(null, "PHPLaravel");
    $connector->render_links(new $modelName, $id, $links);
    $connector->render_table(new $modelName, $id, $tasks);

    The GanttConnector constructor takes 2 parameters: null means that we want to use a model, not a database; PHPLaravel – the module for working with PHP.

    The render_links method configures connector, retrieves data from a table with links and takes three parameters: the method creating a model for links, the name of the link id, and a comma-separated list of rendered links.

    The render_table method configures connector and retrieves data from a table with tasks. It takes three parameters as well: the method creating a model for tasks, the name of the task id, and a comma separated list of rendered tasks.

    To configure the Controller object you should create a new file named GanttController.php within the app/Http/Controllers folder:

    <?php
    namespace App\Http\Controllers;
    use App\GanttTask;
    use App\GanttLink;
    use Dhtmlx\Connector\GanttConnector;

    class GanttController extends Controller
    {
        public function data() {
            $connector = new GanttConnector(null, "PHPLaravel");
            $connector->render_links(new GanttLink(), "id", "source,target,type");
            $connector->render_table(new GanttTask(),"id","start_date,duration,text,progress,parent");
            }
    }

    Final Steps: Environment, Routes, and CSRF Protection

    There are three final steps left before you can test your application. Let’s start from the environment configuration. The .env file that resides in the root folder of your project will be used for that purpose. All that we need is to configure the database. Here are the four lines that we are interested in:

    DB_HOST=localhost
    DB_DATABASE=gantt
    DB_USERNAME=root
    DB_PASSWORD=yourpassword

    You should define the hostname, name of the database that we’ve created earlier, username, and a password to allow Laravel use the data from a database.

    The next step is to define the routes. Open the app/Http/routes.php file. Here’s the default routes configuration that you’ll find there:

    Route::get('/', function () {
        return view('welcome');
    });

    Here’s what it means, in a nutshell. When you open the root folder of your website in a browser, the GET request will be performed. As a result, the welcome page from the resources/views folder will be returned. In fact, the name of this file is welcome.blade.php but Laravel disregards file extensions. What we need to do is to tell Laravel that the previously created view, gantt.php, should be returned. The other step is to use GanttController.php to save and load data. All you need to do is to replace the existing route with the following:

    Route::get('/', function () {
        return view('gantt');
    });

    Route::match(['get', 'post'], '/gantt_data', "GanttController@data");

    One more step before we can run the project. Laravel protects your application from cross-site request forgeries by generating a CSRF “token” for each active user session managed by the application. You can read more about the mechanisms of protection on this page if you want, but what we need to do now is to exclude one particular URI from CSRF protection. The one that triggered when created data is supposed to be saved. We need to add a proper value to the $except property:

    protected $except = [
        'gantt_data'
    ];

    That’s it! Now we can test the application.

    Running the Application

    Open the root directory of your project and run:

    php artisan serve

    Here’s the typical output:

    Laravel development server started on http://localhost:8000/

    Open http://localhost:8000/ in your browser and you’ll see the working Gantt chart:

    Gantt chart with Laravel

    Here are the tasks from the database dump file that we’ve imported earlier. You can edit them or create your own, using the “+” button.

    That’s all. We hope you have enjoyed the tutorial. The final application logic was not the goal of this article, but the interface built here is a good start for creating a fully-functional web application.

    The post Using dhtmlxGantt with Laravel Framework [Tutorial] appeared first on DHTMLX Blog.

    DHTMLX Little-Known Features: How To Save Login/Password in Browser

    $
    0
    0

    From time to time we are asked to offer an easy way to use real HTML form with dhtmlxForm. So we’d like to share this tip with you and show you the working sample of login form that forces a browser to save credentials for login/password form.

    Login/password form

    Here is a complete demo (Enter “admin / 1” login details to check it). If you want to know how to make it in your application, continue reading this mini tutorial.

    Step 1.

    First of all, let’s create a real html form:

    <form id="realForm" action="check.php" method="POST"></form>

    Do not add inputs into it, this will be done by dhtmlxForm.

    Step 2.

    Add hidden iframe on page to submit real form without the page reloading:

    <iframe border="0" frameBorder="0" name="submit_ifr" class="submit_iframe"></iframe>

    And you need some css to hide it from eyes:

    <style>
        iframe.submit_iframe {
            position: absolute;
            width: 1px;
            height: 1px;
            left: -100px;
            top: -100px;
            font-size: 1px;
        }
    </style>

    Step 3.

    Add target attr to form to force submit to the hidden iframe:

    <form id="realForm" action="check.php" method="POST" target="submit_ifr"></form>

    Step 4.

    Now it’s time to add dhtmlxForm:

    var formData = [
        {type: "settings", position: "label-left", labelWidth: 75, inputWidth: 150},
        {type: "block", blockOffset: 30, offsetTop: 15, width: "auto", list: [
            {type: "label", label: "Please introduce yourself", labelWidth: "auto", offsetLeft: 35},
            {type: "input", label: "Login", name: "dhxform_demo_login", value: "", offsetTop: 20},
            {type: "password", label: "Password", name: "dhxform_demo_pwd", value: ""},
            {type: "button", name: "submit", value: "Let me in", offsetTop: 20, offsetLeft: 72}
        ]}
    ];
    var myForm = new dhtmlXForm("dhxForm", formData);

    Step 5.

    Add an event handler for submitting (here instead of dhtmlxForm we’ll submit the real form):

    myForm.attachEvent("onButtonClick", function(name) {
        if (name == "submit") {
            document.getElementById("realForm").submit();
        }
    });

    Step 6.

    Here is the server side code you need:

    <?php
    header("Content-Type: text/html; charset=utf-8");

    if (@$_REQUEST["dhxform_demo_login"] == "admin" && @$_REQUEST["dhxform_demo_pwd"] == "1") {
        $state = 1;
    } else {
        $state = 0;
    }

    print_r("<meta http-equiv='Content-Type' content='text/html; charset=UTF-8'/>");
    print_r("<script> try { parent.submitCallback(".$state."); } catch(e) {};</script>");
    ?>

    Final Step 7.

    Add submitCallback function on client which will parse server response:

    function submitCallback(status) {
        if (status == 1) {
            document.location.href = "secret.html";
        } else {
            // reset form
            myForm.setFormData({dhxform_demo_login: "", dhxform_demo_pwd: ""});
        }
    }

    As a result you have a login/password form that allows you to save credentials in browsers. We’ve set up our server so that if you enter the credentials “admin / 1” you’ll get to the secret page.

    login form with dhtmlxForm

    We hope this piece of information was useful for you; and feel free to use it in your applications. Share your comments below!

    The post DHTMLX Little-Known Features: How To Save Login/Password in Browser appeared first on DHTMLX Blog.


    dhtmlxSuite 4.6.1 with latest fixes and improvements is out [PRO]

    $
    0
    0

    We are glad to provide you bug fixes and improvements that were found in dhtmlxSuite 4.6. Full list of fixes can be found here.

    Moreover, small fixes were also added to dhtmlxGrid, dhtmlxTree and dhtmlxTreeGrid components.

    Suite update

    The updated version is available by the same link as dhtmlxSuite 4.6.1. So, just re-download the package.

    Based on our updated license policy, this update is available for PRO users only. Users of Standard Edition will be able to get these fixes in future minor or major update.

    The post dhtmlxSuite 4.6.1 with latest fixes and improvements is out [PRO] appeared first on DHTMLX Blog.

    Top Five Samples Show You Need to Choose dhtmlxGrid

    $
    0
    0

    If you’re not familiar with our grid component yet, then you should know that dhtmlxGrid is a js data grid control with a range of powerful features, fast performance and ability to work work with big datasets. dhtmlxGrid has such an extended functionality, but in this article we’ll point out top 5 samples that are most popular among our users.

    1. Using extended cells technology

    You can define the formatting for each column of the gridview in javascript and the editor to edit it. For more details and the list of available cell types check this documentation guide.

    cell types in grid

    2. Add/Delete Rows in Grid

    It’s surely one of the essential features for all JavaScript data grids. You can add rows to your grid any time by using API methods. You should specify the position where the row should appear. Deleting row is easy as well.

    Add-delete row

    3. Filtering

    Our grid library also provides an extension for filtering data on the client-side. You can set filter for different columns in grid.

    Filtering in grid

    4. Loading data from JSON

    Still the most used way for data loading is loading from JSON format, you can use 2 JSON formats – Basic and Native. Documentation can be found here.

    Loading data from JSON

    5. Loading big amount of data

    50,000 records in our js grid table is not a limit, but still check the sample and enjoy smooth performance. In this sample we put 50,000 records into a table in a Mysql database filled with random words. dhtmlxGrid using Ajax loads visible records only. Find related docs here.

    Big datasets

    Get 30-days free trial of PRO Edition of dhtmlxGrid

    With this grid javascript library, you can easily create nice-looking, js grid tables with in-cell editing, filtering, searching, and grouping and other capabilities. More samples can be found here.

    The post Top Five Samples Show You Need to Choose dhtmlxGrid appeared first on DHTMLX Blog.

    Behind the Scenes: On the Way to dhtmlxSuite 5.0

    $
    0
    0

    Time flies fast. Our JavaScript widget library is almost ready to be updated to the version 5.0. We want you to be aware of the current status of our hard work on this long-awaited update, so continue reading to get know how is it going.

    Suite 5.0

    As it was announced in dhtmlxSuite roadmap, we are going to release DHTMLX framework, new tree control and updated visual designer with form builder tool. Besides, we decided to provide a new skin based on Google Material design. So, in this article we’ll share our intermediate results with form builder and new skin.

    Online Form Creator

    We started to update Visual Designer with adding a form builder tool. You’ll be able to create any types of forms fast with less effort. Online form builder comes with the most useful functionality: drag and drop, import/export of created forms and live preview.

    Form Builder

    Do you want to get a beta version of the form builder? Contact us.

    DHTMLX Material

    Following modern tendencies and based on your votes, we decided to create a new skin for dhtmlxSuite controls.

    The users of our JavaScript UI library will get familiar look and feel of popular Google Material Design. Each element of our javascript ui controls is carefully analyzed by our designers, so the result must be worthy.

    Other important updates, such as DHTMLX Framework and TreeView component, are also ready and are passing the testing phase. Our plans are also available online here.

    More details about Suite 5.0 coming soon.

    The post Behind the Scenes: On the Way to dhtmlxSuite 5.0 appeared first on DHTMLX Blog.

    dhtmlxScheduler 4.3.25: Maintenance Fix is Out [PRO]

    $
    0
    0

    For quite a long time we haven’t officially released any updates of our JavaScript Scheduler though the work on its improvement wasn’t stopped. So, now we’d like to announce a release of more stable version of dhtmlxScheduler, the version 4.3.25.

    Scheduler fix

    What’s fixed in dhtmlxScheduler 4.3.25:

    • Touch support – trigger tap and double tap on multiday area of Day/Weeks/Units views
    • Touch support – fix regression with event disappearing on start of touch-drag
    • Timeline – fix onYScaleClick call when ignored columns are defined
    • Timeline – fix incorrect state of event object after canceling drag and drop
    • Tree Timeline – timeline_scale_class template should be applied to folder items
    • dataProcessor – clearing scheduler while dataProcessor request is in progress should not cause JS error
    • dataProcessor – fix incorrect state when adding and modifying recurring series when autoUpdate is disabled
    • Day/Week views – fix event visibility when first/last hours of calendar are enabled
    • Multiday Units View – fix default section on creation event with a double click
    • General – occasional Chrome bug, when click and double click events stopped firing
    • General – fixes for daylight savings time bugs in Safari
    • and many other small fixes


    Need to say, this update won’t bring any new functionality, but provide seamless performance and be free from small issues and bugs that appeared in 4.3.1. Based on our updated license policy, this update is available for PRO users only. Users of Standard Edition will be able to get these fixes in future minor or major update.

    The post dhtmlxScheduler 4.3.25: Maintenance Fix is Out [PRO] appeared first on DHTMLX Blog.

    Wrappers for Suite Components from an AngularJS Fan

    $
    0
    0

    Emanuil Glavchev made an important contribution that many dhtmlx users were looking for. He has created wrappers for some of the DHTMLX library controls that enables using it with AngularJS Framework. So, most popular Suite controls, such as Grid, Tree, Layout, Form and more other can be now easily used in your Angular + DHTMLX projects.

    angular+dhtmlx

    Continue reading to learn about Emanuil’s contribution and the work he has done.

    “What these directives represent are the wrappers for some of the DHTMLX components. As I require more of them I add more to the project. Each directive provides an interface to the underlying dhtmlx components. That interface in most cases does not encompass the complete API. I’ve handled the issue in 2 ways: one is letting the directive user get access to the underlying object at important times in its lifetime (in order to manually configure it additionally, or manipulate its data), whereas another way is registering the object in the controller scope usually via the dhxObj/dhx-obj attribute.

    Find the described wrappers on GitHub

    Despite that, I try to include in the directives interface all that I’m likely going to need most of the time. This is done because I mostly use DHTMLX+Angular.js for fast creation of prototype web applications, and it is really much easier when a component can be fully defined in the template without requiring additional code configuration in the controller other than attaching the actual data, which for prototyping purposes can also be often inlined in the template.

    I’ve tried to add comments where absolutely necessary, however usually I stick quite close to the actual DHTMLX Api of the underlying components, which means of course you need to have DHTMLX handy. I find it important that for each directive, a demo exists in this application. This serves 2 purposes.

    First it serves as a sort of environment in which all the directives can be easily tested. Secondly, the very application showcases the directive code, as well as the actual demo code that gets executed before one’s eyes. That makes the demo app not only into a testing environment, but also a sort of handbook, to which I often refer to remember how the directives are used. Naturally, as I add more directives or expand the functionality of the existing ones, I will update the demos accordingly to reflect this new functionality.

    Final Note: Not being a professional Javascript/Angular.js developer, I do not claim to follow completely the established good principles of design, functionality and codestyle, but always remain open to correction and improvement. If anyone feels like they have something to add to any part of this and they want to share their knowhow, they will be most welcome.”

    Note that to use it in commercial projects, you need to obtain appropriate license.

    We want to thank Emanuil Glavchev one more time. You may find Angular+DHTMLX demos here. You are welcome to leave your comments and suggestions!

    The post Wrappers for Suite Components from an AngularJS Fan appeared first on DHTMLX Blog.

    Viewing all 228 articles
    Browse latest View live