About configuration constants, personally I like your solution (static public properties used to initialize the class before instantiating it), as it encapsulates the control configuration into the control class itself, which seems a pretty clean solution to me. But maybe that's a matter of taste, other developer would like more using always global constants as they can be uniformly set/maintained in a centralized initialization script. Your solution, however, allows to initialize the class both from inside (by overriding a property value) and from outside (by setting its value in an initialization script), so it seems very convenient to me.

QPM packages are not included into the framework itself because they are intended to be optional extensions of the framework, as “pluggable” features. I see some reasons to not include them into the Qcodo distribution.

- Extensiblility.
Extensiblility is virtually infinite, more and more classes/features can be added in the future. I'm pretty sure that the framework file/folder organization and configurability would suffer if we all include our personal development/maintenance tastes into the framework distribution.

- Optionality.
The current implementation gives the option of including a specific package or not. Think about someone not needing your control in his application, with the current QPM implementation he has the option of not including it at all.

- Variety.
Maybe two controls have the same features, so there's no need to include both in the distribution. You can opt for some control made by one developer, but not for the same control made by another.

- Versions.
There can be a specific control that has different versions for (let's imagine) PHP 5.2 and PHP 5.3, or different versions for Windows and Linux servers, or simply different versions with different features/uses. That versions can be opted as packages when needed, instead of merging them into the framework and forcing the developer to unnecessarily deploy all them.

All in all, QPM packages are like software plugins. If you need or like one, you use and deploy it. But if you don't need or like another, you are not forced to use and deploy it.

Eventually, if one plugin turns to be necessary or a really “must have” feature, it can be included into the core distribution. But that's not the primary idea of plugins.

And of course following the Qcodo Coding Standards
http://www.qcodo.com/wiki/qcodo/development/contribute

I don't have a problem creating a column using the first array but when I try to change the DataSource to the second array it just overwrites everything in the first column.

I've tried doing it as a 2 Dim array but can't get it to call a specific array inside my 2D array, instead it only uses the information from both arrays from the specified index.(I.E Array ( [0] => Array ( [0] => stuff [1] => Other [2] => last ) [0] => Array ( [0] => 2 [1] => 1 [2] => 1 ) ) When I specify Index 0 i presumed it would give me the array from index 0 and print the three indexes from that array, instead it gives me Stuff, and 2 the index 0 for both arrays inside the parent array. moreover it only creates a column with 2 rows despite me having multiple indices I presume that has to do with my DataSource only having to $_ITEM's inside it.

I apologize for the uber noob question but could really use some help.

If you're using the optimized/packed JS file by explicitly including it on the page and overriding the includes in QForm's protected $strIgnoreJavaScriptFileArray, then your site will use the packed file and (yes) editing control_dialog.js will have no effect whatsoever.

So if you're wanting to make manual edits to any of the JS files, it's best that you remove any <script> type of reference to the _qc_packed.js file, and ensure that QForm is NOT ignoring the include of any core/framework JS files.

The current implementation of codegen only allows you to define the relationships within a database... but of course, you could likely poke around in the code and make mods to it so that it can recognize and start to gen across different databases.

In other words, if I have table 'form' that has a foreign key to 'user' table (both in the same database with foreign keys defined in the database), I can access the user object from a form object ($objForm->User); so I get a User object generated within the Form data class for me.  However if I split the two tables between databases and use virtual foreign keys within the codegen_settings.xml file all I get is a UserId property generated in the Form data class and not a reference to the User node.

Can the codegen generate the User objects/nodes in my Form data class using virtual foreign keys or is that not coded into the functionality?

many thanks

Stupid me :-)

Sure helps. But what if the user has entered both field 1 and 2? Or 2 and 3? Or 1 and 3...

You get the point.

The current solution only supports one filter.

Best regards
Geert

So something like:

    $objCondition = QQ::All();

    if ($txtFilter1->Text) {
        $objCondition = QQ::AndCondition($objCondition, QQ::Equal(QQN::Foo()->Bar, $txtFilter1->Text);
    }

    if ($txtFilter2->Text) {
        $objCondition = QQ::AndCondition($objCondition, QQ::Equal(QQN::Foo()->Bar, $txtFilter2->Text);
    }

    if ($txtFilter3->Text) {
        $objCondition = QQ::AndCondition($objCondition, QQ::Equal(QQN::Foo()->Bar, $txtFilter3->Text);
    }

    // Etc.

hope that helps...

I need one that doesn't reposition itself to the middle but scolls up with the rest of the page. I've worked on _core/control_dialog.js but I can't seem to override/change the default behaviour. Many thanks in advance.
Mike

I'm trying to create an advanced search function for my users. The idea is simple, the can combine 2 listboxes an 2 textboxes (with dates) to filter a list of reports.

This is how it goes:

“I'd like to see all reports from <<lstUsers>> for the <<lstPatients>> that were entered between <<dttStartDate>> and <<enddate>>”

Creating the above is no problem. However how do I create the logic behind it.

this is my first try:
bc.
<?php
   $QQfilterClause = array();
                   if($this->lstFilterPatients->SelectedValue !== null){
                       array_push($QQfilterClause,QQ::Equal(QQN::Vpc()->PatientID,$this->lstFilterPatients->SelectedValue));
                   }
                   if($this->lstFilterUsers->SelectedValue !== null){
                       array_push($QQfilterClause,QQ::Equal(QQN::Vpc()->CreatedBy,$this->lstFilterUsers->SelectedValue));
                   }
                   /*
                    * Start and endtime
                    *
                    */
                    $arrDateParts = explode('.',$this->dttFilterStartTime->Text);
                    $dttFilterStartDate = new QDateTime(QDateTime::Now);
                    $dttFilterStartDate->setDate($arrDateParts[2], $arrDateParts[1], $arrDateParts[0]);

                    $arrDateParts = explode('.',$this->dttFilterEndTime->Text);
                    $dttFilterEndDate = new QDateTime(QDateTime::Now);
                    $dttFilterEndDate->setDate($arrDateParts[2], $arrDateParts[1], $arrDateParts[0]);
               
                    array_push($QQfilterClause,QQ::GreaterOrEqual(QQN::Vpc()->VpcDate, $dttFilterStartDate));
                    array_push($QQfilterClause,QQ::LessOrEqual(QQN::Vpc()->VpcDate, $dttFilterEndDate));

                    $arrVpcs = Vpc::QueryArray($QQfilterClause);
                    $this->dtgVpcs->DataSource =$arrVpcs;
                    $this->dtgVpcs->Refresh();
?>
.bc

The QueryArry doesn't accept the array with the conditions.

Any help is most appreciated

But if you really think that “it's time for an upgrade again”, the code of the Qcodo web is free. You can alter and modify it as much as you want, and then push your modifications to its main branch using GitHub.

I haven't had the need of modifying my event handler at the time or writing. Although I think that at this point some other JS frameworks may have better solutions, but I suspect that all them have solutions centered either in DOM2 events or in DOM1 events, never in both.

Basically:
- It allows to assign and manage crossbrowser listeners. It adds and removes DOM2 events to HtML objects, as almost any JS framework does.
- It triggers DOM1 and DOM2 events assigned to HTML objects, in this order. So when you trigger an event, the inline assigned events (that is, events in HTML attributes, as QCodo events for instance) are triggered first, and then the DOM2 events assigned with this same class.
- It works with arrays of HTML objects and/or with arrays of events, for convenience. A simple internal wrapper function is used for this purpose.
- It has an autocleanup routine to desassign DOM2 events on page unload. Particularly convenient in browsers that experience memory leaks by keeping in memory objects that have DOM2 events assigned.

Here's the code. Use it if you find it useful:

/**
 * JavaScript class to add, remove and trigger event handlers for events of controls.
 * - Makes crossbrowser listeners.
 * - The event object is always passed as parameter to the event handler function,
 *   and inside the function the 'this' keyword refers to the control that generated the event.
 * - Admits setting/removing/triggering event handlers for a single control or an array of controls,
 *   for a single event or an array of events.
 * - Admits both "click" and "onclick" syntax for events.
 * - Automatic cleanout of assigned event handlers on page unload.
 * - Triggers both event handlers set with this class (DOM2) and as inline HTML attributes (DOM1).
 * Limitations:
 * - Handlers must be named functions.
 * Thanks to:
 * - John Resig, for the original addEvent/removeEvent solution
 *   ( http://ejohn.org/projects/flexible-javascript-events/ )
 * - Kupu developers, for the ContextFixer object solution
 *   ( http://kupu.oscom.org/ )
 * Version 1.0 Copyright (C) Fernando Lordán, October 2006.
 * Distributed under the BSD License.
 */
if (typeof(eventManager) == 'undefined') {


function eventManagerContextFixer(func, context) {
    /* Make sure 'this' inside a method points to its class */
    this.func = func;
    this.context = context;
    this.args = arguments;
    var self = this;

    this.execute = function() {
        /* execute the method */
        var args = new Array();
        // the first arguments will be the extra ones of the class
        for (var i=0; i < self.args.length - 2; i++) {
            args.push(self.args[i + 2]);
        };
        // the last are the ones passed on to the execute method
        for (var i=0; i < arguments.length; i++) {
            args.push(arguments[i]);
        };
        self.func.apply(self.context, args);
    };
};


var eventManager = { initialize: function() {

    this.actionAdd = 1;
    this.actionRemove = 2;
    this.actionTrigger = 3;

    this.add = function(sNode, sEventType, fnHandler) {
        eventManager._wrapCall(sNode, sEventType, fnHandler, eventManager.actionAdd);
    };

    this.remove = function(sNode, sEventType, fnHandler) {
        eventManager._wrapCall(sNode, sEventType, fnHandler, eventManager.actionRemove);
    };

    this.trigger = function(sNode, sEventType, objWindow) {
        eventManager._wrapCall(sNode, sEventType, objWindow, eventManager.actionTrigger);
    };

    this._wrapCall = function(sNode, sEventType, objParam, iAction) {
        if (typeof(sNode) == 'object') {
            // Works with events of an array of controls.
            for (var i=0;i<sNode.length;i++) {
                eventManager._wrapCall(sNode[i], sEventType, objParam, iAction);
            };
        } else if (typeof(sNode) == 'string') {
            if (typeof(sEventType) == 'object') {
                // Works with an array of events of one control.
                for (var i=0;i<sEventType.length;i++) {
                    eventManager._wrapCall(sNode, sEventType[i], objParam, iAction);
                };
            } else if (typeof(sEventType) == 'string') {
                // Standarizes the event name.
                sEventType = sEventType.toLowerCase();
                if (sEventType.substr(0,2)=='on') {
                    sEventType = sEventType.substr(2,sEventType.length-2);
                };
                // Calls the convenient action.
                switch (iAction) {
                    case eventManager.actionAdd:
                        eventManager._add(sNode,sEventType,objParam);
                        break;
                    case eventManager.actionRemove:
                        eventManager._remove(sNode,sEventType,objParam);
                        break;
                    case eventManager.actionTrigger:
                        eventManager._trigger(sNode,sEventType,objParam);
                        break;
                    default:
                        throw "Invalid event action";
                        break;
                };
            };
        };
    };

    this._getNode = function(sNode, objWindow) {
        if (sNode) {
            if (sNode.substr(0,1) == "/") {
                // If node starts with "/", works with the specified literal instead of a control.
                var oNode = eval(sNode.substr(1));
            } else {
                if (typeof(objWindow)=="undefined") {
                    objWindow = window;
                };
                var oNode = objWindow.document.getElementById(sNode);
            };
            if (!oNode) {
                throw "Invalid control specified: '"+sNode+"'";
                return null;
            } else {
                return oNode;
            };
        } else {
            return null;
        };
    };

    this._add = function(sNode, sEventType, fnHandler) {
        // Gets the node where event will be added.
        var oNode = eventManager._getNode(sNode);
        if (!oNode) {
            return;
        };
        // There's a chance that we assign more than once the same handler function for the same event for the same control,
        // and it can be convenient because when a control is redrawn via .innerHTML it looses its event handlers.
        // IE doesn't keep track of repeatedly added event handlers, it simply adds them again, so we could fall into memory leaking and performance issues.
        try{
            if (oNode._nodeListeners) {
                if (oNode._nodeListeners[sEventType]) {
                    if (oNode._nodeListeners[sEventType][fnHandler]) {
                        return;
                    };
                };
            };
        } catch (oExc) {};
        if (oNode.attachEvent) {
            // Add event handler in IE, making possible to access the control object as 'this'.
            oNode['e'+sEventType+fnHandler] = eval(fnHandler);
            oNode[sEventType+fnHandler] = function() { oNode[eval("'e'+sEventType+fnHandler")](window.event); }
            oNode.attachEvent('on'+sEventType, oNode[sEventType+fnHandler]);
        } else {
            // Add event handler in Mozilla.
            oNode.addEventListener(sEventType, eval(fnHandler), false);
        };
        // Store event handler to remove on unload.
        if (!oNode._nodeListeners) {
            oNode._nodeListeners = new Object();
        };
        if (!oNode._nodeListeners[sEventType]) {
            oNode._nodeListeners[sEventType] = new Object();
        };
        if (!oNode._nodeListeners[sEventType][fnHandler]) {
            oNode._nodeListeners[sEventType][fnHandler] = true;
        };
        if (!document._docListeners) {
            document._docListeners = new Object();
        };
        if (!document._docListeners[sNode]) {
            document._docListeners[sNode] = oNode;
        };
        // Store handler reference to remove all event handlers on unload.
        if (!document._docListeners._cleanout) {
            if (oNode.attachEvent) {
                window.attachEvent('onunload', eventManager.cleanOut);
            } else {
                window.addEventListener('unload', eventManager.cleanOut, false);
            };
            document._docListeners._cleanout = true;
        }
    }

    this._remove = function(sNode, sEventType, fnHandler) {
        // Gets the node where event will be removed.
        if (!(oNode = eventManager._getNode(sNode))) {
            return;
        };
        if (oNode.attachEvent) {
            // Removes event handler in IE.
            oNode.detachEvent('on'+sEventType, oNode[sEventType+fnHandler]);
            if (oNode[sEventType+fnHandler]) {
                oNode[sEventType+fnHandler] = null;
            };
            if (oNode['e'+sEventType+fnHandler]) {
                oNode['e'+sEventType+fnHandler] = null;
            };
        } else {
            // Removes event handler in Mozilla.
            oNode.removeEventListener(sEventType, eval(fnHandler), false);
        };
        // Deletes the event handler from the list of event handlers to remove on unload.
        if (oNode._nodeListeners) {
            if (oNode._nodeListeners[sEventType]) {
                if (oNode._nodeListeners[sEventType][fnHandler]) {
                    oNode._nodeListeners[sEventType][fnHandler] = false;
                };
            };
        };
    };

    this._trigger = function(sNode, sEventType, objWindow) {
        // Will trigger events in current window if window not specified.
        if (typeof(objWindow)=="undefined") {
            objWindow = window;
        };
        // If window has been closed, returns.
        if (!objWindow || !objWindow.document) {
            return;
        };
        // Gets the node where event will be triggered.
        if (!(oNode = eventManager._getNode(sNode,objWindow))) {
            return;
        };

        // Constructs the event object to pass as parameter.
        objFakeEvent = new Object();
        objFakeEvent.type = sEventType;
        if (window.attachEvent) {
            // In IE, the "event.srcElement" property holds the control that issued the event.
            objFakeEvent.srcElement = oNode;
        } else {
            // Else, the control that issued the event is in the "event.target" property.
            objFakeEvent.target = oNode;
        };

        // Calls the DOM1 event handler set as a control property or as inline HTML attribute of the control, if any.
        if (((oNode.type == "checkbox") || (oNode.type == "radio")) && !!oNode[0]) {
            for (var i=0; i < oNode.length; i++) {
                fnHandler = eval("oNode[i].on" + sEventType);
                if (fnHandler) {
                    // This is explained below.
                    if (typeof(fnHandler) == "object") {
                        objHandler=fnHandler;
                        fnHandler=function(event){eval(objHandler+";event=objFakeEvent;anonymous();")};
                        dummy = new eventManagerContextFixer(fnHandler, oNode).execute(objFakeEvent);
                    } else if (typeof(fnHandler) == "function") {
                        dummy = new eventManagerContextFixer(fnHandler, oNode).execute(objFakeEvent);
                    };
                };
            };
        } else {
            fnHandler = eval("oNode.on" + sEventType);
            if (fnHandler) {
                if (typeof(fnHandler) == "object") {
                    // In IE, the handler is not stored as a function reference,
                    // but as an object that contains a function called "anonymous()", literally.
                    // Makes a wrapper function to call the anonymous function object and use the "event" variable inside it.
                    // Compatibility warning:
                    //   Inside the inline handler, the "event" variable will work, but "window.event" will not.
                    // Compatibility note:
                    //   In IE, inside an inline handler, the "this" keyword will refer to the calling window, not to a control.
                    //   This is the standard IE behaviour for inline event handlers. In IE just don't use "this", use "event.srcElement".
                    objHandler=fnHandler;
                    fnHandler=function(event){eval(objHandler+";event=objFakeEvent;anonymous();")};
                    // At this moment, calling the wrapper function directly or calling it through the context wrapper have the same effect,
                    // so both options are equivalent.
                    fnHandler();
//                    dummy = new eventManagerContextFixer(fnHandler, oNode).execute(objFakeEvent);
                } else if (typeof(fnHandler) == "function") {
                    dummy = new eventManagerContextFixer(fnHandler, oNode).execute(objFakeEvent);
                };
            };
        };

        // Calls all the DOM2 event handlers added for the event of the control.
        if (oNode._nodeListeners) {
            if (oNode._nodeListeners[sEventType]) {
                for (var fnHandler in oNode._nodeListeners[sEventType]) {
                    if (oNode._nodeListeners[sEventType][fnHandler]) {
                        if (window.attachEvent) {
                            // In IE, attach the event handler to the target control to be able to use the "this" keyword.
                            oNode._tmpHandler = eval("objWindow."+fnHandler);
                            oNode._tmpHandler(objFakeEvent);
                            oNode._tmpHandler = null;
                        } else {
                            // Else, just use the context wrapper.
                            dummy = new eventManagerContextFixer(eval("objWindow."+fnHandler), oNode).execute(objFakeEvent);
                        };
                    };
                };
            };
        };

    };

    this.removeAll = function() {
        // Removes all event listeners.
        if (document._docListeners) {
            for (var sNode in document._docListeners) {
                var oNode = document._docListeners[sNode];
                if (oNode._nodeListeners) {
                    for (var sEventType in oNode._nodeListeners) {
                        for (var fnHandler in oNode._nodeListeners[sEventType]) {
                            if (oNode._nodeListeners[sEventType][fnHandler]) {
                                eventManager._remove(sNode, sEventType, fnHandler);
                            };
                        };
                    };
                };
            };
        };
    };

    this.cleanOut = function() {
        // Removes all stored event handlers.
        eventManager.removeAll();
        document._docListeners = null;
        // Removes the event handler that removes all event handlers.
        if (window.attachEvent) {
            window.detachEvent('onunload', eventManager.cleanOut);
        } else {
            window.removeEventListener('unload', eventManager.cleanOut, false);
        };
    };

}};

em = eventManager;
em.initialize();

/*
addEvent=em.add;
removeEvent=em.remove;
triggerEvent=em.trigger;
*/

};

Please, read the comments into the code. They probably respond to some questions.

Also take into account that this code hasn't been reviewed for more than five years. Not only it has not been particularly tested against IE8+ and Chrome, but also I was not the coder I am now. Anyway I tend to do defensive programming, so I'm pretty sure it still performs well in any browser.

If you guys are still with MediaTemple, I've got a pretty decent build script for their (ve) line of virtual servers.  I've got a number of clients using it...

You may need to start putting echo() statements throughout your gen code to find out.

Also, it sounds like you're still on the v0.3.x version of qcodo... if so, note that there are several things that are incompatible with 5.3.x of PHP.

So your options at that point are to stick with 5.2.x of PHP or upgarde to v0.4.x of Qcodo.  Just a thought.

Here's the raw script
<?php
$con = mysql_connect(“localhost”,”root”,””);
if (!$con)
 {
 die('Could not connect: ' . mysql_error());
 }

mysql_select_db(“uloop_prod”, $con);

$result = mysql_query(“SELECT * FROM person limit 10”);

while($row = mysql_fetch_array($result))
 {
 echo $row['first_name'] . " " . $row['last_name'];
 echo “\n”;
 }

mysql_close($con);

?>

Also tried putting it into a cursor, but the InsantiateCursor method is not defined.

Also, what happens if you do a QQ::All() query and stuff it into a cursor?

e.g.

<?php
    $objCursor = School::QueryCursor(QQ::All());
    while ($objSchool = School::InsantiateCursor($objCursor)) {
        print($objSchool->Id . "\r\n");
    }
?>

Let me know...